core/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.1
#
# 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-2026 IMP Inventors. All rights reserved.



import functools



from sys import version_info as _swig_python_version_info
import _IMP_core

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class IMP_CORE_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_CORE_SwigPyIterator class."""

    thisown = 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

    def value(self):
        r"""value(IMP_CORE_SwigPyIterator self) -> PyObject *"""
        return _IMP_core.IMP_CORE_SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

# Register IMP_CORE_SwigPyIterator in _IMP_core:
_IMP_core.IMP_CORE_SwigPyIterator_swigregister(IMP_CORE_SwigPyIterator)

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

IMP_DEBUG = _IMP_core.IMP_DEBUG

IMP_RELEASE = _IMP_core.IMP_RELEASE

IMP_SILENT = _IMP_core.IMP_SILENT

IMP_PROGRESS = _IMP_core.IMP_PROGRESS

IMP_TERSE = _IMP_core.IMP_TERSE

IMP_VERBOSE = _IMP_core.IMP_VERBOSE

IMP_MEMORY = _IMP_core.IMP_MEMORY

IMP_NONE = _IMP_core.IMP_NONE

IMP_USAGE = _IMP_core.IMP_USAGE

IMP_INTERNAL = _IMP_core.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_core.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_core.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_core.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_core.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_core.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_core.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_core.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_core.IMP_KERNEL_HAS_BOOST_SYSTEM

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_core.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_core.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_core.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_core.IMPKERNEL_SHOW_WARNINGS


import sys
class _DirectorObjects:
    """@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):
    r"""Proxy of C++ std::ostream class."""

    thisown = 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):
        r"""write(_ostream self, char const * osa_buf)"""
        return _IMP_core._ostream_write(self, osa_buf)

# Register _ostream in _IMP_core:
_IMP_core._ostream_swigregister(_ostream)
IMP_C_OPEN_BINARY = _IMP_core.IMP_C_OPEN_BINARY

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_core.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_NUMPY = _IMP_core.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_core.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_core.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_core.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_CGAL = _IMP_core.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_core.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_core.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_core.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_core.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_core.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_CGAL = _IMP_core.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_core.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_core.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_core.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_core.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_core.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_core.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_core.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_core.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_CORE_HAS_IMP_CGAL = _IMP_core.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_core.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_core.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_core.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_core.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_CGAL = _IMP_core.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_core.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_core.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_core.IMPCORE_SHOW_WARNINGS

class _OpenCubicSplineBase(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::score_functor::ScoreUnaryFunction< IMP::score_functor::OpenCubicSpline > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(_OpenCubicSplineBase self, IMP::score_functor::OpenCubicSpline const & score, std::string name="UnaryFunction%1%") -> _OpenCubicSplineBase"""
        _IMP_core._OpenCubicSplineBase_swiginit(self, _IMP_core.new__OpenCubicSplineBase(*args))

    def get_version_info(self):
        r"""get_version_info(_OpenCubicSplineBase self) -> VersionInfo"""
        return _IMP_core._OpenCubicSplineBase_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete__OpenCubicSplineBase

# Register _OpenCubicSplineBase in _IMP_core:
_IMP_core._OpenCubicSplineBase_swigregister(_OpenCubicSplineBase)

_object_types.append("MonteCarloMover")


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

_object_types.append("KClosePairsPairScore")


def _object_cast_to_KClosePairsPairScore(o):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_object_cast_to_RigidBodyUmbrella(Object o) -> RigidBodyUmbrella"""
    return _IMP_core._object_cast_to_RigidBodyUmbrella(o)

_object_types.append("_UpdateRigidBodyMembers")


def _object_cast_to__UpdateRigidBodyMembers(o):
    r"""_object_cast_to__UpdateRigidBodyMembers(Object o) -> _UpdateRigidBodyMembers"""
    return _IMP_core._object_cast_to__UpdateRigidBodyMembers(o)

_object_types.append("_AccumulateRigidBodyDerivatives")


def _object_cast_to__AccumulateRigidBodyDerivatives(o):
    r"""_object_cast_to__AccumulateRigidBodyDerivatives(Object o) -> _AccumulateRigidBodyDerivatives"""
    return _IMP_core._object_cast_to__AccumulateRigidBodyDerivatives(o)

_object_types.append("_RigidBodyNormalizeConstraint")


def _object_cast_to__RigidBodyNormalizeConstraint(o):
    r"""_object_cast_to__RigidBodyNormalizeConstraint(Object o) -> _RigidBodyNormalizeConstraint"""
    return _IMP_core._object_cast_to__RigidBodyNormalizeConstraint(o)

_object_types.append("_NormalizeRotation")


def _object_cast_to__NormalizeRotation(o):
    r"""_object_cast_to__NormalizeRotation(Object o) -> _NormalizeRotation"""
    return _IMP_core._object_cast_to__NormalizeRotation(o)

_object_types.append("_RigidBodyPositionConstraint")


def _object_cast_to__RigidBodyPositionConstraint(o):
    r"""_object_cast_to__RigidBodyPositionConstraint(Object o) -> _RigidBodyPositionConstraint"""
    return _IMP_core._object_cast_to__RigidBodyPositionConstraint(o)

_object_types.append("RigidClosePairsFinder")


def _object_cast_to_RigidClosePairsFinder(o):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_object_cast_to_MultipleBinormalRestraint(Object o) -> MultipleBinormalRestraint"""
    return _IMP_core._object_cast_to_MultipleBinormalRestraint(o)
class ClosePairsFinder(IMP._ParticleInputs, IMP.Object):
    r"""Proxy of C++ IMP::core::ClosePairsFinder class."""

    thisown = 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

    def get_close_pairs(self, *args):
        r"""
        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):
        r"""set_distance(ClosePairsFinder self, double d)"""
        return _IMP_core.ClosePairsFinder_set_distance(self, d)

    def get_distance(self):
        r"""get_distance(ClosePairsFinder self) -> double"""
        return _IMP_core.ClosePairsFinder_get_distance(self)
    def __get_pair_filters(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_pair_filters,  getfunc=self.get_pair_filter, erasefunc=self.erase_pair_filter,  appendfunc=self.add_pair_filter, extendfunc=self.add_pair_filters,  clearfunc=self.clear_pair_filters, indexfunc=self._python_index_pair_filter)  
    def __set_pair_filters(self, obj): IMP._list_util.set_varlist(self.pair_filters, obj)  
    def __del_pair_filters(self): IMP._list_util.del_varlist(self.pair_filters)       
    pair_filters = property(__get_pair_filters, __set_pair_filters, __del_pair_filters, doc="List of ##ucnames")  

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

    def _python_index_pair_filter(self, d, start, stop):
        r"""_python_index_pair_filter(ClosePairsFinder self, PairPredicate d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_core.ClosePairsFinder__python_index_pair_filter(self, d, start, stop)

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

    def set_pair_filters(self, ps):
        r"""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):
        r"""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):
        r"""add_pair_filter(ClosePairsFinder self, PairPredicate obj) -> unsigned int"""
        return _IMP_core.ClosePairsFinder_add_pair_filter(self, obj)

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

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

    def get_number_of_pair_filters(self):
        r"""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):
        r"""get_has_pair_filters(ClosePairsFinder self) -> bool"""
        return _IMP_core.ClosePairsFinder_get_has_pair_filters(self)

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

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

    def erase_pair_filter(self, i):
        r"""erase_pair_filter(ClosePairsFinder self, unsigned int i)"""
        return _IMP_core.ClosePairsFinder_erase_pair_filter(self, i)

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

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

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

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


# Register ClosePairsFinder in _IMP_core:
_IMP_core.ClosePairsFinder_swigregister(ClosePairsFinder)
class MonteCarloMoverResult(IMP._Value):
    r"""Proxy of C++ IMP::core::MonteCarloMoverResult class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(MonteCarloMoverResult self, IMP::ParticleIndexes i0=IMP::ParticleIndexes(), double i1=double()) -> MonteCarloMoverResult"""
        _IMP_core.MonteCarloMoverResult_swiginit(self, _IMP_core.new_MonteCarloMoverResult(*args))

    def __hash__(self):
        r"""__hash__(MonteCarloMoverResult self) -> std::size_t"""
        return _IMP_core.MonteCarloMoverResult___hash__(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register MonteCarloMoverResult in _IMP_core:
_IMP_core.MonteCarloMoverResult_swigregister(MonteCarloMoverResult)
class MonteCarloMover(IMP.ModelObject):
    r"""Proxy of C++ IMP::core::MonteCarloMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(MonteCarloMover self, Model m, std::string name) -> MonteCarloMover
        __init__(MonteCarloMover self) -> MonteCarloMover
        """
        if self.__class__ == MonteCarloMover:
            _self = None
        else:
            _self = self
        _IMP_core.MonteCarloMover_swiginit(self, _IMP_core.new_MonteCarloMover(_self, *args))

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




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

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

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

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

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

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

    def add_to_statistics(self, num_proposed, num_rejected):
        r"""add_to_statistics(MonteCarloMover self, unsigned int num_proposed, unsigned int num_rejected)"""
        return _IMP_core.MonteCarloMover_add_to_statistics(self, num_proposed, num_rejected)

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

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

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

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

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

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

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


    def do_show(self, out):
        pass

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


    def _get_jax(self):
        """Return a JAX implementation of this mover.
           Implement this method in a MonteCarloMover subclass to provide
           equivalent functionality using [JAX](https://docs.jax.dev/).
           See _wrap_jax for more information.
        """
        raise NotImplementedError(f"No JAX implementation for {self}")

    def _wrap_jax(self, init_func, propose_func, accept_func=None,
                  sync_func=None):
        """Create the return value for _get_jax.
           Use this method in _get_jax() to wrap the JAX functions
           with other mover-specific information.

           @param init_func a JAX function which is used to initialize this
                  mover. It is called with a single argument, a fresh JAX
                  random key, and should return a persistent state object.
                  This object may be the key itself, or any other Python object
                  that JAX understands.
           @param propose_func a JAX function which is called with the current
                  JAX Model and the mover's persistent state object.
                  It should return a new JAX Model with the move applied,
                  a new persistent state, and the proposal ratio. If the move
                  is rejected then the new JAX Model will be discarded.
                  However, the mover's persistent state is updated for both
                  accepted and rejected moves.
           @param accept_func if provided, a JAX function which is called
                  after each accepted Monte Carlo move, with the persistent
                  state object. It should return a new persistent state.
           @param sync_func If provided, a Python function which is called
                  at the end of a Monte Carlo sampling run to sync mover
                  data back to IMP. It is called with the persistent state
                  and the IMP Mover object.
        """
        from IMP.core._jax_util import JAXMoverInfo
        return JAXMoverInfo(init_func, propose_func, accept_func, sync_func)

    __swig_destroy__ = _IMP_core.delete_MonteCarloMover
    def __disown__(self):
        self.this.disown()
        _IMP_core.disown_MonteCarloMover(self)
        return weakref.proxy(self)

    def do_destroy(self):
        r"""do_destroy(MonteCarloMover self)"""
        return _IMP_core.MonteCarloMover_do_destroy(self)

    def handle_set_has_required_score_states(self, arg0):
        r"""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):
        r"""do_get_inputs(MonteCarloMover self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.MonteCarloMover_do_get_inputs(self)

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

# Register MonteCarloMover in _IMP_core:
_IMP_core.MonteCarloMover_swigregister(MonteCarloMover)
class XYZ(IMP.Decorator):
    r"""Proxy of C++ IMP::core::XYZ class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __init__(self, *args):
        r"""
        __init__(XYZ self) -> XYZ
        __init__(XYZ self, Model m, ParticleIndex id) -> XYZ
        __init__(XYZ self, _ParticleAdaptor d) -> XYZ
        """
        _IMP_core.XYZ_swiginit(self, _IMP_core.new_XYZ(*args))

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

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

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

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

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

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

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

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

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

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

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

    def add_to_derivatives(self, v, d):
        r"""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):
        r"""get_coordinates_are_optimized(XYZ self) -> bool"""
        return _IMP_core.XYZ_get_coordinates_are_optimized(self)

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

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

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

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(XYZ self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(XYZ self, SparseIntKey a0, IMP::Int a1)
        add_attribute(XYZ self, SparseStringKey a0, IMP::String a1)
        add_attribute(XYZ self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.XYZ_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(XYZ self, SparseFloatKey a0) -> IMP::Float
        get_value(XYZ self, SparseIntKey a0) -> IMP::Int
        get_value(XYZ self, SparseStringKey a0) -> IMP::String
        get_value(XYZ self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.XYZ_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(XYZ self, SparseFloatKey a0, IMP::Float a1)
        set_value(XYZ self, SparseIntKey a0, IMP::Int a1)
        set_value(XYZ self, SparseStringKey a0, IMP::String a1)
        set_value(XYZ self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.XYZ_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(XYZ self, SparseFloatKey a0)
        remove_attribute(XYZ self, SparseIntKey a0)
        remove_attribute(XYZ self, SparseStringKey a0)
        remove_attribute(XYZ self, SparseParticleIndexKey a0)
        """
        return _IMP_core.XYZ_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(XYZ self, SparseFloatKey a0) -> bool
        has_attribute(XYZ self, SparseIntKey a0) -> bool
        has_attribute(XYZ self, SparseStringKey a0) -> bool
        has_attribute(XYZ self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.XYZ_has_attribute(self, *args)

    def get_derivative(self, *args):
        r"""
        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):
        r"""get_name(XYZ self) -> std::string"""
        return _IMP_core.XYZ_get_name(self)

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

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

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

    def add_to_derivative(self, *args):
        r"""
        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):
        r"""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):
        r"""get_is_optimized(XYZ self, FloatKey a0) -> bool"""
        return _IMP_core.XYZ_get_is_optimized(self, a0)

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

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

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

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

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

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

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

    def __hash__(self):
        r"""__hash__(XYZ self) -> std::size_t"""
        return _IMP_core.XYZ___hash__(self)

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(XYZ self) -> PyObject *"""
        return _IMP_core.XYZ__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XYZ self, PyObject * p)"""
        return _IMP_core.XYZ__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_XYZ

# Register XYZ in _IMP_core:
_IMP_core.XYZ_swigregister(XYZ)

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

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

def get_dihedral(a, b, c, d):
    r"""get_dihedral(XYZ a, XYZ b, XYZ c, XYZ d) -> double"""
    return _IMP_core.get_dihedral(a, b, c, d)
class XYZR(XYZ):
    r"""Proxy of C++ IMP::core::XYZR class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(XYZR self) -> XYZR
        __init__(XYZR self, Model m, ParticleIndex id) -> XYZR
        __init__(XYZR self, _ParticleAdaptor d) -> XYZR
        """
        _IMP_core.XYZR_swiginit(self, _IMP_core.new_XYZR(*args))

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

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

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

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

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

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

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

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

    def add_to_radius_derivative(self, v, d):
        r"""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):
        r"""
        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)
        add_attribute(XYZR self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(XYZR self, SparseIntKey a0, IMP::Int a1)
        add_attribute(XYZR self, SparseStringKey a0, IMP::String a1)
        add_attribute(XYZR self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.XYZR_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(XYZR self, SparseFloatKey a0) -> IMP::Float
        get_value(XYZR self, SparseIntKey a0) -> IMP::Int
        get_value(XYZR self, SparseStringKey a0) -> IMP::String
        get_value(XYZR self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.XYZR_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(XYZR self, SparseFloatKey a0, IMP::Float a1)
        set_value(XYZR self, SparseIntKey a0, IMP::Int a1)
        set_value(XYZR self, SparseStringKey a0, IMP::String a1)
        set_value(XYZR self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.XYZR_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(XYZR self, SparseFloatKey a0)
        remove_attribute(XYZR self, SparseIntKey a0)
        remove_attribute(XYZR self, SparseStringKey a0)
        remove_attribute(XYZR self, SparseParticleIndexKey a0)
        """
        return _IMP_core.XYZR_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(XYZR self, SparseFloatKey a0) -> bool
        has_attribute(XYZR self, SparseIntKey a0) -> bool
        has_attribute(XYZR self, SparseStringKey a0) -> bool
        has_attribute(XYZR self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.XYZR_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(XYZR self, FloatKey a0) -> bool"""
        return _IMP_core.XYZR_get_is_optimized(self, a0)

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

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

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

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

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

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

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

    def __hash__(self):
        r"""__hash__(XYZR self) -> std::size_t"""
        return _IMP_core.XYZR___hash__(self)

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(XYZR self) -> PyObject *"""
        return _IMP_core.XYZR__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XYZR self, PyObject * p)"""
        return _IMP_core.XYZR__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_XYZR

# Register XYZR in _IMP_core:
_IMP_core.XYZR_swigregister(XYZR)

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

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

def get_enclosing_sphere(v):
    r"""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):
    r"""create_xyzr_particles(Model m, unsigned int num, IMP::Float radius, IMP::Float box_side=10) -> IMP::core::XYZRs"""
    return _IMP_core.create_xyzr_particles(m, num, radius, box_side)
class XYZRGeometry(IMP.display.SingletonGeometry):
    r"""Proxy of C++ IMP::core::XYZRGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(XYZRGeometry self, Particle p) -> XYZRGeometry
        __init__(XYZRGeometry self, XYZR d) -> XYZRGeometry
        """
        _IMP_core.XYZRGeometry_swiginit(self, _IMP_core.new_XYZRGeometry(*args))

    def get_version_info(self):
        r"""get_version_info(XYZRGeometry self) -> VersionInfo"""
        return _IMP_core.XYZRGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_XYZRGeometry

    def __str__(self):
        r"""__str__(XYZRGeometry self) -> std::string"""
        return _IMP_core.XYZRGeometry___str__(self)

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

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


# Register XYZRGeometry in _IMP_core:
_IMP_core.XYZRGeometry_swigregister(XYZRGeometry)
class XYZRsGeometry(IMP.display.SingletonsGeometry):
    r"""Proxy of C++ IMP::core::XYZRsGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, sc):
        r"""__init__(XYZRsGeometry self, SingletonContainer sc) -> XYZRsGeometry"""
        _IMP_core.XYZRsGeometry_swiginit(self, _IMP_core.new_XYZRsGeometry(sc))

    def get_version_info(self):
        r"""get_version_info(XYZRsGeometry self) -> VersionInfo"""
        return _IMP_core.XYZRsGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_XYZRsGeometry

    def __str__(self):
        r"""__str__(XYZRsGeometry self) -> std::string"""
        return _IMP_core.XYZRsGeometry___str__(self)

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

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


# Register XYZRsGeometry in _IMP_core:
_IMP_core.XYZRsGeometry_swigregister(XYZRsGeometry)
class XYZDerivativeGeometry(IMP.display.SingletonGeometry):
    r"""Proxy of C++ IMP::core::XYZDerivativeGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(XYZDerivativeGeometry self, Particle p) -> XYZDerivativeGeometry
        __init__(XYZDerivativeGeometry self, XYZ d) -> XYZDerivativeGeometry
        """
        _IMP_core.XYZDerivativeGeometry_swiginit(self, _IMP_core.new_XYZDerivativeGeometry(*args))

    def get_version_info(self):
        r"""get_version_info(XYZDerivativeGeometry self) -> VersionInfo"""
        return _IMP_core.XYZDerivativeGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_XYZDerivativeGeometry

    def __str__(self):
        r"""__str__(XYZDerivativeGeometry self) -> std::string"""
        return _IMP_core.XYZDerivativeGeometry___str__(self)

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

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


# Register XYZDerivativeGeometry in _IMP_core:
_IMP_core.XYZDerivativeGeometry_swigregister(XYZDerivativeGeometry)
class XYZDerivativesGeometry(IMP.display.SingletonsGeometry):
    r"""Proxy of C++ IMP::core::XYZDerivativesGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, sc):
        r"""__init__(XYZDerivativesGeometry self, SingletonContainer sc) -> XYZDerivativesGeometry"""
        _IMP_core.XYZDerivativesGeometry_swiginit(self, _IMP_core.new_XYZDerivativesGeometry(sc))

    def get_version_info(self):
        r"""get_version_info(XYZDerivativesGeometry self) -> VersionInfo"""
        return _IMP_core.XYZDerivativesGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_XYZDerivativesGeometry

    def __str__(self):
        r"""__str__(XYZDerivativesGeometry self) -> std::string"""
        return _IMP_core.XYZDerivativesGeometry___str__(self)

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

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


# Register XYZDerivativesGeometry in _IMP_core:
_IMP_core.XYZDerivativesGeometry_swigregister(XYZDerivativesGeometry)
class EdgePairGeometry(IMP.display.PairGeometry):
    r"""Proxy of C++ IMP::core::EdgePairGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, pp):
        r"""__init__(EdgePairGeometry self, IMP::ParticlePair const & pp) -> EdgePairGeometry"""
        _IMP_core.EdgePairGeometry_swiginit(self, _IMP_core.new_EdgePairGeometry(pp))

    def get_version_info(self):
        r"""get_version_info(EdgePairGeometry self) -> VersionInfo"""
        return _IMP_core.EdgePairGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_EdgePairGeometry

    def __str__(self):
        r"""__str__(EdgePairGeometry self) -> std::string"""
        return _IMP_core.EdgePairGeometry___str__(self)

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

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


# Register EdgePairGeometry in _IMP_core:
_IMP_core.EdgePairGeometry_swigregister(EdgePairGeometry)
class EdgePairsGeometry(IMP.display.PairsGeometry):
    r"""Proxy of C++ IMP::core::EdgePairsGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, sc):
        r"""__init__(EdgePairsGeometry self, PairContainer sc) -> EdgePairsGeometry"""
        _IMP_core.EdgePairsGeometry_swiginit(self, _IMP_core.new_EdgePairsGeometry(sc))

    def get_version_info(self):
        r"""get_version_info(EdgePairsGeometry self) -> VersionInfo"""
        return _IMP_core.EdgePairsGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_EdgePairsGeometry

    def __str__(self):
        r"""__str__(EdgePairsGeometry self) -> std::string"""
        return _IMP_core.EdgePairsGeometry___str__(self)

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

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


# Register EdgePairsGeometry in _IMP_core:
_IMP_core.EdgePairsGeometry_swigregister(EdgePairsGeometry)
class Direction(IMP.Decorator):
    r"""Proxy of C++ IMP::core::Direction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __init__(self, *args):
        r"""
        __init__(Direction self) -> Direction
        __init__(Direction self, Model m, ParticleIndex id) -> Direction
        __init__(Direction self, _ParticleAdaptor d) -> Direction
        """
        _IMP_core.Direction_swiginit(self, _IMP_core.new_Direction(*args))

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

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

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

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

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

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

    def add_to_direction_derivative(self, i, v, d):
        r"""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):
        r"""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):
        r"""get_direction_is_optimized(Direction self) -> bool"""
        return _IMP_core.Direction_get_direction_is_optimized(self)

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

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Direction self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Direction self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Direction self, SparseStringKey a0, IMP::String a1)
        add_attribute(Direction self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Direction_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Direction self, SparseFloatKey a0) -> IMP::Float
        get_value(Direction self, SparseIntKey a0) -> IMP::Int
        get_value(Direction self, SparseStringKey a0) -> IMP::String
        get_value(Direction self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Direction_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Direction self, SparseFloatKey a0, IMP::Float a1)
        set_value(Direction self, SparseIntKey a0, IMP::Int a1)
        set_value(Direction self, SparseStringKey a0, IMP::String a1)
        set_value(Direction self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Direction_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Direction self, SparseFloatKey a0)
        remove_attribute(Direction self, SparseIntKey a0)
        remove_attribute(Direction self, SparseStringKey a0)
        remove_attribute(Direction self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Direction_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Direction self, SparseFloatKey a0) -> bool
        has_attribute(Direction self, SparseIntKey a0) -> bool
        has_attribute(Direction self, SparseStringKey a0) -> bool
        has_attribute(Direction self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Direction_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Direction self, FloatKey a0) -> bool"""
        return _IMP_core.Direction_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Direction self) -> PyObject *"""
        return _IMP_core.Direction__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Direction self, PyObject * p)"""
        return _IMP_core.Direction__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Direction

# Register Direction in _IMP_core:
_IMP_core.Direction_swigregister(Direction)

def get_angle(a, b):
    r"""get_angle(Direction a, Direction b) -> double"""
    return _IMP_core.get_angle(a, b)
class DirectionAngle(IMP.Decorator):
    r"""Proxy of C++ IMP::core::DirectionAngle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(DirectionAngle self) -> DirectionAngle
        __init__(DirectionAngle self, Model m, ParticleIndex id) -> DirectionAngle
        __init__(DirectionAngle self, _ParticleAdaptor d) -> DirectionAngle
        """
        _IMP_core.DirectionAngle_swiginit(self, _IMP_core.new_DirectionAngle(*args))

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

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

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

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

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

    def get_particle(self, *args):
        r"""
        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):
        r"""
        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):
        r"""get_angle(DirectionAngle self) -> IMP::Float"""
        return _IMP_core.DirectionAngle_get_angle(self)

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

    def add_to_angle_derivative(self, v, d):
        r"""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):
        r"""
        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)
        add_attribute(DirectionAngle self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(DirectionAngle self, SparseIntKey a0, IMP::Int a1)
        add_attribute(DirectionAngle self, SparseStringKey a0, IMP::String a1)
        add_attribute(DirectionAngle self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.DirectionAngle_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(DirectionAngle self, SparseFloatKey a0) -> IMP::Float
        get_value(DirectionAngle self, SparseIntKey a0) -> IMP::Int
        get_value(DirectionAngle self, SparseStringKey a0) -> IMP::String
        get_value(DirectionAngle self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.DirectionAngle_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(DirectionAngle self, SparseFloatKey a0, IMP::Float a1)
        set_value(DirectionAngle self, SparseIntKey a0, IMP::Int a1)
        set_value(DirectionAngle self, SparseStringKey a0, IMP::String a1)
        set_value(DirectionAngle self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.DirectionAngle_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(DirectionAngle self, SparseFloatKey a0)
        remove_attribute(DirectionAngle self, SparseIntKey a0)
        remove_attribute(DirectionAngle self, SparseStringKey a0)
        remove_attribute(DirectionAngle self, SparseParticleIndexKey a0)
        """
        return _IMP_core.DirectionAngle_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(DirectionAngle self, SparseFloatKey a0) -> bool
        has_attribute(DirectionAngle self, SparseIntKey a0) -> bool
        has_attribute(DirectionAngle self, SparseStringKey a0) -> bool
        has_attribute(DirectionAngle self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.DirectionAngle_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(DirectionAngle self, FloatKey a0) -> bool"""
        return _IMP_core.DirectionAngle_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(DirectionAngle self) -> PyObject *"""
        return _IMP_core.DirectionAngle__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DirectionAngle self, PyObject * p)"""
        return _IMP_core.DirectionAngle__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_DirectionAngle

# Register DirectionAngle in _IMP_core:
_IMP_core.DirectionAngle_swigregister(DirectionAngle)
class Surface(XYZ):
    r"""Proxy of C++ IMP::core::Surface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    @staticmethod
    def do_setup_particle(*args):
        r"""
        do_setup_particle(Model m, ParticleIndex pi, Vector3D center=IMP::algebra::Vector3D(0, 0, 0), Vector3D normal=IMP::algebra::Vector3D(0, 0, 1))
        do_setup_particle(Model m, ParticleIndex pi, ReferenceFrame3D rf)
        """
        return _IMP_core.Surface_do_setup_particle(*args)

    def __init__(self, *args):
        r"""
        __init__(Surface self) -> Surface
        __init__(Surface self, Model m, ParticleIndex id) -> Surface
        __init__(Surface self, _ParticleAdaptor d) -> Surface
        """
        _IMP_core.Surface_swiginit(self, _IMP_core.new_Surface(*args))

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

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

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

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

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

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

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

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

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

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

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

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

    def add_to_normal_derivative(self, i, v, d):
        r"""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):
        r"""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):
        r"""get_normal_is_optimized(Surface self) -> bool"""
        return _IMP_core.Surface_get_normal_is_optimized(self)

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

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

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

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

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

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

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

    def get_distance_to_center(self, v):
        r"""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):
        r"""set_reference_frame(Surface self, ReferenceFrame3D rf)"""
        return _IMP_core.Surface_set_reference_frame(self, rf)

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Surface self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Surface self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Surface self, SparseStringKey a0, IMP::String a1)
        add_attribute(Surface self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Surface_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Surface self, SparseFloatKey a0) -> IMP::Float
        get_value(Surface self, SparseIntKey a0) -> IMP::Int
        get_value(Surface self, SparseStringKey a0) -> IMP::String
        get_value(Surface self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Surface_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Surface self, SparseFloatKey a0, IMP::Float a1)
        set_value(Surface self, SparseIntKey a0, IMP::Int a1)
        set_value(Surface self, SparseStringKey a0, IMP::String a1)
        set_value(Surface self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Surface_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Surface self, SparseFloatKey a0)
        remove_attribute(Surface self, SparseIntKey a0)
        remove_attribute(Surface self, SparseStringKey a0)
        remove_attribute(Surface self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Surface_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Surface self, SparseFloatKey a0) -> bool
        has_attribute(Surface self, SparseIntKey a0) -> bool
        has_attribute(Surface self, SparseStringKey a0) -> bool
        has_attribute(Surface self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Surface_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Surface self, FloatKey a0) -> bool"""
        return _IMP_core.Surface_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Surface self) -> PyObject *"""
        return _IMP_core.Surface__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Surface self, PyObject * p)"""
        return _IMP_core.Surface__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Surface

# Register Surface in _IMP_core:
_IMP_core.Surface_swigregister(Surface)

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

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

def get_distance(*args):
    r"""
    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):
    r"""Proxy of C++ IMP::core::SurfaceGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SurfaceGeometry self, std::string n="SurfaceGeometry") -> SurfaceGeometry
        __init__(SurfaceGeometry self, Surface s, std::string const n="SurfaceGeometry") -> SurfaceGeometry
        __init__(SurfaceGeometry self, Surface s, Color c, std::string n="SurfaceGeometry") -> SurfaceGeometry
        """
        _IMP_core.SurfaceGeometry_swiginit(self, _IMP_core.new_SurfaceGeometry(*args))

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

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

    def get_version_info(self):
        r"""get_version_info(SurfaceGeometry self) -> VersionInfo"""
        return _IMP_core.SurfaceGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceGeometry

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

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

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


# Register SurfaceGeometry in _IMP_core:
_IMP_core.SurfaceGeometry_swigregister(SurfaceGeometry)

def create_geometry(*args):
    r"""create_geometry(Surface s, std::string name=std::string("SurfaceGeometry%1%")) -> SurfaceGeometry"""
    return _IMP_core.create_geometry(*args)
class SurfaceGeometryConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::SurfaceGeometryConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, s, g):
        r"""__init__(SurfaceGeometryConstraint self, Surface s, SurfaceGeometry g) -> SurfaceGeometryConstraint"""
        _IMP_core.SurfaceGeometryConstraint_swiginit(self, _IMP_core.new_SurfaceGeometryConstraint(s, g))

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(SurfaceGeometryConstraint self) -> VersionInfo"""
        return _IMP_core.SurfaceGeometryConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceGeometryConstraint

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

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

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


# Register SurfaceGeometryConstraint in _IMP_core:
_IMP_core.SurfaceGeometryConstraint_swigregister(SurfaceGeometryConstraint)

def get_constrained_surface_geometry(*args):
    r"""get_constrained_surface_geometry(Surface s, std::string name="SurfaceGeometry%1%") -> SurfaceGeometry"""
    return _IMP_core.get_constrained_surface_geometry(*args)
class LateralSurfaceConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::LateralSurfaceConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, s, d):
        r"""__init__(LateralSurfaceConstraint self, Surface s, XYZ d) -> LateralSurfaceConstraint"""
        _IMP_core.LateralSurfaceConstraint_swiginit(self, _IMP_core.new_LateralSurfaceConstraint(s, d))

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

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

    def get_version_info(self):
        r"""get_version_info(LateralSurfaceConstraint self) -> VersionInfo"""
        return _IMP_core.LateralSurfaceConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_LateralSurfaceConstraint

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

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

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


# Register LateralSurfaceConstraint in _IMP_core:
_IMP_core.LateralSurfaceConstraint_swigregister(LateralSurfaceConstraint)
class AngleTripletScore(IMP.TripletScore):
    r"""Proxy of C++ IMP::core::AngleTripletScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(AngleTripletScore self, UnaryFunction f) -> AngleTripletScore
        __init__(AngleTripletScore self) -> AngleTripletScore
        """
        _IMP_core.AngleTripletScore_swiginit(self, _IMP_core.new_AngleTripletScore(*args))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(AngleTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AngleTripletScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(AngleTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AngleTripletScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(AngleTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AngleTripletScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(AngleTripletScore self, Model m, IMP::ParticleIndexTriplets const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AngleTripletScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(AngleTripletScore self) -> VersionInfo"""
        return _IMP_core.AngleTripletScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_AngleTripletScore

    def __str__(self):
        r"""__str__(AngleTripletScore self) -> std::string"""
        return _IMP_core.AngleTripletScore___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(AngleTripletScore self) -> PyObject *"""
        return _IMP_core.AngleTripletScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AngleTripletScore self, PyObject * p)"""
        return _IMP_core.AngleTripletScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register AngleTripletScore in _IMP_core:
_IMP_core.AngleTripletScore_swigregister(AngleTripletScore)
class BallMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::BallMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(BallMover self, Model m, ParticleIndex pi, IMP::FloatKeys const & vars, double radius) -> BallMover
        __init__(BallMover self, Model m, ParticleIndex pi, double radius) -> BallMover
        __init__(BallMover self, Model m, IMP::ParticleIndexes const & pis, IMP::FloatKeys const & vars, IMP::Float radius) -> BallMover
        __init__(BallMover self, Model m, IMP::ParticleIndexes const & pis, IMP::Float radius) -> BallMover
        __init__(BallMover self) -> BallMover
        """
        _IMP_core.BallMover_swiginit(self, _IMP_core.new_BallMover(*args))

    def set_radius(self, radius):
        r"""set_radius(BallMover self, IMP::Float radius)"""
        return _IMP_core.BallMover_set_radius(self, radius)

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

    def get_indexes(self):
        r"""get_indexes(BallMover self) -> IMP::ParticleIndexes"""
        return _IMP_core.BallMover_get_indexes(self)

    def get_keys(self):
        r"""get_keys(BallMover self) -> IMP::FloatKeys"""
        return _IMP_core.BallMover_get_keys(self)

    def get_version_info(self):
        r"""get_version_info(BallMover self) -> VersionInfo"""
        return _IMP_core.BallMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_BallMover

    def __str__(self):
        r"""__str__(BallMover self) -> std::string"""
        return _IMP_core.BallMover___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(BallMover self) -> PyObject *"""
        return _IMP_core.BallMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BallMover self, PyObject * p)"""
        return _IMP_core.BallMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import jax.random
        from IMP.algebra._jax_util import get_random_vector_in_3d_sphere
        indexes = self.get_indexes()
        keys = frozenset(self.get_keys())
        if keys != frozenset(IMP.core.XYZ.get_xyz_keys()):
            raise NotImplementedError("Only works for XYZ")
        radius = self.get_radius()

        def init_func(key):
            return key

        def propose_func(jm, key):
            key, subkey = jax.random.split(key)
            v = get_random_vector_in_3d_sphere(subkey, radius)
            jm['xyz'] = jm['xyz'].at[indexes].add(v)
            return jm, key, 1.0
        return self._wrap_jax(init_func, propose_func)


# Register BallMover in _IMP_core:
_IMP_core.BallMover_swigregister(BallMover)
class SerialMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::SerialMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SerialMover self, IMP::core::MonteCarloMoversTemp const & mvs) -> SerialMover
        __init__(SerialMover self) -> SerialMover
        """
        _IMP_core.SerialMover_swiginit(self, _IMP_core.new_SerialMover(*args))

    def get_movers(self):
        r"""get_movers(SerialMover self) -> IMP::core::MonteCarloMovers const &"""
        return _IMP_core.SerialMover_get_movers(self)

    def get_version_info(self):
        r"""get_version_info(SerialMover self) -> VersionInfo"""
        return _IMP_core.SerialMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SerialMover

    def __str__(self):
        r"""__str__(SerialMover self) -> std::string"""
        return _IMP_core.SerialMover___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(SerialMover self) -> PyObject *"""
        return _IMP_core.SerialMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SerialMover self, PyObject * p)"""
        return _IMP_core.SerialMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import jax.random
        import jax.lax
        import jax.numpy as jnp
        from IMP.core._jax_util import _SerialMover
        movers = [m.get_derived_object()._get_jax()
                  for m in self.get_movers()]

        def sub_propose_func(jm, sms, i):
            """Call the propose_func of the ith mover"""
            jm, sms.mover_state[i], ratio = movers[i].propose_func(
                jm, sms.mover_state[i])
            sms.proposed_mover_steps = sms.proposed_mover_steps.at[i].add(1)
            return jm, sms, ratio

        sub_propose_funcs = [functools.partial(sub_propose_func, i=i)
                             for i in range(len(movers))]

        def init_func(key):
    # Initialize all movers and store their state in ours
            mover_state = []
            for m in movers:
                key, subkey = jax.random.split(key)
                mover_state.append(m.init_func(subkey))
            return _SerialMover(
                imov=-1, mover_state=mover_state,
                proposed_mover_steps=jnp.zeros(len(movers), dtype=int),
                accepted_mover_steps=jnp.zeros(len(movers), dtype=int))

        def propose_func(jm, sms):
            sms.imov = jnp.mod(sms.imov + 1, len(movers))
            return jax.lax.switch(sms.imov, sub_propose_funcs, jm, sms)

        def accept_func(sms):
    # Update statistics for the chosen mover
            sms.accepted_mover_steps = \
                sms.accepted_mover_steps.at[sms.imov].add(1)
            return sms

        def sync_func(imp_mover, sms):
    # Copy submover statistics back to IMP Movers
            for i, mover in enumerate(imp_mover.get_movers()):
                mover.add_to_statistics(
                    sms.proposed_mover_steps[i],
                    sms.proposed_mover_steps[i] - sms.accepted_mover_steps[i])

        return self._wrap_jax(init_func, propose_func, accept_func, sync_func)


# Register SerialMover in _IMP_core:
_IMP_core.SerialMover_swigregister(SerialMover)
class SubsetMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::SubsetMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SubsetMover self, IMP::core::MonteCarloMoversTemp const & mvs, unsigned int n) -> SubsetMover
        __init__(SubsetMover self) -> SubsetMover
        """
        _IMP_core.SubsetMover_swiginit(self, _IMP_core.new_SubsetMover(*args))

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

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

    def get_version_info(self):
        r"""get_version_info(SubsetMover self) -> VersionInfo"""
        return _IMP_core.SubsetMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SubsetMover

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(SubsetMover self) -> PyObject *"""
        return _IMP_core.SubsetMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SubsetMover self, PyObject * p)"""
        return _IMP_core.SubsetMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register SubsetMover in _IMP_core:
_IMP_core.SubsetMover_swigregister(SubsetMover)
class DirectionMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::DirectionMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(DirectionMover self, Model m, ParticleIndex pi, IMP::Float max_rotation, IMP::Float reflect_probability) -> DirectionMover
        __init__(DirectionMover self, Direction d, IMP::Float max_rotation, IMP::Float reflect_probability) -> DirectionMover
        __init__(DirectionMover self) -> DirectionMover
        """
        _IMP_core.DirectionMover_swiginit(self, _IMP_core.new_DirectionMover(*args))

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(DirectionMover self) -> VersionInfo"""
        return _IMP_core.DirectionMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DirectionMover

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(DirectionMover self) -> PyObject *"""
        return _IMP_core.DirectionMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DirectionMover self, PyObject * p)"""
        return _IMP_core.DirectionMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register DirectionMover in _IMP_core:
_IMP_core.DirectionMover_swigregister(DirectionMover)
class SurfaceMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::SurfaceMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SurfaceMover self, Model m, ParticleIndex pi, IMP::Float max_translation, IMP::Float max_rotation, IMP::Float reflect_probability) -> SurfaceMover
        __init__(SurfaceMover self, Surface s, IMP::Float max_translation, IMP::Float max_rotation, IMP::Float reflect_probability) -> SurfaceMover
        __init__(SurfaceMover self) -> SurfaceMover
        """
        _IMP_core.SurfaceMover_swiginit(self, _IMP_core.new_SurfaceMover(*args))

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

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

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(SurfaceMover self) -> VersionInfo"""
        return _IMP_core.SurfaceMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceMover

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(SurfaceMover self) -> PyObject *"""
        return _IMP_core.SurfaceMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SurfaceMover self, PyObject * p)"""
        return _IMP_core.SurfaceMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register SurfaceMover in _IMP_core:
_IMP_core.SurfaceMover_swigregister(SurfaceMover)
class BoxSweepClosePairsFinder(ClosePairsFinder):
    r"""Proxy of C++ IMP::core::BoxSweepClosePairsFinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self):
        r"""__init__(BoxSweepClosePairsFinder self) -> BoxSweepClosePairsFinder"""
        _IMP_core.BoxSweepClosePairsFinder_swiginit(self, _IMP_core.new_BoxSweepClosePairsFinder())

    def get_close_pairs(self, *args):
        r"""
        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):
        r"""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):
        r"""get_version_info(BoxSweepClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.BoxSweepClosePairsFinder_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_BoxSweepClosePairsFinder

    def __str__(self):
        r"""__str__(BoxSweepClosePairsFinder self) -> std::string"""
        return _IMP_core.BoxSweepClosePairsFinder___str__(self)

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

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


# Register BoxSweepClosePairsFinder in _IMP_core:
_IMP_core.BoxSweepClosePairsFinder_swigregister(BoxSweepClosePairsFinder)
class CentroidOfRefined(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::CentroidOfRefined class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(CentroidOfRefined self, Refiner r, FloatKey weight=IMP::FloatKey(), IMP::FloatKeys ks=IMP::core::XYZ::get_xyz_keys()) -> CentroidOfRefined"""
        _IMP_core.CentroidOfRefined_swiginit(self, _IMP_core.new_CentroidOfRefined(*args))

    def get_refiner(self):
        r"""get_refiner(CentroidOfRefined self) -> Refiner"""
        return _IMP_core.CentroidOfRefined_get_refiner(self)

    def get_weight(self):
        r"""get_weight(CentroidOfRefined self) -> FloatKey"""
        return _IMP_core.CentroidOfRefined_get_weight(self)

    def get_keys(self):
        r"""get_keys(CentroidOfRefined self) -> IMP::FloatKeys"""
        return _IMP_core.CentroidOfRefined_get_keys(self)

    def get_is_weight_null(self):
        r"""get_is_weight_null(CentroidOfRefined self) -> bool"""
        return _IMP_core.CentroidOfRefined_get_is_weight_null(self)

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""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):
        r"""get_version_info(CentroidOfRefined self) -> VersionInfo"""
        return _IMP_core.CentroidOfRefined_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_CentroidOfRefined

    def __str__(self):
        r"""__str__(CentroidOfRefined self) -> std::string"""
        return _IMP_core.CentroidOfRefined___str__(self)

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

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


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        refined = [
            self.get_refiner().get_refined_indexes(m, IMP.ParticleIndex(index))
            for index in indexes]

        def apply_func_unweighted(jm):
            for ind, ref in zip(indexes, refined):
                xyz = jm['xyz']
                jm['xyz'] = xyz.at[ind].set(jnp.average(xyz[ref], axis=0))
            return jm

        def apply_func_weighted(jm, weight_key):
            for ind, ref in zip(indexes, refined):
                xyz = jm['xyz']
                weights = jm[weight_key][ref]
                jm['xyz'] = xyz.at[ind].set(
                    jnp.average(xyz[ref], axis=0, weights=weights))
            return jm

        keys = frozenset(self.get_keys())
        if keys != frozenset(IMP.core.XYZ.get_xyz_keys()):
            raise NotImplementedError("Only works for XYZ")

        if self.get_is_weight_null():
            return self._wrap_jax(apply_func_unweighted)
        else:
            weight_key = self.get_weight()
            return self._wrap_jax(
                functools.partial(apply_func_weighted,
                                  weight_key=weight_key.get_string()),
                keys=(weight_key,))


# Register CentroidOfRefined in _IMP_core:
_IMP_core.CentroidOfRefined_swigregister(CentroidOfRefined)
class Centroid(XYZ):
    r"""Proxy of C++ IMP::core::Centroid class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def get_constraint(self):
        r"""get_constraint(Centroid self) -> Constraint"""
        return _IMP_core.Centroid_get_constraint(self)

    def __init__(self, *args):
        r"""
        __init__(Centroid self) -> Centroid
        __init__(Centroid self, Model m, ParticleIndex id) -> Centroid
        __init__(Centroid self, _ParticleAdaptor d) -> Centroid
        """
        _IMP_core.Centroid_swiginit(self, _IMP_core.new_Centroid(*args))

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Centroid self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Centroid self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Centroid self, SparseStringKey a0, IMP::String a1)
        add_attribute(Centroid self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Centroid_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Centroid self, SparseFloatKey a0) -> IMP::Float
        get_value(Centroid self, SparseIntKey a0) -> IMP::Int
        get_value(Centroid self, SparseStringKey a0) -> IMP::String
        get_value(Centroid self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Centroid_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Centroid self, SparseFloatKey a0, IMP::Float a1)
        set_value(Centroid self, SparseIntKey a0, IMP::Int a1)
        set_value(Centroid self, SparseStringKey a0, IMP::String a1)
        set_value(Centroid self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Centroid_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Centroid self, SparseFloatKey a0)
        remove_attribute(Centroid self, SparseIntKey a0)
        remove_attribute(Centroid self, SparseStringKey a0)
        remove_attribute(Centroid self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Centroid_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Centroid self, SparseFloatKey a0) -> bool
        has_attribute(Centroid self, SparseIntKey a0) -> bool
        has_attribute(Centroid self, SparseStringKey a0) -> bool
        has_attribute(Centroid self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Centroid_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Centroid self, FloatKey a0) -> bool"""
        return _IMP_core.Centroid_get_is_optimized(self, a0)

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

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

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

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

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

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

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

    def __hash__(self):
        r"""__hash__(Centroid self) -> std::size_t"""
        return _IMP_core.Centroid___hash__(self)

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Centroid self) -> PyObject *"""
        return _IMP_core.Centroid__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Centroid self, PyObject * p)"""
        return _IMP_core.Centroid__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Centroid

# Register Centroid in _IMP_core:
_IMP_core.Centroid_swigregister(Centroid)
class ChecksScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::core::ChecksScoreState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ChecksScoreState self, Model m, double probability) -> ChecksScoreState
        __init__(ChecksScoreState self) -> ChecksScoreState
        """
        _IMP_core.ChecksScoreState_swiginit(self, _IMP_core.new_ChecksScoreState(*args))

    def get_number_of_checked(self):
        r"""get_number_of_checked(ChecksScoreState self) -> unsigned int"""
        return _IMP_core.ChecksScoreState_get_number_of_checked(self)

    def do_before_evaluate(self):
        r"""do_before_evaluate(ChecksScoreState self)"""
        return _IMP_core.ChecksScoreState_do_before_evaluate(self)

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

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

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

    def get_version_info(self):
        r"""get_version_info(ChecksScoreState self) -> VersionInfo"""
        return _IMP_core.ChecksScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ChecksScoreState

    def __str__(self):
        r"""__str__(ChecksScoreState self) -> std::string"""
        return _IMP_core.ChecksScoreState___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ChecksScoreState self) -> PyObject *"""
        return _IMP_core.ChecksScoreState__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ChecksScoreState self, PyObject * p)"""
        return _IMP_core.ChecksScoreState__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ChecksScoreState in _IMP_core:
_IMP_core.ChecksScoreState_swigregister(ChecksScoreState)
class ChildrenRefiner(IMP.Refiner):
    r"""Proxy of C++ IMP::core::ChildrenRefiner class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, tr):
        r"""__init__(ChildrenRefiner self, HierarchyTraits tr) -> ChildrenRefiner"""
        _IMP_core.ChildrenRefiner_swiginit(self, _IMP_core.new_ChildrenRefiner(tr))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(ChildrenRefiner self) -> VersionInfo"""
        return _IMP_core.ChildrenRefiner_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ChildrenRefiner

    def __str__(self):
        r"""__str__(ChildrenRefiner self) -> std::string"""
        return _IMP_core.ChildrenRefiner___str__(self)

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

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


# Register ChildrenRefiner in _IMP_core:
_IMP_core.ChildrenRefiner_swigregister(ChildrenRefiner)
class ClosedCubicSpline(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::ClosedCubicSpline class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, values, minrange, spacing):
        r"""__init__(ClosedCubicSpline self, IMP::Floats const & values, double minrange, double spacing) -> ClosedCubicSpline"""
        _IMP_core.ClosedCubicSpline_swiginit(self, _IMP_core.new_ClosedCubicSpline(values, minrange, spacing))

    def get_version_info(self):
        r"""get_version_info(ClosedCubicSpline self) -> VersionInfo"""
        return _IMP_core.ClosedCubicSpline_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ClosedCubicSpline

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

    def get_minrange(self):
        r"""get_minrange(ClosedCubicSpline self) -> IMP::Float"""
        return _IMP_core.ClosedCubicSpline_get_minrange(self)

    def get_spacing(self):
        r"""get_spacing(ClosedCubicSpline self) -> IMP::Float"""
        return _IMP_core.ClosedCubicSpline_get_spacing(self)

    def get_values(self):
        r"""get_values(ClosedCubicSpline self) -> IMP::Floats"""
        return _IMP_core.ClosedCubicSpline_get_values(self)

    def get_second_derivatives(self):
        r"""get_second_derivatives(ClosedCubicSpline self) -> IMP::Floats"""
        return _IMP_core.ClosedCubicSpline_get_second_derivatives(self)

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

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

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


    def _get_jax(self):
        import jax.numpy as jnp
        from IMP.core._jax_util import _spline
        def score(feature, minrange, spacing, values, second_derivs):
    # determine bin index and thus the cubic fragment to use:
            lowbin = jnp.array((feature - minrange) / spacing, dtype=int)
    # enforce periodicity - wrap around from n to 0
            highbin = jnp.remainder(lowbin + 1, len(values))
            return _spline(feature, minrange, lowbin, highbin, spacing,
                           values, second_derivs)
        return functools.partial(
            score, minrange=self.get_minrange(),
            spacing=self.get_spacing(), values=jnp.asarray(self.get_values()),
            second_derivs=jnp.asarray(self.get_second_derivatives()))


# Register ClosedCubicSpline in _IMP_core:
_IMP_core.ClosedCubicSpline_swigregister(ClosedCubicSpline)
class KClosePairsPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::KClosePairsPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, f, r, k=1):
        r"""__init__(KClosePairsPairScore self, PairScore f, Refiner r, int k=1) -> KClosePairsPairScore"""
        _IMP_core.KClosePairsPairScore_swiginit(self, _IMP_core.new_KClosePairsPairScore(f, r, k))

    def get_close_pairs(self, pp):
        r"""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):
        r"""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):
        r"""do_get_inputs(KClosePairsPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.KClosePairsPairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(KClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.KClosePairsPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(KClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.KClosePairsPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(KClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.KClosePairsPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(KClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.KClosePairsPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(KClosePairsPairScore self) -> VersionInfo"""
        return _IMP_core.KClosePairsPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_KClosePairsPairScore

    def __str__(self):
        r"""__str__(KClosePairsPairScore self) -> std::string"""
        return _IMP_core.KClosePairsPairScore___str__(self)

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

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


# Register KClosePairsPairScore in _IMP_core:
_IMP_core.KClosePairsPairScore_swigregister(KClosePairsPairScore)
class ClosePairsPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::ClosePairsPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, f, r, max_distance):
        r"""__init__(ClosePairsPairScore self, PairScore f, Refiner r, IMP::Float max_distance) -> ClosePairsPairScore"""
        _IMP_core.ClosePairsPairScore_swiginit(self, _IMP_core.new_ClosePairsPairScore(f, r, max_distance))

    def get_close_pairs(self, pp):
        r"""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):
        r"""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):
        r"""do_get_inputs(ClosePairsPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ClosePairsPairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(ClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.ClosePairsPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(ClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.ClosePairsPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(ClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.ClosePairsPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(ClosePairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.ClosePairsPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(ClosePairsPairScore self) -> VersionInfo"""
        return _IMP_core.ClosePairsPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ClosePairsPairScore

    def __str__(self):
        r"""__str__(ClosePairsPairScore self) -> std::string"""
        return _IMP_core.ClosePairsPairScore___str__(self)

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

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


# Register ClosePairsPairScore in _IMP_core:
_IMP_core.ClosePairsPairScore_swigregister(ClosePairsPairScore)
class ConjugateGradients(IMP.AttributeOptimizer):
    r"""Proxy of C++ IMP::core::ConjugateGradients class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ConjugateGradients self, Model m, std::string name="ConjugateGradients%1%") -> ConjugateGradients
        __init__(ConjugateGradients self) -> ConjugateGradients
        """
        _IMP_core.ConjugateGradients_swiginit(self, _IMP_core.new_ConjugateGradients(*args))

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

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

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

    def get_version_info(self):
        r"""get_version_info(ConjugateGradients self) -> VersionInfo"""
        return _IMP_core.ConjugateGradients_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ConjugateGradients

    def __str__(self):
        r"""__str__(ConjugateGradients self) -> std::string"""
        return _IMP_core.ConjugateGradients___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ConjugateGradients self) -> PyObject *"""
        return _IMP_core.ConjugateGradients__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConjugateGradients self, PyObject * p)"""
        return _IMP_core.ConjugateGradients__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ConjugateGradients in _IMP_core:
_IMP_core.ConjugateGradients_swigregister(ConjugateGradients)
class ConnectivityRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::ConnectivityRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, ps, sc):
        r"""__init__(ConnectivityRestraint self, PairScore ps, _SingletonContainerAdaptor sc) -> ConnectivityRestraint"""
        _IMP_core.ConnectivityRestraint_swiginit(self, _IMP_core.new_ConnectivityRestraint(ps, sc))

    def get_connected_index_pairs(self):
        r"""get_connected_index_pairs(ConnectivityRestraint self) -> IMP::ParticleIndexPairs"""
        return _IMP_core.ConnectivityRestraint_get_connected_index_pairs(self)

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

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

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

    def get_version_info(self):
        r"""get_version_info(ConnectivityRestraint self) -> VersionInfo"""
        return _IMP_core.ConnectivityRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ConnectivityRestraint

    def __str__(self):
        r"""__str__(ConnectivityRestraint self) -> std::string"""
        return _IMP_core.ConnectivityRestraint___str__(self)

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

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


# Register ConnectivityRestraint in _IMP_core:
_IMP_core.ConnectivityRestraint_swigregister(ConnectivityRestraint)
class ConstantRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::ConstantRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ConstantRestraint self, Model m, IMP::Float v) -> ConstantRestraint
        __init__(ConstantRestraint self) -> ConstantRestraint
        """
        _IMP_core.ConstantRestraint_swiginit(self, _IMP_core.new_ConstantRestraint(*args))

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

    def get_version_info(self):
        r"""get_version_info(ConstantRestraint self) -> VersionInfo"""
        return _IMP_core.ConstantRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ConstantRestraint

    def __str__(self):
        r"""__str__(ConstantRestraint self) -> std::string"""
        return _IMP_core.ConstantRestraint___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(ConstantRestraint self) -> PyObject *"""
        return _IMP_core.ConstantRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConstantRestraint self, PyObject * p)"""
        return _IMP_core.ConstantRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ConstantRestraint in _IMP_core:
_IMP_core.ConstantRestraint_swigregister(ConstantRestraint)
class Cosine(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::Cosine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Cosine self, IMP::Float force_constant, int periodicity, IMP::Float phase) -> Cosine
        __init__(Cosine self) -> Cosine
        """
        _IMP_core.Cosine_swiginit(self, _IMP_core.new_Cosine(*args))

    def get_force_constant(self):
        r"""get_force_constant(Cosine self) -> IMP::Float"""
        return _IMP_core.Cosine_get_force_constant(self)

    def get_periodicity(self):
        r"""get_periodicity(Cosine self) -> int"""
        return _IMP_core.Cosine_get_periodicity(self)

    def get_phase(self):
        r"""get_phase(Cosine self) -> IMP::Float"""
        return _IMP_core.Cosine_get_phase(self)

    def get_version_info(self):
        r"""get_version_info(Cosine self) -> VersionInfo"""
        return _IMP_core.Cosine_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_Cosine

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

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(Cosine self) -> PyObject *"""
        return _IMP_core.Cosine__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Cosine self, PyObject * p)"""
        return _IMP_core.Cosine__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import jax.numpy as jnp
        def score(val, k, period, phase):
            return jnp.abs(k) - k * jnp.cos(period * val + phase)
        return functools.partial(score, k=self.get_force_constant(),
                                 period=self.get_periodicity(),
                                 phase=self.get_phase())


# Register Cosine in _IMP_core:
_IMP_core.Cosine_swigregister(Cosine)
class CoverRefined(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::CoverRefined class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, ref, slack=0):
        r"""__init__(CoverRefined self, Refiner ref, IMP::Float slack=0) -> CoverRefined"""
        _IMP_core.CoverRefined_swiginit(self, _IMP_core.new_CoverRefined(ref, slack))

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

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""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):
        r"""get_version_info(CoverRefined self) -> VersionInfo"""
        return _IMP_core.CoverRefined_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_CoverRefined

    def __str__(self):
        r"""__str__(CoverRefined self) -> std::string"""
        return _IMP_core.CoverRefined___str__(self)

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

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


# Register CoverRefined in _IMP_core:
_IMP_core.CoverRefined_swigregister(CoverRefined)
class Cover(XYZR):
    r"""Proxy of C++ IMP::core::Cover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def get_constraint(self):
        r"""get_constraint(Cover self) -> Constraint"""
        return _IMP_core.Cover_get_constraint(self)

    def __init__(self, *args):
        r"""
        __init__(Cover self) -> Cover
        __init__(Cover self, Model m, ParticleIndex id) -> Cover
        __init__(Cover self, _ParticleAdaptor d) -> Cover
        """
        _IMP_core.Cover_swiginit(self, _IMP_core.new_Cover(*args))

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Cover self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Cover self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Cover self, SparseStringKey a0, IMP::String a1)
        add_attribute(Cover self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Cover_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Cover self, SparseFloatKey a0) -> IMP::Float
        get_value(Cover self, SparseIntKey a0) -> IMP::Int
        get_value(Cover self, SparseStringKey a0) -> IMP::String
        get_value(Cover self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Cover_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Cover self, SparseFloatKey a0, IMP::Float a1)
        set_value(Cover self, SparseIntKey a0, IMP::Int a1)
        set_value(Cover self, SparseStringKey a0, IMP::String a1)
        set_value(Cover self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Cover_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Cover self, SparseFloatKey a0)
        remove_attribute(Cover self, SparseIntKey a0)
        remove_attribute(Cover self, SparseStringKey a0)
        remove_attribute(Cover self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Cover_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Cover self, SparseFloatKey a0) -> bool
        has_attribute(Cover self, SparseIntKey a0) -> bool
        has_attribute(Cover self, SparseStringKey a0) -> bool
        has_attribute(Cover self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Cover_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Cover self, FloatKey a0) -> bool"""
        return _IMP_core.Cover_get_is_optimized(self, a0)

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

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

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

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

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

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

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

    def __hash__(self):
        r"""__hash__(Cover self) -> std::size_t"""
        return _IMP_core.Cover___hash__(self)

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Cover self) -> PyObject *"""
        return _IMP_core.Cover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Cover self, PyObject * p)"""
        return _IMP_core.Cover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Cover

# Register Cover in _IMP_core:
_IMP_core.Cover_swigregister(Cover)
class DerivativesFromRefined(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::DerivativesFromRefined class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(DerivativesFromRefined self, Refiner r, IMP::FloatKeys ks=IMP::core::XYZ::get_xyz_keys()) -> DerivativesFromRefined"""
        _IMP_core.DerivativesFromRefined_swiginit(self, _IMP_core.new_DerivativesFromRefined(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""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):
        r"""get_version_info(DerivativesFromRefined self) -> VersionInfo"""
        return _IMP_core.DerivativesFromRefined_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DerivativesFromRefined

    def __str__(self):
        r"""__str__(DerivativesFromRefined self) -> std::string"""
        return _IMP_core.DerivativesFromRefined___str__(self)

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

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


# Register DerivativesFromRefined in _IMP_core:
_IMP_core.DerivativesFromRefined_swigregister(DerivativesFromRefined)
class DerivativesToRefined(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::DerivativesToRefined class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(DerivativesToRefined self, Refiner r, IMP::FloatKeys ks=IMP::core::XYZ::get_xyz_keys()) -> DerivativesToRefined"""
        _IMP_core.DerivativesToRefined_swiginit(self, _IMP_core.new_DerivativesToRefined(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""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):
        r"""get_version_info(DerivativesToRefined self) -> VersionInfo"""
        return _IMP_core.DerivativesToRefined_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DerivativesToRefined

    def __str__(self):
        r"""__str__(DerivativesToRefined self) -> std::string"""
        return _IMP_core.DerivativesToRefined___str__(self)

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

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


# Register DerivativesToRefined in _IMP_core:
_IMP_core.DerivativesToRefined_swigregister(DerivativesToRefined)
class DiameterRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::DiameterRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, f, sc, diameter):
        r"""__init__(DiameterRestraint self, UnaryFunction f, SingletonContainer sc, IMP::Float diameter) -> DiameterRestraint"""
        _IMP_core.DiameterRestraint_swiginit(self, _IMP_core.new_DiameterRestraint(f, sc, diameter))

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

    def get_version_info(self):
        r"""get_version_info(DiameterRestraint self) -> VersionInfo"""
        return _IMP_core.DiameterRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DiameterRestraint

    def do_create_decomposition(self):
        r"""do_create_decomposition(DiameterRestraint self) -> IMP::Restraints"""
        return _IMP_core.DiameterRestraint_do_create_decomposition(self)

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

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

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

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


# Register DiameterRestraint in _IMP_core:
_IMP_core.DiameterRestraint_swigregister(DiameterRestraint)
class Transform(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::Transform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Transform self, Transformation3D t, bool ignore_non_xyz=False) -> Transform
        __init__(Transform self) -> Transform
        """
        _IMP_core.Transform_swiginit(self, _IMP_core.new_Transform(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""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):
        r"""get_version_info(Transform self) -> VersionInfo"""
        return _IMP_core.Transform_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_Transform

    def __str__(self):
        r"""__str__(Transform self) -> std::string"""
        return _IMP_core.Transform___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(Transform self) -> PyObject *"""
        return _IMP_core.Transform__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Transform self, PyObject * p)"""
        return _IMP_core.Transform__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register Transform in _IMP_core:
_IMP_core.Transform_swigregister(Transform)
class Reference(IMP.Decorator):
    r"""Proxy of C++ IMP::core::Reference class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Reference self) -> Reference
        __init__(Reference self, Model m, ParticleIndex id) -> Reference
        __init__(Reference self, _ParticleAdaptor d) -> Reference
        """
        _IMP_core.Reference_swiginit(self, _IMP_core.new_Reference(*args))

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

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

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Reference self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Reference self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Reference self, SparseStringKey a0, IMP::String a1)
        add_attribute(Reference self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Reference_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Reference self, SparseFloatKey a0) -> IMP::Float
        get_value(Reference self, SparseIntKey a0) -> IMP::Int
        get_value(Reference self, SparseStringKey a0) -> IMP::String
        get_value(Reference self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Reference_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Reference self, SparseFloatKey a0, IMP::Float a1)
        set_value(Reference self, SparseIntKey a0, IMP::Int a1)
        set_value(Reference self, SparseStringKey a0, IMP::String a1)
        set_value(Reference self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Reference_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Reference self, SparseFloatKey a0)
        remove_attribute(Reference self, SparseIntKey a0)
        remove_attribute(Reference self, SparseStringKey a0)
        remove_attribute(Reference self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Reference_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Reference self, SparseFloatKey a0) -> bool
        has_attribute(Reference self, SparseIntKey a0) -> bool
        has_attribute(Reference self, SparseStringKey a0) -> bool
        has_attribute(Reference self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Reference_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Reference self, FloatKey a0) -> bool"""
        return _IMP_core.Reference_get_is_optimized(self, a0)

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

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

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

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

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

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

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

    def __hash__(self):
        r"""__hash__(Reference self) -> std::size_t"""
        return _IMP_core.Reference___hash__(self)

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Reference self) -> PyObject *"""
        return _IMP_core.Reference__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Reference self, PyObject * p)"""
        return _IMP_core.Reference__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Reference

# Register Reference in _IMP_core:
_IMP_core.Reference_swigregister(Reference)
class TransformationAndReflectionSymmetry(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::TransformationAndReflectionSymmetry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, t, r):
        r"""__init__(TransformationAndReflectionSymmetry self, Transformation3D t, Reflection3D r) -> TransformationAndReflectionSymmetry"""
        _IMP_core.TransformationAndReflectionSymmetry_swiginit(self, _IMP_core.new_TransformationAndReflectionSymmetry(t, r))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""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):
        r"""get_version_info(TransformationAndReflectionSymmetry self) -> VersionInfo"""
        return _IMP_core.TransformationAndReflectionSymmetry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TransformationAndReflectionSymmetry

    def __str__(self):
        r"""__str__(TransformationAndReflectionSymmetry self) -> std::string"""
        return _IMP_core.TransformationAndReflectionSymmetry___str__(self)

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

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


# Register TransformationAndReflectionSymmetry in _IMP_core:
_IMP_core.TransformationAndReflectionSymmetry_swigregister(TransformationAndReflectionSymmetry)
class TransformationSymmetry(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::TransformationSymmetry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(TransformationSymmetry self, Transformation3D t) -> TransformationSymmetry
        __init__(TransformationSymmetry self, ParticleIndex rb_pi) -> TransformationSymmetry
        """
        _IMP_core.TransformationSymmetry_swiginit(self, _IMP_core.new_TransformationSymmetry(*args))

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

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

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""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):
        r"""get_version_info(TransformationSymmetry self) -> VersionInfo"""
        return _IMP_core.TransformationSymmetry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TransformationSymmetry

    def __str__(self):
        r"""__str__(TransformationSymmetry self) -> std::string"""
        return _IMP_core.TransformationSymmetry___str__(self)

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

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


# Register TransformationSymmetry in _IMP_core:
_IMP_core.TransformationSymmetry_swigregister(TransformationSymmetry)
class TransformationSymmetryMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::TransformationSymmetryMover class."""

    thisown = 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):
        r"""__init__(TransformationSymmetryMover self, Model m, TransformationSymmetry symm, ParticleIndex pivot, IMP::Float max_translation, IMP::Float max_rotation) -> TransformationSymmetryMover"""
        _IMP_core.TransformationSymmetryMover_swiginit(self, _IMP_core.new_TransformationSymmetryMover(m, symm, pivot, max_translation, max_rotation))

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(TransformationSymmetryMover self) -> VersionInfo"""
        return _IMP_core.TransformationSymmetryMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TransformationSymmetryMover

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

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

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


# Register TransformationSymmetryMover in _IMP_core:
_IMP_core.TransformationSymmetryMover_swigregister(TransformationSymmetryMover)
class DihedralRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::DihedralRestraint class."""

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

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

    def get_version_info(self):
        r"""get_version_info(DihedralRestraint self) -> VersionInfo"""
        return _IMP_core.DihedralRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DihedralRestraint

    def __str__(self):
        r"""__str__(DihedralRestraint self) -> std::string"""
        return _IMP_core.DihedralRestraint___str__(self)

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

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


# Register DihedralRestraint in _IMP_core:
_IMP_core.DihedralRestraint_swigregister(DihedralRestraint)
class DistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::DistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(DistancePairScore self, UnaryFunction uf, std::string name="DistancePairScore%1%") -> DistancePairScore
        __init__(DistancePairScore self) -> DistancePairScore
        """
        _IMP_core.DistancePairScore_swiginit(self, _IMP_core.new_DistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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_score_functor(self, *args):
        r"""
        get_score_functor(DistancePairScore self) -> UnaryFunctionEvaluate
        get_score_functor(DistancePairScore self) -> UnaryFunctionEvaluate
        """
        return _IMP_core.DistancePairScore_get_score_functor(self, *args)

    def get_version_info(self):
        r"""get_version_info(DistancePairScore self) -> VersionInfo"""
        return _IMP_core.DistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DistancePairScore

    def __str__(self):
        r"""__str__(DistancePairScore self) -> std::string"""
        return _IMP_core.DistancePairScore___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(DistancePairScore self) -> PyObject *"""
        return _IMP_core.DistancePairScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DistancePairScore self, PyObject * p)"""
        return _IMP_core.DistancePairScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        def jax_score(jm, uf):
            xyzs = jm['xyz'][indexes]
            diff = xyzs[:,0] - xyzs[:,1]
            drs = jnp.linalg.norm(diff, axis=1)
            return uf(drs)
        sfnc = self.get_score_functor()
        uf = sfnc.get_unary_function().get_derived_object()
        f = functools.partial(jax_score, uf=uf._get_jax())
        return self._wrap_jax(m, f)


# Register DistancePairScore in _IMP_core:
_IMP_core.DistancePairScore_swigregister(DistancePairScore)
class HarmonicDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::HarmonicDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(HarmonicDistancePairScore self, double x0, double k, std::string name="HarmonicDistancePairScore%1%") -> HarmonicDistancePairScore
        __init__(HarmonicDistancePairScore self) -> HarmonicDistancePairScore
        """
        _IMP_core.HarmonicDistancePairScore_swiginit(self, _IMP_core.new_HarmonicDistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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_score_functor(self, *args):
        r"""
        get_score_functor(HarmonicDistancePairScore self) -> IMP::core::HarmonicDistanceScore
        get_score_functor(HarmonicDistancePairScore self) -> IMP::core::HarmonicDistanceScore const &
        """
        return _IMP_core.HarmonicDistancePairScore_get_score_functor(self, *args)

    def get_x0(self):
        r"""get_x0(HarmonicDistancePairScore self) -> double"""
        return _IMP_core.HarmonicDistancePairScore_get_x0(self)

    def get_k(self):
        r"""get_k(HarmonicDistancePairScore self) -> double"""
        return _IMP_core.HarmonicDistancePairScore_get_k(self)

    def get_version_info(self):
        r"""get_version_info(HarmonicDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicDistancePairScore

    def __str__(self):
        r"""__str__(HarmonicDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicDistancePairScore___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(HarmonicDistancePairScore self) -> PyObject *"""
        return _IMP_core.HarmonicDistancePairScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(HarmonicDistancePairScore self, PyObject * p)"""
        return _IMP_core.HarmonicDistancePairScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        def jax_harmonic_distance_pair_score(jm, d, k):
            xyzs = jm['xyz'][indexes]
            diff = xyzs[:,0] - xyzs[:,1]
            drs = jnp.linalg.norm(diff, axis=1)
            return 0.5 * k * (d - drs)**2
        f = functools.partial(jax_harmonic_distance_pair_score,
                              d=self.get_x0(), k=self.get_k())
        return self._wrap_jax(m, f)


# Register HarmonicDistancePairScore in _IMP_core:
_IMP_core.HarmonicDistancePairScore_swigregister(HarmonicDistancePairScore)
class DistanceRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::DistanceRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(DistanceRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor a, _ParticleIndexAdaptor b, std::string name="DistanceRestraint %1%") -> DistanceRestraint
        __init__(DistanceRestraint self) -> DistanceRestraint
        """
        _IMP_core.DistanceRestraint_swiginit(self, _IMP_core.new_DistanceRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(DistanceRestraint self) -> DistancePairScore"""
        return _IMP_core.DistanceRestraint_get_score_object(self)

    def get_index(self):
        r"""get_index(DistanceRestraint self) -> IMP::core::DistancePairScore::IndexArgument"""
        return _IMP_core.DistanceRestraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(DistanceRestraint self) -> VersionInfo"""
        return _IMP_core.DistanceRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DistanceRestraint

    def __str__(self):
        r"""__str__(DistanceRestraint self) -> std::string"""
        return _IMP_core.DistanceRestraint___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(DistanceRestraint self) -> PyObject *"""
        return _IMP_core.DistanceRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DistanceRestraint self, PyObject * p)"""
        return _IMP_core.DistanceRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import jax.numpy as jnp
        ps = self.get_score_object()
        indexes = jnp.array([self.get_index()])
        ji = ps._get_jax(self.get_model(), indexes)
        def score(jm):
            return jnp.sum(ji.score_func(jm))
        return self._wrap_jax(score)


# Register DistanceRestraint in _IMP_core:
_IMP_core.DistanceRestraint_swigregister(DistanceRestraint)
class SphereDistanceToSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::core::SphereDistanceToSingletonScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, f, pt):
        r"""__init__(SphereDistanceToSingletonScore self, UnaryFunction f, Vector3D pt) -> SphereDistanceToSingletonScore"""
        _IMP_core.SphereDistanceToSingletonScore_swiginit(self, _IMP_core.new_SphereDistanceToSingletonScore(f, pt))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SphereDistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.SphereDistanceToSingletonScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(SphereDistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.SphereDistanceToSingletonScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(SphereDistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.SphereDistanceToSingletonScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(SphereDistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.SphereDistanceToSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(SphereDistanceToSingletonScore self) -> VersionInfo"""
        return _IMP_core.SphereDistanceToSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SphereDistanceToSingletonScore

    def __str__(self):
        r"""__str__(SphereDistanceToSingletonScore self) -> std::string"""
        return _IMP_core.SphereDistanceToSingletonScore___str__(self)

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

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


# Register SphereDistanceToSingletonScore in _IMP_core:
_IMP_core.SphereDistanceToSingletonScore_swigregister(SphereDistanceToSingletonScore)
class ExcludedVolumeRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::ExcludedVolumeRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(ExcludedVolumeRestraint self, _SingletonContainerAdaptor sc, double k=1, double slack=10, std::string name="ExcludedVolumeRestraint%1%") -> ExcludedVolumeRestraint"""
        _IMP_core.ExcludedVolumeRestraint_swiginit(self, _IMP_core.new_ExcludedVolumeRestraint(*args))

    def do_get_inputs(self):
        r"""do_get_inputs(ExcludedVolumeRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.ExcludedVolumeRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ExcludedVolumeRestraint self) -> VersionInfo"""
        return _IMP_core.ExcludedVolumeRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ExcludedVolumeRestraint

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

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

    def get_indexes(self):
        r"""get_indexes(ExcludedVolumeRestraint self) -> IMP::ParticleIndexPairs const &"""
        return _IMP_core.ExcludedVolumeRestraint_get_indexes(self)
    def __get_pair_filters(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_pair_filters,  getfunc=self.get_pair_filter, erasefunc=self.erase_pair_filter,  appendfunc=self.add_pair_filter, extendfunc=self.add_pair_filters,  clearfunc=self.clear_pair_filters, indexfunc=self._python_index_pair_filter)  
    def __set_pair_filters(self, obj): IMP._list_util.set_varlist(self.pair_filters, obj)  
    def __del_pair_filters(self): IMP._list_util.del_varlist(self.pair_filters)       
    pair_filters = property(__get_pair_filters, __set_pair_filters, __del_pair_filters, doc="List of ##ucnames")  

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

    def _python_index_pair_filter(self, d, start, stop):
        r"""_python_index_pair_filter(ExcludedVolumeRestraint self, PairPredicate d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_core.ExcludedVolumeRestraint__python_index_pair_filter(self, d, start, stop)

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

    def set_pair_filters(self, ps):
        r"""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):
        r"""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):
        r"""add_pair_filter(ExcludedVolumeRestraint self, PairPredicate obj) -> unsigned int"""
        return _IMP_core.ExcludedVolumeRestraint_add_pair_filter(self, obj)

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

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

    def get_number_of_pair_filters(self):
        r"""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):
        r"""get_has_pair_filters(ExcludedVolumeRestraint self) -> bool"""
        return _IMP_core.ExcludedVolumeRestraint_get_has_pair_filters(self)

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

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

    def erase_pair_filter(self, i):
        r"""erase_pair_filter(ExcludedVolumeRestraint self, unsigned int i)"""
        return _IMP_core.ExcludedVolumeRestraint_erase_pair_filter(self, i)

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

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

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

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


# Register ExcludedVolumeRestraint in _IMP_core:
_IMP_core.ExcludedVolumeRestraint_swigregister(ExcludedVolumeRestraint)
class FixedRefiner(IMP.Refiner):
    r"""Proxy of C++ IMP::core::FixedRefiner class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(FixedRefiner self, IMP::ParticlesTemp const & ps) -> FixedRefiner
        __init__(FixedRefiner self, Model m, IMP::ParticleIndexes const & pis) -> FixedRefiner
        """
        _IMP_core.FixedRefiner_swiginit(self, _IMP_core.new_FixedRefiner(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(FixedRefiner self) -> VersionInfo"""
        return _IMP_core.FixedRefiner_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_FixedRefiner

    def __str__(self):
        r"""__str__(FixedRefiner self) -> std::string"""
        return _IMP_core.FixedRefiner___str__(self)

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

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


# Register FixedRefiner in _IMP_core:
_IMP_core.FixedRefiner_swigregister(FixedRefiner)
class GridClosePairsFinder(ClosePairsFinder):
    r"""Proxy of C++ IMP::core::GridClosePairsFinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self):
        r"""__init__(GridClosePairsFinder self) -> GridClosePairsFinder"""
        _IMP_core.GridClosePairsFinder_swiginit(self, _IMP_core.new_GridClosePairsFinder())

    def get_close_pairs(self, *args):
        r"""
        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):
        r"""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):
        r"""get_version_info(GridClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.GridClosePairsFinder_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_GridClosePairsFinder

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(GridClosePairsFinder self) -> PyObject *"""
        return _IMP_core.GridClosePairsFinder__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(GridClosePairsFinder self, PyObject * p)"""
        return _IMP_core.GridClosePairsFinder__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register GridClosePairsFinder in _IMP_core:
_IMP_core.GridClosePairsFinder_swigregister(GridClosePairsFinder)
class Harmonic(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::Harmonic class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Harmonic self, IMP::Float mean, IMP::Float k) -> Harmonic
        __init__(Harmonic self) -> Harmonic
        """
        _IMP_core.Harmonic_swiginit(self, _IMP_core.new_Harmonic(*args))

    def get_version_info(self):
        r"""get_version_info(Harmonic self) -> VersionInfo"""
        return _IMP_core.Harmonic_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_Harmonic

    def get_mean(self):
        r"""get_mean(Harmonic self) -> IMP::Float"""
        return _IMP_core.Harmonic_get_mean(self)

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

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

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

    @staticmethod
    def get_k_from_standard_deviation(sd, t=297.15):
        r"""get_k_from_standard_deviation(IMP::Float sd, IMP::Float t=297.15) -> IMP::Float"""
        return _IMP_core.Harmonic_get_k_from_standard_deviation(sd, t)

    def __str__(self):
        r"""__str__(Harmonic self) -> std::string"""
        return _IMP_core.Harmonic___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(Harmonic self) -> PyObject *"""
        return _IMP_core.Harmonic__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Harmonic self, PyObject * p)"""
        return _IMP_core.Harmonic__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        def score(val, mean, k):
            return 0.5 * k * (mean - val) ** 2
        return functools.partial(score, mean=self.get_mean(), k=self.get_k())


# Register Harmonic in _IMP_core:
_IMP_core.Harmonic_swigregister(Harmonic)
class HarmonicWell(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::HarmonicWell class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, well, k):
        r"""__init__(HarmonicWell self, IMP::FloatRange const & well, double k) -> HarmonicWell"""
        _IMP_core.HarmonicWell_swiginit(self, _IMP_core.new_HarmonicWell(well, k))

    def get_well(self):
        r"""get_well(HarmonicWell self) -> IMP::FloatRange"""
        return _IMP_core.HarmonicWell_get_well(self)

    def get_k(self):
        r"""get_k(HarmonicWell self) -> double"""
        return _IMP_core.HarmonicWell_get_k(self)

    def get_version_info(self):
        r"""get_version_info(HarmonicWell self) -> VersionInfo"""
        return _IMP_core.HarmonicWell_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicWell

    def __str__(self):
        r"""__str__(HarmonicWell self) -> std::string"""
        return _IMP_core.HarmonicWell___str__(self)

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

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


    def _get_jax(self):
        import jax.numpy as jnp
        def score(val, lb, ub, k):
            return 0.5 * k * (val - jnp.clip(val, lb, ub)) ** 2
        well = self.get_well()
        return functools.partial(score, lb=well[0], ub=well[1], k=self.get_k())


# Register HarmonicWell in _IMP_core:
_IMP_core.HarmonicWell_swigregister(HarmonicWell)
class HarmonicLowerBound(Harmonic):
    r"""Proxy of C++ IMP::core::HarmonicLowerBound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(HarmonicLowerBound self, IMP::Float mean, IMP::Float k) -> HarmonicLowerBound
        __init__(HarmonicLowerBound self) -> HarmonicLowerBound
        """
        _IMP_core.HarmonicLowerBound_swiginit(self, _IMP_core.new_HarmonicLowerBound(*args))
    __swig_destroy__ = _IMP_core.delete_HarmonicLowerBound

    def __str__(self):
        r"""__str__(HarmonicLowerBound self) -> std::string"""
        return _IMP_core.HarmonicLowerBound___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(HarmonicLowerBound self) -> PyObject *"""
        return _IMP_core.HarmonicLowerBound__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(HarmonicLowerBound self, PyObject * p)"""
        return _IMP_core.HarmonicLowerBound__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import jax.lax
        def score(val, mean, k):
            return 0.5 * k * jax.lax.max(mean - val, 0.0) ** 2
        return functools.partial(score, mean=self.get_mean(), k=self.get_k())


# Register HarmonicLowerBound in _IMP_core:
_IMP_core.HarmonicLowerBound_swigregister(HarmonicLowerBound)
class HarmonicUpperBound(Harmonic):
    r"""Proxy of C++ IMP::core::HarmonicUpperBound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(HarmonicUpperBound self, IMP::Float mean, IMP::Float k) -> HarmonicUpperBound
        __init__(HarmonicUpperBound self) -> HarmonicUpperBound
        """
        _IMP_core.HarmonicUpperBound_swiginit(self, _IMP_core.new_HarmonicUpperBound(*args))
    __swig_destroy__ = _IMP_core.delete_HarmonicUpperBound

    def __str__(self):
        r"""__str__(HarmonicUpperBound self) -> std::string"""
        return _IMP_core.HarmonicUpperBound___str__(self)

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(HarmonicUpperBound self) -> PyObject *"""
        return _IMP_core.HarmonicUpperBound__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(HarmonicUpperBound self, PyObject * p)"""
        return _IMP_core.HarmonicUpperBound__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import jax.lax
        def score(val, mean, k):
            return 0.5 * k * jax.lax.min(mean - val, 0.0) ** 2
        return functools.partial(score, mean=self.get_mean(), k=self.get_k())


# Register HarmonicUpperBound in _IMP_core:
_IMP_core.HarmonicUpperBound_swigregister(HarmonicUpperBound)
class WeightedSum(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::WeightedSum class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, funcs, weights):
        r"""__init__(WeightedSum self, IMP::UnaryFunctions funcs, IMP::Floats weights) -> WeightedSum"""
        _IMP_core.WeightedSum_swiginit(self, _IMP_core.new_WeightedSum(funcs, weights))

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(WeightedSum self) -> VersionInfo"""
        return _IMP_core.WeightedSum_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_WeightedSum

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

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

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


    def _get_jax(self):
        import jax.numpy as jnp
        def score(val, funcs, weights):
            return sum(f(val) * weight for (f, weight) in zip(funcs, weights))
        nfunc = self.get_function_number()
        funcs = [self.get_function(i).get_derived_object()._get_jax()
                 for i in range(nfunc)]
        return functools.partial(score, funcs=funcs,
                                 weights=self.get_weights())


# Register WeightedSum in _IMP_core:
_IMP_core.WeightedSum_swigregister(WeightedSum)
class WeightedSumOfExponential(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::WeightedSumOfExponential class."""

    thisown = 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):
        r"""__init__(WeightedSumOfExponential self, IMP::UnaryFunctions funcs, IMP::Floats weights, IMP::Float denom=1.0) -> WeightedSumOfExponential"""
        _IMP_core.WeightedSumOfExponential_swiginit(self, _IMP_core.new_WeightedSumOfExponential(funcs, weights, denom))

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

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

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

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

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

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

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

    def get_version_info(self):
        r"""get_version_info(WeightedSumOfExponential self) -> VersionInfo"""
        return _IMP_core.WeightedSumOfExponential_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_WeightedSumOfExponential

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

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

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


    def _get_jax(self):
        import jax.numpy as jnp
        def score(val, funcs, weights, denom):
            exp_sum = sum(weight * jnp.exp(-f(val) / denom)
                          for (f, weight) in zip(funcs, weights))
            return -jnp.log(exp_sum) * denom
        nfunc = self.get_function_number()
        funcs = [self.get_function(i).get_derived_object()._get_jax()
                 for i in range(nfunc)]
        return functools.partial(score, funcs=funcs,
                                 weights=self.get_weights(),
                                 denom=self.get_denominator())


# Register WeightedSumOfExponential in _IMP_core:
_IMP_core.WeightedSumOfExponential_swigregister(WeightedSumOfExponential)
class MSConnectivityRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::MSConnectivityRestraint class."""

    thisown = 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):
        r"""__init__(MSConnectivityRestraint self, Model m, PairScore ps, double eps=0.1) -> MSConnectivityRestraint"""
        _IMP_core.MSConnectivityRestraint_swiginit(self, _IMP_core.new_MSConnectivityRestraint(m, ps, eps))

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

    def add_composite(self, *args):
        r"""
        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):
        r"""get_connected_pairs(MSConnectivityRestraint self) -> IMP::ParticlePairsTemp"""
        return _IMP_core.MSConnectivityRestraint_get_connected_pairs(self)

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

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

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

    def get_version_info(self):
        r"""get_version_info(MSConnectivityRestraint self) -> VersionInfo"""
        return _IMP_core.MSConnectivityRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_MSConnectivityRestraint

    def __str__(self):
        r"""__str__(MSConnectivityRestraint self) -> std::string"""
        return _IMP_core.MSConnectivityRestraint___str__(self)

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

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


# Register MSConnectivityRestraint in _IMP_core:
_IMP_core.MSConnectivityRestraint_swigregister(MSConnectivityRestraint)
class HierarchyTraits(object):
    r"""Proxy of C++ IMP::core::HierarchyTraits class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(HierarchyTraits self) -> HierarchyTraits
        __init__(HierarchyTraits self, std::string name) -> HierarchyTraits
        """
        _IMP_core.HierarchyTraits_swiginit(self, _IMP_core.new_HierarchyTraits(*args))

    def get_children_key(self):
        r"""get_children_key(HierarchyTraits self) -> ParticleIndexesKey"""
        return _IMP_core.HierarchyTraits_get_children_key(self)

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

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

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

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

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

# Register HierarchyTraits in _IMP_core:
_IMP_core.HierarchyTraits_swigregister(HierarchyTraits)
class Hierarchy(IMP.Decorator):
    r"""Proxy of C++ IMP::core::Hierarchy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

    def __init__(self, *args):
        r"""
        __init__(Hierarchy self) -> Hierarchy
        __init__(Hierarchy self, Model m, ParticleIndex id, HierarchyTraits tr=get_default_traits()) -> Hierarchy
        __init__(Hierarchy self, _ParticleAdaptor d, HierarchyTraits tr=get_default_traits()) -> Hierarchy
        """
        _IMP_core.Hierarchy_swiginit(self, _IMP_core.new_Hierarchy(*args))

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

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

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

    @staticmethod
    def get_changed_key():
        r"""get_changed_key() -> TriggerKey"""
        return _IMP_core.Hierarchy_get_changed_key()

    def get_parent(self):
        r"""get_parent(Hierarchy self) -> Hierarchy"""
        return _IMP_core.Hierarchy_get_parent(self)

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

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

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

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

    def remove_child(self, *args):
        r"""
        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):
        r"""clear_children(Hierarchy self)"""
        return _IMP_core.Hierarchy_clear_children(self)

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

    def add_child_at(self, h, pos):
        r"""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):
        r"""
        get_child_index(Hierarchy self, unsigned int i) -> ParticleIndex
        get_child_index(Hierarchy self) -> int
        """
        return _IMP_core.Hierarchy_get_child_index(self, *args)

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Hierarchy self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Hierarchy self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Hierarchy self, SparseStringKey a0, IMP::String a1)
        add_attribute(Hierarchy self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Hierarchy_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Hierarchy self, SparseFloatKey a0) -> IMP::Float
        get_value(Hierarchy self, SparseIntKey a0) -> IMP::Int
        get_value(Hierarchy self, SparseStringKey a0) -> IMP::String
        get_value(Hierarchy self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Hierarchy_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Hierarchy self, SparseFloatKey a0, IMP::Float a1)
        set_value(Hierarchy self, SparseIntKey a0, IMP::Int a1)
        set_value(Hierarchy self, SparseStringKey a0, IMP::String a1)
        set_value(Hierarchy self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Hierarchy_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Hierarchy self, SparseFloatKey a0)
        remove_attribute(Hierarchy self, SparseIntKey a0)
        remove_attribute(Hierarchy self, SparseStringKey a0)
        remove_attribute(Hierarchy self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Hierarchy_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Hierarchy self, SparseFloatKey a0) -> bool
        has_attribute(Hierarchy self, SparseIntKey a0) -> bool
        has_attribute(Hierarchy self, SparseStringKey a0) -> bool
        has_attribute(Hierarchy self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Hierarchy_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Hierarchy self, FloatKey a0) -> bool"""
        return _IMP_core.Hierarchy_get_is_optimized(self, a0)

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

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

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

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

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

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

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

    def __hash__(self):
        r"""__hash__(Hierarchy self) -> std::size_t"""
        return _IMP_core.Hierarchy___hash__(self)

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

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

# Register Hierarchy in _IMP_core:
_IMP_core.Hierarchy_swigregister(Hierarchy)
class HierarchyVisitor(object):
    r"""Proxy of C++ IMP::core::HierarchyVisitor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(HierarchyVisitor self) -> HierarchyVisitor"""
        if self.__class__ == HierarchyVisitor:
            _self = None
        else:
            _self = self
        _IMP_core.HierarchyVisitor_swiginit(self, _IMP_core.new_HierarchyVisitor(_self, ))

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




    def __call__(self, p):
        r"""__call__(HierarchyVisitor self, Hierarchy p) -> bool"""
        return _IMP_core.HierarchyVisitor___call__(self, p)
    __swig_destroy__ = _IMP_core.delete_HierarchyVisitor
    def __disown__(self):
        self.this.disown()
        _IMP_core.disown_HierarchyVisitor(self)
        return weakref.proxy(self)

# Register HierarchyVisitor in _IMP_core:
_IMP_core.HierarchyVisitor_swigregister(HierarchyVisitor)
class ModifierVisitor(HierarchyVisitor):
    r"""Proxy of C++ IMP::core::ModifierVisitor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, sm):
        r"""__init__(ModifierVisitor self, SingletonModifier sm) -> ModifierVisitor"""
        _IMP_core.ModifierVisitor_swiginit(self, _IMP_core.new_ModifierVisitor(sm))
    __swig_destroy__ = _IMP_core.delete_ModifierVisitor

# Register ModifierVisitor in _IMP_core:
_IMP_core.ModifierVisitor_swigregister(ModifierVisitor)
class HierarchyCounter(HierarchyVisitor):
    r"""Proxy of C++ IMP::core::HierarchyCounter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self):
        r"""__init__(HierarchyCounter self) -> HierarchyCounter"""
        _IMP_core.HierarchyCounter_swiginit(self, _IMP_core.new_HierarchyCounter())

    def get_count(self):
        r"""get_count(HierarchyCounter self) -> unsigned int"""
        return _IMP_core.HierarchyCounter_get_count(self)

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(HierarchyCounter self) -> PyObject *"""
        return _IMP_core.HierarchyCounter__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(HierarchyCounter self, PyObject * p)"""
        return _IMP_core.HierarchyCounter__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_HierarchyCounter

# Register HierarchyCounter in _IMP_core:
_IMP_core.HierarchyCounter_swigregister(HierarchyCounter)

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

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

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

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

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

def visit_depth_first(d, f):
    r"""visit_depth_first(Hierarchy d, HierarchyVisitor f)"""
    return _IMP_core.visit_depth_first(d, f)
class LeavesRefiner(IMP.Refiner):
    r"""Proxy of C++ IMP::core::LeavesRefiner class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, tr):
        r"""__init__(LeavesRefiner self, HierarchyTraits tr) -> LeavesRefiner"""
        _IMP_core.LeavesRefiner_swiginit(self, _IMP_core.new_LeavesRefiner(tr))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(LeavesRefiner self) -> VersionInfo"""
        return _IMP_core.LeavesRefiner_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_LeavesRefiner

    def __str__(self):
        r"""__str__(LeavesRefiner self) -> std::string"""
        return _IMP_core.LeavesRefiner___str__(self)

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

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


# Register LeavesRefiner in _IMP_core:
_IMP_core.LeavesRefiner_swigregister(LeavesRefiner)
class Linear(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::Linear class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Linear self, double offset, double slope) -> Linear
        __init__(Linear self) -> Linear
        """
        _IMP_core.Linear_swiginit(self, _IMP_core.new_Linear(*args))

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

    def get_slope(self):
        r"""get_slope(Linear self) -> double"""
        return _IMP_core.Linear_get_slope(self)

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

    def get_offset(self):
        r"""get_offset(Linear self) -> double"""
        return _IMP_core.Linear_get_offset(self)

    def get_version_info(self):
        r"""get_version_info(Linear self) -> VersionInfo"""
        return _IMP_core.Linear_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_Linear

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(Linear self) -> PyObject *"""
        return _IMP_core.Linear__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Linear self, PyObject * p)"""
        return _IMP_core.Linear__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        def score(val, slope, offset):
            return (val - offset) * slope
        return functools.partial(score, slope=self.get_slope(),
                                 offset=self.get_offset())


# Register Linear in _IMP_core:
_IMP_core.Linear_swigregister(Linear)
class LogNormalMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::LogNormalMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(LogNormalMover self, Model m, ParticleIndex pi, IMP::FloatKeys const & vars, double stddev) -> LogNormalMover
        __init__(LogNormalMover self, Model m, ParticleIndex pi, double stddev) -> LogNormalMover
        __init__(LogNormalMover self, IMP::ParticlesTemp const & sc, IMP::FloatKeys const & vars, IMP::Float sigma) -> LogNormalMover
        __init__(LogNormalMover self, IMP::ParticlesTemp const & sc, IMP::Float radius) -> LogNormalMover
        __init__(LogNormalMover self) -> LogNormalMover
        """
        _IMP_core.LogNormalMover_swiginit(self, _IMP_core.new_LogNormalMover(*args))

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

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

    def get_version_info(self):
        r"""get_version_info(LogNormalMover self) -> VersionInfo"""
        return _IMP_core.LogNormalMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_LogNormalMover

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

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

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


    def _get_as_binary(self):
        r"""_get_as_binary(LogNormalMover self) -> PyObject *"""
        return _IMP_core.LogNormalMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(LogNormalMover self, PyObject * p)"""
        return _IMP_core.LogNormalMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register LogNormalMover in _IMP_core:
_IMP_core.LogNormalMover_swigregister(LogNormalMover)
IMP_CORE_HAS_MONTE_CARLO_MOVER = _IMP_core.IMP_CORE_HAS_MONTE_CARLO_MOVER

class MonteCarlo(IMP.Optimizer):
    r"""Proxy of C++ IMP::core::MonteCarlo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, m):
        r"""__init__(MonteCarlo self, Model m) -> MonteCarlo"""
        _IMP_core.MonteCarlo_swiginit(self, _IMP_core.new_MonteCarlo(m))

    def get_version_info(self):
        r"""get_version_info(MonteCarlo self) -> VersionInfo"""
        return _IMP_core.MonteCarlo_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_MonteCarlo

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

    def get_return_best(self):
        r"""get_return_best(MonteCarlo self) -> bool"""
        return _IMP_core.MonteCarlo_get_return_best(self)

    def set_score_moved(self, mv):
        r"""set_score_moved(MonteCarlo self, bool mv)"""
        return _IMP_core.MonteCarlo_set_score_moved(self, mv)

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

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

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

    def set_last_accepted_energy(self, energy):
        r"""set_last_accepted_energy(MonteCarlo self, double energy)"""
        return _IMP_core.MonteCarlo_set_last_accepted_energy(self, energy)

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

    def set_best_accepted_energy(self, energy):
        r"""set_best_accepted_energy(MonteCarlo self, double energy)"""
        return _IMP_core.MonteCarlo_set_best_accepted_energy(self, energy)

    def get_number_of_downward_steps(self):
        r"""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):
        r"""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):
        r"""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):
        r"""get_number_of_accepted_steps(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_accepted_steps(self)

    def set_number_of_downward_steps(self, nsteps):
        r"""set_number_of_downward_steps(MonteCarlo self, unsigned int nsteps)"""
        return _IMP_core.MonteCarlo_set_number_of_downward_steps(self, nsteps)

    def set_number_of_upward_steps(self, nsteps):
        r"""set_number_of_upward_steps(MonteCarlo self, unsigned int nsteps)"""
        return _IMP_core.MonteCarlo_set_number_of_upward_steps(self, nsteps)

    def set_number_of_rejected_steps(self, nsteps):
        r"""set_number_of_rejected_steps(MonteCarlo self, unsigned int nsteps)"""
        return _IMP_core.MonteCarlo_set_number_of_rejected_steps(self, nsteps)

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

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

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

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

    def get_maximum_difference(self):
        r"""get_maximum_difference(MonteCarlo self) -> double"""
        return _IMP_core.MonteCarlo_get_maximum_difference(self)
    def __get_movers(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_movers,  getfunc=self.get_mover, erasefunc=self.erase_mover,  appendfunc=self.add_mover, extendfunc=self.add_movers,  clearfunc=self.clear_movers, indexfunc=self._python_index_mover)  
    def __set_movers(self, obj): IMP._list_util.set_varlist(self.movers, obj)  
    def __del_movers(self): IMP._list_util.del_varlist(self.movers)       
    movers = property(__get_movers, __set_movers, __del_movers, doc="List of ##ucnames")  

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

    def _python_index_mover(self, d, start, stop):
        r"""_python_index_mover(MonteCarlo self, MonteCarloMover d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_core.MonteCarlo__python_index_mover(self, d, start, stop)

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

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

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

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

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

    def clear_movers(self):
        r"""clear_movers(MonteCarlo self)"""
        return _IMP_core.MonteCarlo_clear_movers(self)

    def get_number_of_movers(self):
        r"""get_number_of_movers(MonteCarlo self) -> unsigned int"""
        return _IMP_core.MonteCarlo_get_number_of_movers(self)

    def get_has_movers(self):
        r"""get_has_movers(MonteCarlo self) -> bool"""
        return _IMP_core.MonteCarlo_get_has_movers(self)

    def get_mover(self, i):
        r"""get_mover(MonteCarlo self, unsigned int i) -> MonteCarloMover"""
        return _IMP_core.MonteCarlo_get_mover(self, i)

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

    def erase_mover(self, i):
        r"""erase_mover(MonteCarlo self, unsigned int i)"""
        return _IMP_core.MonteCarlo_erase_mover(self, i)

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

    def __str__(self):
        r"""__str__(MonteCarlo self) -> std::string"""
        return _IMP_core.MonteCarlo___str__(self)

    def __repr__(self):
        r"""__repr__(MonteCarlo self) -> std::string"""
        return _IMP_core.MonteCarlo___repr__(self)

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


    def _get_jax(self):
        from IMP.core._jax_util import _MCJAXInfo
        return _MCJAXInfo(self)

    def _get_jax_optimizer(self, max_steps):
        import IMP.core._jax_util
        return IMP.core._jax_util._MCJAXOptimizer(self, max_steps)

    def _optimize_jax(self, max_steps):
        opt = self._get_jax_optimizer(max_steps)
        score, mc_state = opt.optimize(opt.get_initial_state())
        return score


# Register MonteCarlo in _IMP_core:
_IMP_core.MonteCarlo_swigregister(MonteCarlo)
class MonteCarloWithLocalOptimization(MonteCarlo):
    r"""Proxy of C++ IMP::core::MonteCarloWithLocalOptimization class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, opt, steps):
        r"""__init__(MonteCarloWithLocalOptimization self, Optimizer opt, unsigned int steps) -> MonteCarloWithLocalOptimization"""
        _IMP_core.MonteCarloWithLocalOptimization_swiginit(self, _IMP_core.new_MonteCarloWithLocalOptimization(opt, steps))

    def get_number_of_steps(self):
        r"""get_number_of_steps(MonteCarloWithLocalOptimization self) -> unsigned int"""
        return _IMP_core.MonteCarloWithLocalOptimization_get_number_of_steps(self)

    def get_local_optimizer(self):
        r"""get_local_optimizer(MonteCarloWithLocalOptimization self) -> Optimizer"""
        return _IMP_core.MonteCarloWithLocalOptimization_get_local_optimizer(self)
    __swig_destroy__ = _IMP_core.delete_MonteCarloWithLocalOptimization

    def __str__(self):
        r"""__str__(MonteCarloWithLocalOptimization self) -> std::string"""
        return _IMP_core.MonteCarloWithLocalOptimization___str__(self)

    def __repr__(self):
        r"""__repr__(MonteCarloWithLocalOptimization self) -> std::string"""
        return _IMP_core.MonteCarloWithLocalOptimization___repr__(self)

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


# Register MonteCarloWithLocalOptimization in _IMP_core:
_IMP_core.MonteCarloWithLocalOptimization_swigregister(MonteCarloWithLocalOptimization)
class MonteCarloWithBasinHopping(MonteCarloWithLocalOptimization):
    r"""Proxy of C++ IMP::core::MonteCarloWithBasinHopping class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, opt, ns):
        r"""__init__(MonteCarloWithBasinHopping self, Optimizer opt, unsigned int ns) -> MonteCarloWithBasinHopping"""
        _IMP_core.MonteCarloWithBasinHopping_swiginit(self, _IMP_core.new_MonteCarloWithBasinHopping(opt, ns))
    __swig_destroy__ = _IMP_core.delete_MonteCarloWithBasinHopping

    def __str__(self):
        r"""__str__(MonteCarloWithBasinHopping self) -> std::string"""
        return _IMP_core.MonteCarloWithBasinHopping___str__(self)

    def __repr__(self):
        r"""__repr__(MonteCarloWithBasinHopping self) -> std::string"""
        return _IMP_core.MonteCarloWithBasinHopping___repr__(self)

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


# Register MonteCarloWithBasinHopping in _IMP_core:
_IMP_core.MonteCarloWithBasinHopping_swigregister(MonteCarloWithBasinHopping)
class NeighborsTable(IMP.ScoreState):
    r"""Proxy of C++ IMP::core::NeighborsTable class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(NeighborsTable self, PairContainer input, std::string name="CloseNeighborsTable%1%") -> NeighborsTable"""
        _IMP_core.NeighborsTable_swiginit(self, _IMP_core.new_NeighborsTable(*args))

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

    def get_version_info(self):
        r"""get_version_info(NeighborsTable self) -> VersionInfo"""
        return _IMP_core.NeighborsTable_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_NeighborsTable

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

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

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


# Register NeighborsTable in _IMP_core:
_IMP_core.NeighborsTable_swigregister(NeighborsTable)
class NormalMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::NormalMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(NormalMover self, Model m, ParticleIndex pi, IMP::FloatKeys const & vars, double stddev) -> NormalMover
        __init__(NormalMover self, Model m, ParticleIndex pi, double stddev) -> NormalMover
        __init__(NormalMover self, IMP::ParticlesTemp const & sc, IMP::FloatKeys const & vars, IMP::Float sigma) -> NormalMover
        __init__(NormalMover self, IMP::ParticlesTemp const & sc, IMP::Float radius) -> NormalMover
        __init__(NormalMover self) -> NormalMover
        """
        _IMP_core.NormalMover_swiginit(self, _IMP_core.new_NormalMover(*args))

    def set_sigma(self, sigma):
        r"""set_sigma(NormalMover self, IMP::Float sigma)"""
        return _IMP_core.NormalMover_set_sigma(self, sigma)

    def get_sigma(self):
        r"""get_sigma(NormalMover self) -> IMP::Float"""
        return _IMP_core.NormalMover_get_sigma(self)

    def get_version_info(self):
        r"""get_version_info(NormalMover self) -> VersionInfo"""
        return _IMP_core.NormalMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_NormalMover

    def __str__(self):
        r"""__str__(NormalMover self) -> std::string"""
        return _IMP_core.NormalMover___str__(self)

    def __repr__(self):
        r"""__repr__(NormalMover self) -> std::string"""
        return _IMP_core.NormalMover___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(NormalMover self) -> PyObject *"""
        return _IMP_core.NormalMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(NormalMover self, PyObject * p)"""
        return _IMP_core.NormalMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register NormalMover in _IMP_core:
_IMP_core.NormalMover_swigregister(NormalMover)
class OpenCubicSpline(_OpenCubicSplineBase):
    r"""Proxy of C++ IMP::core::OpenCubicSpline class."""

    thisown = 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):
        r"""__init__(OpenCubicSpline self, IMP::Floats const & values, IMP::Float minrange, IMP::Float spacing, bool extend=False) -> OpenCubicSpline"""
        _IMP_core.OpenCubicSpline_swiginit(self, _IMP_core.new_OpenCubicSpline(values, minrange, spacing, extend))

    def get_minrange(self):
        r"""get_minrange(OpenCubicSpline self) -> IMP::Float"""
        return _IMP_core.OpenCubicSpline_get_minrange(self)

    def get_spacing(self):
        r"""get_spacing(OpenCubicSpline self) -> IMP::Float"""
        return _IMP_core.OpenCubicSpline_get_spacing(self)

    def get_values(self):
        r"""get_values(OpenCubicSpline self) -> IMP::Floats"""
        return _IMP_core.OpenCubicSpline_get_values(self)

    def get_extend(self):
        r"""get_extend(OpenCubicSpline self) -> bool"""
        return _IMP_core.OpenCubicSpline_get_extend(self)

    def get_second_derivatives(self):
        r"""get_second_derivatives(OpenCubicSpline self) -> IMP::Floats"""
        return _IMP_core.OpenCubicSpline_get_second_derivatives(self)

    def __str__(self):
        r"""__str__(OpenCubicSpline self) -> std::string"""
        return _IMP_core.OpenCubicSpline___str__(self)

    def __repr__(self):
        r"""__repr__(OpenCubicSpline self) -> std::string"""
        return _IMP_core.OpenCubicSpline___repr__(self)

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


    def _get_jax(self):
        import jax.numpy as jnp
        from IMP.core._jax_util import _spline
        def score(feature, minrange, maxrange, spacing, values, second_derivs):
    # clip feature to range (extend=True behavior)
            feature = jnp.clip(feature, minrange, maxrange)
    # determine bin index and thus the cubic fragment to use:
            lowbin = jnp.array((feature - minrange) / spacing, dtype=int)
            return _spline(feature, minrange, lowbin, lowbin + 1, spacing,
                           values, second_derivs)
        spacing = self.get_spacing()
        minrange = self.get_minrange()
        values = jnp.asarray(self.get_values())
        maxrange = minrange + spacing * (len(values) - 1)
        return functools.partial(
            score, minrange=minrange, maxrange=maxrange,
            spacing=spacing, values=values,
            second_derivs=jnp.asarray(self.get_second_derivatives()))

    __swig_destroy__ = _IMP_core.delete_OpenCubicSpline

# Register OpenCubicSpline in _IMP_core:
_IMP_core.OpenCubicSpline_swigregister(OpenCubicSpline)
class QuadraticClosePairsFinder(ClosePairsFinder):
    r"""Proxy of C++ IMP::core::QuadraticClosePairsFinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self):
        r"""__init__(QuadraticClosePairsFinder self) -> QuadraticClosePairsFinder"""
        _IMP_core.QuadraticClosePairsFinder_swiginit(self, _IMP_core.new_QuadraticClosePairsFinder())

    def get_are_close_and_filtered(self, *args):
        r"""
        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):
        r"""
        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):
        r"""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):
        r"""get_version_info(QuadraticClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.QuadraticClosePairsFinder_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_QuadraticClosePairsFinder

    def __str__(self):
        r"""__str__(QuadraticClosePairsFinder self) -> std::string"""
        return _IMP_core.QuadraticClosePairsFinder___str__(self)

    def __repr__(self):
        r"""__repr__(QuadraticClosePairsFinder self) -> std::string"""
        return _IMP_core.QuadraticClosePairsFinder___repr__(self)

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


# Register QuadraticClosePairsFinder in _IMP_core:
_IMP_core.QuadraticClosePairsFinder_swigregister(QuadraticClosePairsFinder)
class RefinedPairsPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::RefinedPairsPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, r, f):
        r"""__init__(RefinedPairsPairScore self, Refiner r, PairScore f) -> RefinedPairsPairScore"""
        _IMP_core.RefinedPairsPairScore_swiginit(self, _IMP_core.new_RefinedPairsPairScore(r, f))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(RefinedPairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RefinedPairsPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(RefinedPairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RefinedPairsPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(RefinedPairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RefinedPairsPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(RefinedPairsPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RefinedPairsPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(RefinedPairsPairScore self) -> VersionInfo"""
        return _IMP_core.RefinedPairsPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RefinedPairsPairScore

    def __str__(self):
        r"""__str__(RefinedPairsPairScore self) -> std::string"""
        return _IMP_core.RefinedPairsPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(RefinedPairsPairScore self) -> std::string"""
        return _IMP_core.RefinedPairsPairScore___repr__(self)

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


# Register RefinedPairsPairScore in _IMP_core:
_IMP_core.RefinedPairsPairScore_swigregister(RefinedPairsPairScore)
class RigidBody(XYZ):
    r"""Proxy of C++ IMP::core::RigidBody class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def get_rotation_keys():
        r"""get_rotation_keys() -> IMP::FloatKeys"""
        return _IMP_core.RigidBody_get_rotation_keys()

    def get_member_particle_indexes(self):
        r"""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):
        r"""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):
        r"""get_member_indexes(RigidBody self) -> IMP::ParticleIndexes"""
        return _IMP_core.RigidBody_get_member_indexes(self)

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

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

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

    def __init__(self, *args):
        r"""
        __init__(RigidBody self) -> RigidBody
        __init__(RigidBody self, Model m, ParticleIndex id) -> RigidBody
        __init__(RigidBody self, _ParticleAdaptor d) -> RigidBody
        __init__(RigidBody self, RigidBody arg2) -> RigidBody
        """
        _IMP_core.RigidBody_swiginit(self, _IMP_core.new_RigidBody(*args))
    __swig_destroy__ = _IMP_core.delete_RigidBody

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

    def get_coordinates(self):
        r"""get_coordinates(RigidBody self) -> Vector3D"""
        return _IMP_core.RigidBody_get_coordinates(self)

    def get_rotation(self):
        r"""get_rotation(RigidBody self) -> Rotation3D"""
        return _IMP_core.RigidBody_get_rotation(self)

    def get_reference_frame(self):
        r"""get_reference_frame(RigidBody self) -> ReferenceFrame3D"""
        return _IMP_core.RigidBody_get_reference_frame(self)

    def set_reference_frame(self, tr):
        r"""set_reference_frame(RigidBody self, ReferenceFrame3D tr)"""
        return _IMP_core.RigidBody_set_reference_frame(self, tr)

    def set_reference_frame_lazy(self, tr):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""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):
        r"""get_torque(RigidBody self) -> Vector3D"""
        return _IMP_core.RigidBody_get_torque(self)

    def get_coordinates_are_optimized(self):
        r"""get_coordinates_are_optimized(RigidBody self) -> bool"""
        return _IMP_core.RigidBody_get_coordinates_are_optimized(self)

    def set_coordinates_are_optimized(self, tf):
        r"""set_coordinates_are_optimized(RigidBody self, bool tf)"""
        return _IMP_core.RigidBody_set_coordinates_are_optimized(self, tf)

    def normalize_rotation(self):
        r"""normalize_rotation(RigidBody self)"""
        return _IMP_core.RigidBody_normalize_rotation(self)

    def update_members(self):
        r"""update_members(RigidBody self)"""
        return _IMP_core.RigidBody_update_members(self)

    def get_rotational_derivatives(self):
        r"""get_rotational_derivatives(RigidBody self) -> Vector4D"""
        return _IMP_core.RigidBody_get_rotational_derivatives(self)

    def get_number_of_members(self):
        r"""get_number_of_members(RigidBody self) -> unsigned int"""
        return _IMP_core.RigidBody_get_number_of_members(self)

    def get_member(self, i):
        r"""get_member(RigidBody self, unsigned int i) -> RigidBodyMember"""
        return _IMP_core.RigidBody_get_member(self, i)

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

    def add_non_rigid_member(self, p):
        r"""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):
        r"""set_is_rigid_member(RigidBody self, ParticleIndex pi, bool tf)"""
        return _IMP_core.RigidBody_set_is_rigid_member(self, pi, tf)

    def remove_member(self, p):
        r"""remove_member(RigidBody self, _ParticleIndexAdaptor p)"""
        return _IMP_core.RigidBody_remove_member(self, p)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(RigidBody self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(RigidBody self, SparseIntKey a0, IMP::Int a1)
        add_attribute(RigidBody self, SparseStringKey a0, IMP::String a1)
        add_attribute(RigidBody self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.RigidBody_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(RigidBody self, SparseFloatKey a0) -> IMP::Float
        get_value(RigidBody self, SparseIntKey a0) -> IMP::Int
        get_value(RigidBody self, SparseStringKey a0) -> IMP::String
        get_value(RigidBody self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.RigidBody_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(RigidBody self, SparseFloatKey a0, IMP::Float a1)
        set_value(RigidBody self, SparseIntKey a0, IMP::Int a1)
        set_value(RigidBody self, SparseStringKey a0, IMP::String a1)
        set_value(RigidBody self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.RigidBody_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(RigidBody self, SparseFloatKey a0)
        remove_attribute(RigidBody self, SparseIntKey a0)
        remove_attribute(RigidBody self, SparseStringKey a0)
        remove_attribute(RigidBody self, SparseParticleIndexKey a0)
        """
        return _IMP_core.RigidBody_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(RigidBody self, SparseFloatKey a0) -> bool
        has_attribute(RigidBody self, SparseIntKey a0) -> bool
        has_attribute(RigidBody self, SparseStringKey a0) -> bool
        has_attribute(RigidBody self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.RigidBody_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(RigidBody self, FloatKey a0) -> double"""
        return _IMP_core.RigidBody_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(RigidBody self) -> std::string"""
        return _IMP_core.RigidBody_get_name(self)

    def clear_caches(self):
        r"""clear_caches(RigidBody self)"""
        return _IMP_core.RigidBody_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(RigidBody self, std::string a0)"""
        return _IMP_core.RigidBody_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(RigidBody self, FloatKey a0) -> bool"""
        return _IMP_core.RigidBody_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(RigidBody self) -> IMP::CheckLevel"""
        return _IMP_core.RigidBody_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(RigidBody self, RigidBody o) -> bool
        __eq__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(RigidBody self, RigidBody o) -> bool
        __ne__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(RigidBody self, RigidBody o) -> bool
        __le__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(RigidBody self, RigidBody o) -> bool
        __lt__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(RigidBody self, RigidBody o) -> bool
        __ge__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(RigidBody self, RigidBody o) -> bool
        __gt__(RigidBody self, Particle d) -> bool
        """
        return _IMP_core.RigidBody___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(RigidBody self) -> std::size_t"""
        return _IMP_core.RigidBody___hash__(self)

    def __str__(self):
        r"""__str__(RigidBody self) -> std::string"""
        return _IMP_core.RigidBody___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBody self) -> std::string"""
        return _IMP_core.RigidBody___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(RigidBody self) -> PyObject *"""
        return _IMP_core.RigidBody__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RigidBody self, PyObject * p)"""
        return _IMP_core.RigidBody__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register RigidBody in _IMP_core:
_IMP_core.RigidBody_swigregister(RigidBody)

def add_rigid_body_cache_key(k):
    r"""add_rigid_body_cache_key(ObjectKey k)"""
    return _IMP_core.add_rigid_body_cache_key(k)
class RigidBodyMember(XYZ):
    r"""Proxy of C++ IMP::core::RigidBodyMember class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

    def get_internal_transformation(self):
        r"""get_internal_transformation(RigidBodyMember self) -> Transformation3D"""
        return _IMP_core.RigidBodyMember_get_internal_transformation(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyMember

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

    def __init__(self, *args):
        r"""
        __init__(RigidBodyMember self) -> RigidBodyMember
        __init__(RigidBodyMember self, Model m, ParticleIndex id) -> RigidBodyMember
        __init__(RigidBodyMember self, _ParticleAdaptor d) -> RigidBodyMember
        __init__(RigidBodyMember self, RigidBodyMember arg2) -> RigidBodyMember
        """
        _IMP_core.RigidBodyMember_swiginit(self, _IMP_core.new_RigidBodyMember(*args))

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

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

    @staticmethod
    def get_internal_rotation_keys():
        r"""get_internal_rotation_keys() -> IMP::FloatKeys"""
        return _IMP_core.RigidBodyMember_get_internal_rotation_keys()

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(RigidBodyMember self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(RigidBodyMember self, SparseIntKey a0, IMP::Int a1)
        add_attribute(RigidBodyMember self, SparseStringKey a0, IMP::String a1)
        add_attribute(RigidBodyMember self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.RigidBodyMember_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(RigidBodyMember self, SparseFloatKey a0) -> IMP::Float
        get_value(RigidBodyMember self, SparseIntKey a0) -> IMP::Int
        get_value(RigidBodyMember self, SparseStringKey a0) -> IMP::String
        get_value(RigidBodyMember self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.RigidBodyMember_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(RigidBodyMember self, SparseFloatKey a0, IMP::Float a1)
        set_value(RigidBodyMember self, SparseIntKey a0, IMP::Int a1)
        set_value(RigidBodyMember self, SparseStringKey a0, IMP::String a1)
        set_value(RigidBodyMember self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.RigidBodyMember_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(RigidBodyMember self, SparseFloatKey a0)
        remove_attribute(RigidBodyMember self, SparseIntKey a0)
        remove_attribute(RigidBodyMember self, SparseStringKey a0)
        remove_attribute(RigidBodyMember self, SparseParticleIndexKey a0)
        """
        return _IMP_core.RigidBodyMember_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(RigidBodyMember self, SparseFloatKey a0) -> bool
        has_attribute(RigidBodyMember self, SparseIntKey a0) -> bool
        has_attribute(RigidBodyMember self, SparseStringKey a0) -> bool
        has_attribute(RigidBodyMember self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.RigidBodyMember_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(RigidBodyMember self, FloatKey a0) -> bool"""
        return _IMP_core.RigidBodyMember_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(RigidBodyMember self) -> PyObject *"""
        return _IMP_core.RigidBodyMember__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RigidBodyMember self, PyObject * p)"""
        return _IMP_core.RigidBodyMember__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register RigidBodyMember in _IMP_core:
_IMP_core.RigidBodyMember_swigregister(RigidBodyMember)
class RigidMember(RigidBodyMember):
    r"""Proxy of C++ IMP::core::RigidMember class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __init__(self, *args):
        r"""
        __init__(RigidMember self) -> RigidMember
        __init__(RigidMember self, Model m, ParticleIndex id) -> RigidMember
        __init__(RigidMember self, _ParticleAdaptor d) -> RigidMember
        __init__(RigidMember self, RigidMember arg2) -> RigidMember
        """
        _IMP_core.RigidMember_swiginit(self, _IMP_core.new_RigidMember(*args))
    __swig_destroy__ = _IMP_core.delete_RigidMember

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(RigidMember self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(RigidMember self, SparseIntKey a0, IMP::Int a1)
        add_attribute(RigidMember self, SparseStringKey a0, IMP::String a1)
        add_attribute(RigidMember self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.RigidMember_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(RigidMember self, SparseFloatKey a0) -> IMP::Float
        get_value(RigidMember self, SparseIntKey a0) -> IMP::Int
        get_value(RigidMember self, SparseStringKey a0) -> IMP::String
        get_value(RigidMember self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.RigidMember_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(RigidMember self, SparseFloatKey a0, IMP::Float a1)
        set_value(RigidMember self, SparseIntKey a0, IMP::Int a1)
        set_value(RigidMember self, SparseStringKey a0, IMP::String a1)
        set_value(RigidMember self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.RigidMember_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(RigidMember self, SparseFloatKey a0)
        remove_attribute(RigidMember self, SparseIntKey a0)
        remove_attribute(RigidMember self, SparseStringKey a0)
        remove_attribute(RigidMember self, SparseParticleIndexKey a0)
        """
        return _IMP_core.RigidMember_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(RigidMember self, SparseFloatKey a0) -> bool
        has_attribute(RigidMember self, SparseIntKey a0) -> bool
        has_attribute(RigidMember self, SparseStringKey a0) -> bool
        has_attribute(RigidMember self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.RigidMember_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(RigidMember self, FloatKey a0) -> double"""
        return _IMP_core.RigidMember_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(RigidMember self) -> std::string"""
        return _IMP_core.RigidMember_get_name(self)

    def clear_caches(self):
        r"""clear_caches(RigidMember self)"""
        return _IMP_core.RigidMember_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(RigidMember self, std::string a0)"""
        return _IMP_core.RigidMember_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(RigidMember self, FloatKey a0) -> bool"""
        return _IMP_core.RigidMember_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(RigidMember self) -> IMP::CheckLevel"""
        return _IMP_core.RigidMember_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(RigidMember self, RigidMember o) -> bool
        __eq__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(RigidMember self, RigidMember o) -> bool
        __ne__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(RigidMember self, RigidMember o) -> bool
        __le__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(RigidMember self, RigidMember o) -> bool
        __lt__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(RigidMember self, RigidMember o) -> bool
        __ge__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(RigidMember self, RigidMember o) -> bool
        __gt__(RigidMember self, Particle d) -> bool
        """
        return _IMP_core.RigidMember___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(RigidMember self) -> std::size_t"""
        return _IMP_core.RigidMember___hash__(self)

    def __str__(self):
        r"""__str__(RigidMember self) -> std::string"""
        return _IMP_core.RigidMember___str__(self)

    def __repr__(self):
        r"""__repr__(RigidMember self) -> std::string"""
        return _IMP_core.RigidMember___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(RigidMember self) -> PyObject *"""
        return _IMP_core.RigidMember__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RigidMember self, PyObject * p)"""
        return _IMP_core.RigidMember__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register RigidMember in _IMP_core:
_IMP_core.RigidMember_swigregister(RigidMember)
class NonRigidMember(RigidBodyMember):
    r"""Proxy of C++ IMP::core::NonRigidMember class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def __init__(self, *args):
        r"""
        __init__(NonRigidMember self) -> NonRigidMember
        __init__(NonRigidMember self, Model m, ParticleIndex id) -> NonRigidMember
        __init__(NonRigidMember self, _ParticleAdaptor d) -> NonRigidMember
        __init__(NonRigidMember self, NonRigidMember arg2) -> NonRigidMember
        """
        _IMP_core.NonRigidMember_swiginit(self, _IMP_core.new_NonRigidMember(*args))
    __swig_destroy__ = _IMP_core.delete_NonRigidMember

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

    def add_to_internal_derivatives(self, deriv_parent, da):
        r"""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):
        r"""
        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):
        r"""get_internal_derivatives(NonRigidMember self) -> Vector3D"""
        return _IMP_core.NonRigidMember_get_internal_derivatives(self)

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(NonRigidMember self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(NonRigidMember self, SparseIntKey a0, IMP::Int a1)
        add_attribute(NonRigidMember self, SparseStringKey a0, IMP::String a1)
        add_attribute(NonRigidMember self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.NonRigidMember_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(NonRigidMember self, SparseFloatKey a0) -> IMP::Float
        get_value(NonRigidMember self, SparseIntKey a0) -> IMP::Int
        get_value(NonRigidMember self, SparseStringKey a0) -> IMP::String
        get_value(NonRigidMember self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.NonRigidMember_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(NonRigidMember self, SparseFloatKey a0, IMP::Float a1)
        set_value(NonRigidMember self, SparseIntKey a0, IMP::Int a1)
        set_value(NonRigidMember self, SparseStringKey a0, IMP::String a1)
        set_value(NonRigidMember self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.NonRigidMember_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(NonRigidMember self, SparseFloatKey a0)
        remove_attribute(NonRigidMember self, SparseIntKey a0)
        remove_attribute(NonRigidMember self, SparseStringKey a0)
        remove_attribute(NonRigidMember self, SparseParticleIndexKey a0)
        """
        return _IMP_core.NonRigidMember_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(NonRigidMember self, SparseFloatKey a0) -> bool
        has_attribute(NonRigidMember self, SparseIntKey a0) -> bool
        has_attribute(NonRigidMember self, SparseStringKey a0) -> bool
        has_attribute(NonRigidMember self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.NonRigidMember_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(NonRigidMember self, FloatKey a0) -> double"""
        return _IMP_core.NonRigidMember_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(NonRigidMember self) -> std::string"""
        return _IMP_core.NonRigidMember_get_name(self)

    def clear_caches(self):
        r"""clear_caches(NonRigidMember self)"""
        return _IMP_core.NonRigidMember_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(NonRigidMember self, std::string a0)"""
        return _IMP_core.NonRigidMember_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(NonRigidMember self, FloatKey a0) -> bool"""
        return _IMP_core.NonRigidMember_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(NonRigidMember self) -> IMP::CheckLevel"""
        return _IMP_core.NonRigidMember_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(NonRigidMember self, NonRigidMember o) -> bool
        __eq__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(NonRigidMember self, NonRigidMember o) -> bool
        __ne__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(NonRigidMember self, NonRigidMember o) -> bool
        __le__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(NonRigidMember self, NonRigidMember o) -> bool
        __lt__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(NonRigidMember self, NonRigidMember o) -> bool
        __ge__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(NonRigidMember self, NonRigidMember o) -> bool
        __gt__(NonRigidMember self, Particle d) -> bool
        """
        return _IMP_core.NonRigidMember___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(NonRigidMember self) -> std::size_t"""
        return _IMP_core.NonRigidMember___hash__(self)

    def __str__(self):
        r"""__str__(NonRigidMember self) -> std::string"""
        return _IMP_core.NonRigidMember___str__(self)

    def __repr__(self):
        r"""__repr__(NonRigidMember self) -> std::string"""
        return _IMP_core.NonRigidMember___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(NonRigidMember self) -> PyObject *"""
        return _IMP_core.NonRigidMember__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(NonRigidMember self, PyObject * p)"""
        return _IMP_core.NonRigidMember__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register NonRigidMember in _IMP_core:
_IMP_core.NonRigidMember_swigregister(NonRigidMember)
class RigidMembersRefiner(IMP.Refiner):
    r"""Proxy of C++ IMP::core::RigidMembersRefiner class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(RigidMembersRefiner self, std::string name="RigidMembersRefiner%d") -> RigidMembersRefiner"""
        _IMP_core.RigidMembersRefiner_swiginit(self, _IMP_core.new_RigidMembersRefiner(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(RigidMembersRefiner self) -> VersionInfo"""
        return _IMP_core.RigidMembersRefiner_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidMembersRefiner

    def __str__(self):
        r"""__str__(RigidMembersRefiner self) -> std::string"""
        return _IMP_core.RigidMembersRefiner___str__(self)

    def __repr__(self):
        r"""__repr__(RigidMembersRefiner self) -> std::string"""
        return _IMP_core.RigidMembersRefiner___repr__(self)

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


# Register RigidMembersRefiner in _IMP_core:
_IMP_core.RigidMembersRefiner_swigregister(RigidMembersRefiner)

def get_rigid_members_refiner():
    r"""get_rigid_members_refiner() -> RigidMembersRefiner"""
    return _IMP_core.get_rigid_members_refiner()

def transform(*args):
    r"""
    transform(XYZ a, Transformation3D tr)
    transform(RigidBody a, Transformation3D tr)
    """
    return _IMP_core.transform(*args)

def get_initial_reference_frame(*args):
    r"""
    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):
    r"""create_rigid_bodies(Model m, unsigned int n, bool no_members=False) -> IMP::ParticlesTemp"""
    return _IMP_core.create_rigid_bodies(m, n, no_members)

def show_rigid_body_hierarchy(*args):
    r"""show_rigid_body_hierarchy(RigidBody rb, TextOutput out=IMP::TextOutput(std::cout))"""
    return _IMP_core.show_rigid_body_hierarchy(*args)

def get_root_rigid_body(m):
    r"""get_root_rigid_body(RigidMember m) -> ParticleIndex"""
    return _IMP_core.get_root_rigid_body(m)
class _UpdateRigidBodyMembers(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::internal::_UpdateRigidBodyMembers class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(_UpdateRigidBodyMembers self, std::string name="UpdateRigidBodyMembers%1%") -> _UpdateRigidBodyMembers"""
        _IMP_core._UpdateRigidBodyMembers_swiginit(self, _IMP_core.new__UpdateRigidBodyMembers(*args))

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

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

    def get_version_info(self):
        r"""get_version_info(_UpdateRigidBodyMembers self) -> VersionInfo"""
        return _IMP_core._UpdateRigidBodyMembers_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete__UpdateRigidBodyMembers

    def __str__(self):
        r"""__str__(_UpdateRigidBodyMembers self) -> std::string"""
        return _IMP_core._UpdateRigidBodyMembers___str__(self)

    def __repr__(self):
        r"""__repr__(_UpdateRigidBodyMembers self) -> std::string"""
        return _IMP_core._UpdateRigidBodyMembers___repr__(self)

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


# Register _UpdateRigidBodyMembers in _IMP_core:
_IMP_core._UpdateRigidBodyMembers_swigregister(_UpdateRigidBodyMembers)
class _AccumulateRigidBodyDerivatives(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::internal::_AccumulateRigidBodyDerivatives class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(_AccumulateRigidBodyDerivatives self, std::string name="AccumulateRigidBodyDerivatives%1%") -> _AccumulateRigidBodyDerivatives"""
        _IMP_core._AccumulateRigidBodyDerivatives_swiginit(self, _IMP_core.new__AccumulateRigidBodyDerivatives(*args))

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

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

    def get_version_info(self):
        r"""get_version_info(_AccumulateRigidBodyDerivatives self) -> VersionInfo"""
        return _IMP_core._AccumulateRigidBodyDerivatives_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete__AccumulateRigidBodyDerivatives

    def __str__(self):
        r"""__str__(_AccumulateRigidBodyDerivatives self) -> std::string"""
        return _IMP_core._AccumulateRigidBodyDerivatives___str__(self)

    def __repr__(self):
        r"""__repr__(_AccumulateRigidBodyDerivatives self) -> std::string"""
        return _IMP_core._AccumulateRigidBodyDerivatives___repr__(self)

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


# Register _AccumulateRigidBodyDerivatives in _IMP_core:
_IMP_core._AccumulateRigidBodyDerivatives_swigregister(_AccumulateRigidBodyDerivatives)
class _NormalizeRotation(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::core::internal::_NormalizeRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(_NormalizeRotation self, std::string name="NormalizeRotation%1%") -> _NormalizeRotation"""
        _IMP_core._NormalizeRotation_swiginit(self, _IMP_core.new__NormalizeRotation(*args))

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

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

    def get_version_info(self):
        r"""get_version_info(_NormalizeRotation self) -> VersionInfo"""
        return _IMP_core._NormalizeRotation_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete__NormalizeRotation

    def __str__(self):
        r"""__str__(_NormalizeRotation self) -> std::string"""
        return _IMP_core._NormalizeRotation___str__(self)

    def __repr__(self):
        r"""__repr__(_NormalizeRotation self) -> std::string"""
        return _IMP_core._NormalizeRotation___repr__(self)

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


# Register _NormalizeRotation in _IMP_core:
_IMP_core._NormalizeRotation_swigregister(_NormalizeRotation)
class _RigidBodyNormalizeConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::internal::_RigidBodyNormalizeConstraint class."""

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

    def get_before_modifier(self):
        r"""get_before_modifier(_RigidBodyNormalizeConstraint self) -> _NormalizeRotation"""
        return _IMP_core._RigidBodyNormalizeConstraint_get_before_modifier(self)

    def get_container(self):
        r"""get_container(_RigidBodyNormalizeConstraint self) -> Container"""
        return _IMP_core._RigidBodyNormalizeConstraint_get_container(self)

    def get_version_info(self):
        r"""get_version_info(_RigidBodyNormalizeConstraint self) -> VersionInfo"""
        return _IMP_core._RigidBodyNormalizeConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete__RigidBodyNormalizeConstraint

    def __str__(self):
        r"""__str__(_RigidBodyNormalizeConstraint self) -> std::string"""
        return _IMP_core._RigidBodyNormalizeConstraint___str__(self)

    def __repr__(self):
        r"""__repr__(_RigidBodyNormalizeConstraint self) -> std::string"""
        return _IMP_core._RigidBodyNormalizeConstraint___repr__(self)

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


# Register _RigidBodyNormalizeConstraint in _IMP_core:
_IMP_core._RigidBodyNormalizeConstraint_swigregister(_RigidBodyNormalizeConstraint)
class _RigidBodyPositionConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::internal::_RigidBodyPositionConstraint class."""

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

    def get_version_info(self):
        r"""get_version_info(_RigidBodyPositionConstraint self) -> VersionInfo"""
        return _IMP_core._RigidBodyPositionConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete__RigidBodyPositionConstraint

    def get_before_modifier(self):
        r"""get_before_modifier(_RigidBodyPositionConstraint self) -> _UpdateRigidBodyMembers"""
        return _IMP_core._RigidBodyPositionConstraint_get_before_modifier(self)

    def get_after_modifier(self):
        r"""get_after_modifier(_RigidBodyPositionConstraint self) -> _AccumulateRigidBodyDerivatives"""
        return _IMP_core._RigidBodyPositionConstraint_get_after_modifier(self)

    def get_index(self):
        r"""get_index(_RigidBodyPositionConstraint self) -> ParticleIndex"""
        return _IMP_core._RigidBodyPositionConstraint_get_index(self)

    def __str__(self):
        r"""__str__(_RigidBodyPositionConstraint self) -> std::string"""
        return _IMP_core._RigidBodyPositionConstraint___str__(self)

    def __repr__(self):
        r"""__repr__(_RigidBodyPositionConstraint self) -> std::string"""
        return _IMP_core._RigidBodyPositionConstraint___repr__(self)

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


# Register _RigidBodyPositionConstraint in _IMP_core:
_IMP_core._RigidBodyPositionConstraint_swigregister(_RigidBodyPositionConstraint)
class RigidBodyHierarchyGeometry(IMP.display.SingletonGeometry):
    r"""Proxy of C++ IMP::core::RigidBodyHierarchyGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, rb, constituents):
        r"""__init__(RigidBodyHierarchyGeometry self, RigidBody rb, IMP::ParticlesTemp const & constituents) -> RigidBodyHierarchyGeometry"""
        _IMP_core.RigidBodyHierarchyGeometry_swiginit(self, _IMP_core.new_RigidBodyHierarchyGeometry(rb, constituents))

    def get_version_info(self):
        r"""get_version_info(RigidBodyHierarchyGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyHierarchyGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyHierarchyGeometry

    def __str__(self):
        r"""__str__(RigidBodyHierarchyGeometry self) -> std::string"""
        return _IMP_core.RigidBodyHierarchyGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyHierarchyGeometry self) -> std::string"""
        return _IMP_core.RigidBodyHierarchyGeometry___repr__(self)

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


# Register RigidBodyHierarchyGeometry in _IMP_core:
_IMP_core.RigidBodyHierarchyGeometry_swigregister(RigidBodyHierarchyGeometry)
class RigidBodyDerivativeGeometry(IMP.display.SingletonGeometry):
    r"""Proxy of C++ IMP::core::RigidBodyDerivativeGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(RigidBodyDerivativeGeometry self, Particle p) -> RigidBodyDerivativeGeometry
        __init__(RigidBodyDerivativeGeometry self, RigidBody d) -> RigidBodyDerivativeGeometry
        """
        _IMP_core.RigidBodyDerivativeGeometry_swiginit(self, _IMP_core.new_RigidBodyDerivativeGeometry(*args))

    def get_version_info(self):
        r"""get_version_info(RigidBodyDerivativeGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyDerivativeGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyDerivativeGeometry

    def __str__(self):
        r"""__str__(RigidBodyDerivativeGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativeGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyDerivativeGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativeGeometry___repr__(self)

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


# Register RigidBodyDerivativeGeometry in _IMP_core:
_IMP_core.RigidBodyDerivativeGeometry_swigregister(RigidBodyDerivativeGeometry)
class RigidBodyDerivativesGeometry(IMP.display.SingletonsGeometry):
    r"""Proxy of C++ IMP::core::RigidBodyDerivativesGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, sc):
        r"""__init__(RigidBodyDerivativesGeometry self, SingletonContainer sc) -> RigidBodyDerivativesGeometry"""
        _IMP_core.RigidBodyDerivativesGeometry_swiginit(self, _IMP_core.new_RigidBodyDerivativesGeometry(sc))

    def get_version_info(self):
        r"""get_version_info(RigidBodyDerivativesGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyDerivativesGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyDerivativesGeometry

    def __str__(self):
        r"""__str__(RigidBodyDerivativesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativesGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyDerivativesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyDerivativesGeometry___repr__(self)

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


# Register RigidBodyDerivativesGeometry in _IMP_core:
_IMP_core.RigidBodyDerivativesGeometry_swigregister(RigidBodyDerivativesGeometry)
class RigidBodyFrameGeometry(IMP.display.SingletonGeometry):
    r"""Proxy of C++ IMP::core::RigidBodyFrameGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(RigidBodyFrameGeometry self, Particle p) -> RigidBodyFrameGeometry
        __init__(RigidBodyFrameGeometry self, RigidBody d) -> RigidBodyFrameGeometry
        """
        _IMP_core.RigidBodyFrameGeometry_swiginit(self, _IMP_core.new_RigidBodyFrameGeometry(*args))

    def get_version_info(self):
        r"""get_version_info(RigidBodyFrameGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyFrameGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyFrameGeometry

    def __str__(self):
        r"""__str__(RigidBodyFrameGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFrameGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyFrameGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFrameGeometry___repr__(self)

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


# Register RigidBodyFrameGeometry in _IMP_core:
_IMP_core.RigidBodyFrameGeometry_swigregister(RigidBodyFrameGeometry)
class RigidBodyFramesGeometry(IMP.display.SingletonsGeometry):
    r"""Proxy of C++ IMP::core::RigidBodyFramesGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, sc):
        r"""__init__(RigidBodyFramesGeometry self, SingletonContainer sc) -> RigidBodyFramesGeometry"""
        _IMP_core.RigidBodyFramesGeometry_swiginit(self, _IMP_core.new_RigidBodyFramesGeometry(sc))

    def get_version_info(self):
        r"""get_version_info(RigidBodyFramesGeometry self) -> VersionInfo"""
        return _IMP_core.RigidBodyFramesGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyFramesGeometry

    def __str__(self):
        r"""__str__(RigidBodyFramesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFramesGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyFramesGeometry self) -> std::string"""
        return _IMP_core.RigidBodyFramesGeometry___repr__(self)

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


# Register RigidBodyFramesGeometry in _IMP_core:
_IMP_core.RigidBodyFramesGeometry_swigregister(RigidBodyFramesGeometry)
class RigidBodyTorque(IMP.display.SegmentGeometry):
    r"""Proxy of C++ IMP::core::RigidBodyTorque class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, p):
        r"""__init__(RigidBodyTorque self, Particle p) -> RigidBodyTorque"""
        _IMP_core.RigidBodyTorque_swiginit(self, _IMP_core.new_RigidBodyTorque(p))

    def __str__(self):
        r"""__str__(RigidBodyTorque self) -> std::string"""
        return _IMP_core.RigidBodyTorque___str__(self)

    def __repr__(self):
        r"""__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

# Register RigidBodyTorque in _IMP_core:
_IMP_core.RigidBodyTorque_swigregister(RigidBodyTorque)
class NearestNeighborsClosePairsFinder(ClosePairsFinder):
    r"""Proxy of C++ IMP::core::NearestNeighborsClosePairsFinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self):
        r"""__init__(NearestNeighborsClosePairsFinder self) -> NearestNeighborsClosePairsFinder"""
        _IMP_core.NearestNeighborsClosePairsFinder_swiginit(self, _IMP_core.new_NearestNeighborsClosePairsFinder())

    def get_close_pairs(self, *args):
        r"""
        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):
        r"""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):
        r"""get_version_info(NearestNeighborsClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.NearestNeighborsClosePairsFinder_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_NearestNeighborsClosePairsFinder

    def __str__(self):
        r"""__str__(NearestNeighborsClosePairsFinder self) -> std::string"""
        return _IMP_core.NearestNeighborsClosePairsFinder___str__(self)

    def __repr__(self):
        r"""__repr__(NearestNeighborsClosePairsFinder self) -> std::string"""
        return _IMP_core.NearestNeighborsClosePairsFinder___repr__(self)

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


# Register NearestNeighborsClosePairsFinder in _IMP_core:
_IMP_core.NearestNeighborsClosePairsFinder_swigregister(NearestNeighborsClosePairsFinder)
class RestraintsScoringFunction(IMP.ScoringFunction):
    r"""Proxy of C++ IMP::core::RestraintsScoringFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(RestraintsScoringFunction self, _RestraintsAdaptor rs, double weight=1.0, double max=NO_MAX, std::string name="RestraintsScoringFunction%1%") -> RestraintsScoringFunction
        __init__(RestraintsScoringFunction self, _RestraintsAdaptor rs, std::string name) -> RestraintsScoringFunction
        __init__(RestraintsScoringFunction self) -> RestraintsScoringFunction
        """
        _IMP_core.RestraintsScoringFunction_swiginit(self, _IMP_core.new_RestraintsScoringFunction(*args))

    def do_add_score_and_derivatives(self, sa, ss):
        r"""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):
        r"""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):
        r"""do_get_inputs(RestraintsScoringFunction self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.RestraintsScoringFunction_do_get_inputs(self)

    def get_restraints(self):
        r"""get_restraints(RestraintsScoringFunction self) -> IMP::Restraints"""
        return _IMP_core.RestraintsScoringFunction_get_restraints(self)

    def set_restraints(self, d):
        r"""set_restraints(RestraintsScoringFunction self, IMP::Restraints const & d)"""
        return _IMP_core.RestraintsScoringFunction_set_restraints(self, d)

    def get_number_of_restraints(self):
        r"""get_number_of_restraints(RestraintsScoringFunction self) -> unsigned int"""
        return _IMP_core.RestraintsScoringFunction_get_number_of_restraints(self)

    def clear_restraints(self):
        r"""clear_restraints(RestraintsScoringFunction self)"""
        return _IMP_core.RestraintsScoringFunction_clear_restraints(self)

    def get_restraint(self, i):
        r"""get_restraint(RestraintsScoringFunction self, unsigned int i) -> Restraint"""
        return _IMP_core.RestraintsScoringFunction_get_restraint(self, i)

    def erase_restraint(self, i):
        r"""erase_restraint(RestraintsScoringFunction self, unsigned int i)"""
        return _IMP_core.RestraintsScoringFunction_erase_restraint(self, i)

    def add_restraint(self, d):
        r"""add_restraint(RestraintsScoringFunction self, Restraint d) -> unsigned int"""
        return _IMP_core.RestraintsScoringFunction_add_restraint(self, d)

    def add_restraints(self, d):
        r"""add_restraints(RestraintsScoringFunction self, IMP::Restraints const & d)"""
        return _IMP_core.RestraintsScoringFunction_add_restraints(self, d)

    def _python_index_restraint(self, r, start, stop):
        r"""_python_index_restraint(RestraintsScoringFunction self, Restraint r, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_core.RestraintsScoringFunction__python_index_restraint(self, r, start, stop)
    def __get_restraints(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_restraints,  getfunc=self.get_restraint, erasefunc=self.erase_restraint,  appendfunc=self.add_restraint, extendfunc=self.add_restraints,  clearfunc=self.clear_restraints, indexfunc=self._python_index_restraint)  
    def __set_restraints(self, obj): IMP._list_util.set_varlist(self.restraints, obj)  
    def __del_restraints(self): IMP._list_util.del_varlist(self.restraints)       
    restraints = property(__get_restraints, __set_restraints, __del_restraints, doc="List of ##Restraints")  

    def get_version_info(self):
        r"""get_version_info(RestraintsScoringFunction self) -> VersionInfo"""
        return _IMP_core.RestraintsScoringFunction_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RestraintsScoringFunction

    def __str__(self):
        r"""__str__(RestraintsScoringFunction self) -> std::string"""
        return _IMP_core.RestraintsScoringFunction___str__(self)

    def __repr__(self):
        r"""__repr__(RestraintsScoringFunction self) -> std::string"""
        return _IMP_core.RestraintsScoringFunction___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(RestraintsScoringFunction self) -> PyObject *"""
        return _IMP_core.RestraintsScoringFunction__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RestraintsScoringFunction self, PyObject * p)"""
        return _IMP_core.RestraintsScoringFunction__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import IMP._jax_util
        jis = [r.get_derived_object()._get_jax() for r in self.restraints]
        funcs = [j.score_func for j in jis]
        keys = frozenset(x for j in jis for x in j._keys)
        def jax_sf(jm):
            return sum(f(jm) for f in funcs)
        return IMP._jax_util.JAXRestraintInfo(
            m=self.get_model(), score_func=jax_sf, weight=1.0, keys=keys)


# Register RestraintsScoringFunction in _IMP_core:
_IMP_core.RestraintsScoringFunction_swigregister(RestraintsScoringFunction)
class RigidClosePairsFinder(ClosePairsFinder):
    r"""Proxy of C++ IMP::core::RigidClosePairsFinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, cpf=None):
        r"""__init__(RigidClosePairsFinder self, ClosePairsFinder cpf=None) -> RigidClosePairsFinder"""
        _IMP_core.RigidClosePairsFinder_swiginit(self, _IMP_core.new_RigidClosePairsFinder(cpf))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""get_version_info(RigidClosePairsFinder self) -> VersionInfo"""
        return _IMP_core.RigidClosePairsFinder_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidClosePairsFinder

    def __str__(self):
        r"""__str__(RigidClosePairsFinder self) -> std::string"""
        return _IMP_core.RigidClosePairsFinder___str__(self)

    def __repr__(self):
        r"""__repr__(RigidClosePairsFinder self) -> std::string"""
        return _IMP_core.RigidClosePairsFinder___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(RigidClosePairsFinder self) -> PyObject *"""
        return _IMP_core.RigidClosePairsFinder__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RigidClosePairsFinder self, PyObject * p)"""
        return _IMP_core.RigidClosePairsFinder__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register RigidClosePairsFinder in _IMP_core:
_IMP_core.RigidClosePairsFinder_swigregister(RigidClosePairsFinder)
class _SphereDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::SphereDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        SphereDistancePairScore(UnaryFunction uf, std::string name="SphereDistancePairScore%1%") -> _SphereDistancePairScore
        __init__(_SphereDistancePairScore self) -> _SphereDistancePairScore
        """
        _IMP_core._SphereDistancePairScore_swiginit(self, _IMP_core.new__SphereDistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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_score_functor(self, *args):
        r"""
        get_score_functor(_SphereDistancePairScore self) -> _SphereDistanceUF
        get_score_functor(_SphereDistancePairScore self) -> _SphereDistanceUF
        """
        return _IMP_core._SphereDistancePairScore_get_score_functor(self, *args)

    def get_version_info(self):
        r"""get_version_info(_SphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core._SphereDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete__SphereDistancePairScore

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


    def _get_as_binary(self):
        r"""_get_as_binary(_SphereDistancePairScore self) -> PyObject *"""
        return _IMP_core._SphereDistancePairScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(_SphereDistancePairScore self, PyObject * p)"""
        return _IMP_core._SphereDistancePairScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        def jax_score(jm, uf):
            xyzs = jm['xyz'][indexes]
            rs = jm['r'][indexes]
            diff = xyzs[:,0] - xyzs[:,1]
            drs = jnp.linalg.norm(diff, axis=1) - rs.sum(axis=1)
            return uf(drs)
        sfnc = self.get_score_functor()
        uf = sfnc.get_unary_function().get_derived_object()
        f = functools.partial(jax_score, uf=uf._get_jax())
        return self._wrap_jax(m, f)


# Register _SphereDistancePairScore in _IMP_core:
_IMP_core._SphereDistancePairScore_swigregister(_SphereDistancePairScore)
class HarmonicUpperBoundSphereDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::HarmonicUpperBoundSphereDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(HarmonicUpperBoundSphereDistancePairScore self, double x0, double k, std::string name="HarmonicUpperBoundSphereDistancePairScore%1%") -> HarmonicUpperBoundSphereDistancePairScore
        __init__(HarmonicUpperBoundSphereDistancePairScore self) -> HarmonicUpperBoundSphereDistancePairScore
        """
        _IMP_core.HarmonicUpperBoundSphereDistancePairScore_swiginit(self, _IMP_core.new_HarmonicUpperBoundSphereDistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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_score_functor(self, *args):
        r"""
        get_score_functor(HarmonicUpperBoundSphereDistancePairScore self) -> IMP::core::HarmonicUpperBoundSphereDistanceScore
        get_score_functor(HarmonicUpperBoundSphereDistancePairScore self) -> IMP::core::HarmonicUpperBoundSphereDistanceScore const &
        """
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_score_functor(self, *args)

    def get_x0(self):
        r"""get_x0(HarmonicUpperBoundSphereDistancePairScore self) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_x0(self)

    def get_k(self):
        r"""get_k(HarmonicUpperBoundSphereDistancePairScore self) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_k(self)

    def get_version_info(self):
        r"""get_version_info(HarmonicUpperBoundSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicUpperBoundSphereDistancePairScore

    def __str__(self):
        r"""__str__(HarmonicUpperBoundSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(HarmonicUpperBoundSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(HarmonicUpperBoundSphereDistancePairScore self) -> PyObject *"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(HarmonicUpperBoundSphereDistancePairScore self, PyObject * p)"""
        return _IMP_core.HarmonicUpperBoundSphereDistancePairScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        import jax.lax
        def jax_score(jm, d, k):
            xyzs = jm['xyz'][indexes]
            rs = jm['r'][indexes]
            diff = xyzs[:,0] - xyzs[:,1]
            drs = jnp.linalg.norm(diff, axis=1) - rs.sum(axis=1)
            return 0.5 * k * jax.lax.min(d - drs, 0.0) ** 2
        f = functools.partial(jax_score, d=self.get_x0(), k=self.get_k())
        return self._wrap_jax(m, f)


# Register HarmonicUpperBoundSphereDistancePairScore in _IMP_core:
_IMP_core.HarmonicUpperBoundSphereDistancePairScore_swigregister(HarmonicUpperBoundSphereDistancePairScore)
class HarmonicUpperBoundSphereDiameterPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::HarmonicUpperBoundSphereDiameterPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, d0, k):
        r"""__init__(HarmonicUpperBoundSphereDiameterPairScore self, double d0, double k) -> HarmonicUpperBoundSphereDiameterPairScore"""
        _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_swiginit(self, _IMP_core.new_HarmonicUpperBoundSphereDiameterPairScore(d0, k))

    def get_rest_length(self):
        r"""get_rest_length(HarmonicUpperBoundSphereDiameterPairScore self) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_get_rest_length(self)

    def get_stiffness(self):
        r"""get_stiffness(HarmonicUpperBoundSphereDiameterPairScore self) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_get_stiffness(self)

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(HarmonicUpperBoundSphereDiameterPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(HarmonicUpperBoundSphereDiameterPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(HarmonicUpperBoundSphereDiameterPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(HarmonicUpperBoundSphereDiameterPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(HarmonicUpperBoundSphereDiameterPairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicUpperBoundSphereDiameterPairScore

    def __str__(self):
        r"""__str__(HarmonicUpperBoundSphereDiameterPairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(HarmonicUpperBoundSphereDiameterPairScore self) -> std::string"""
        return _IMP_core.HarmonicUpperBoundSphereDiameterPairScore___repr__(self)

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


# Register HarmonicUpperBoundSphereDiameterPairScore in _IMP_core:
_IMP_core.HarmonicUpperBoundSphereDiameterPairScore_swigregister(HarmonicUpperBoundSphereDiameterPairScore)
class HarmonicSphereDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::HarmonicSphereDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(HarmonicSphereDistancePairScore self, double x0, double k, std::string name="HarmonicSphereDistancePairScore%1%") -> HarmonicSphereDistancePairScore
        __init__(HarmonicSphereDistancePairScore self) -> HarmonicSphereDistancePairScore
        """
        _IMP_core.HarmonicSphereDistancePairScore_swiginit(self, _IMP_core.new_HarmonicSphereDistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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_score_functor(self, *args):
        r"""
        get_score_functor(HarmonicSphereDistancePairScore self) -> IMP::core::HarmonicSphereDistanceScore
        get_score_functor(HarmonicSphereDistancePairScore self) -> IMP::core::HarmonicSphereDistanceScore const &
        """
        return _IMP_core.HarmonicSphereDistancePairScore_get_score_functor(self, *args)

    def get_x0(self):
        r"""get_x0(HarmonicSphereDistancePairScore self) -> double"""
        return _IMP_core.HarmonicSphereDistancePairScore_get_x0(self)

    def get_k(self):
        r"""get_k(HarmonicSphereDistancePairScore self) -> double"""
        return _IMP_core.HarmonicSphereDistancePairScore_get_k(self)

    def get_version_info(self):
        r"""get_version_info(HarmonicSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSphereDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicSphereDistancePairScore

    def __str__(self):
        r"""__str__(HarmonicSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicSphereDistancePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(HarmonicSphereDistancePairScore self) -> std::string"""
        return _IMP_core.HarmonicSphereDistancePairScore___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(HarmonicSphereDistancePairScore self) -> PyObject *"""
        return _IMP_core.HarmonicSphereDistancePairScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(HarmonicSphereDistancePairScore self, PyObject * p)"""
        return _IMP_core.HarmonicSphereDistancePairScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        def jax_score(jm, d, k):
            xyzs = jm['xyz'][indexes]
            rs = jm['r'][indexes]
            diff = xyzs[:,0] - xyzs[:,1]
            drs = jnp.linalg.norm(diff, axis=1) - rs.sum(axis=1)
            return 0.5 * k * (d - drs)**2
        f = functools.partial(jax_score, d=self.get_x0(), k=self.get_k())
        return self._wrap_jax(m, f)


# Register HarmonicSphereDistancePairScore in _IMP_core:
_IMP_core.HarmonicSphereDistancePairScore_swigregister(HarmonicSphereDistancePairScore)
class NormalizedSphereDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::NormalizedSphereDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(NormalizedSphereDistancePairScore self, UnaryFunction f, FloatKey radius=IMP::FloatKey("radius")) -> NormalizedSphereDistancePairScore"""
        _IMP_core.NormalizedSphereDistancePairScore_swiginit(self, _IMP_core.new_NormalizedSphereDistancePairScore(*args))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(NormalizedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.NormalizedSphereDistancePairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(NormalizedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.NormalizedSphereDistancePairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(NormalizedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.NormalizedSphereDistancePairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(NormalizedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.NormalizedSphereDistancePairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(NormalizedSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.NormalizedSphereDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_NormalizedSphereDistancePairScore

    def __str__(self):
        r"""__str__(NormalizedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.NormalizedSphereDistancePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(NormalizedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.NormalizedSphereDistancePairScore___repr__(self)

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


# Register NormalizedSphereDistancePairScore in _IMP_core:
_IMP_core.NormalizedSphereDistancePairScore_swigregister(NormalizedSphereDistancePairScore)
class WeightedSphereDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::WeightedSphereDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(WeightedSphereDistancePairScore self, UnaryFunction f, FloatKey weight, FloatKey radius=IMP::FloatKey("radius")) -> WeightedSphereDistancePairScore"""
        _IMP_core.WeightedSphereDistancePairScore_swiginit(self, _IMP_core.new_WeightedSphereDistancePairScore(*args))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(WeightedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.WeightedSphereDistancePairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(WeightedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.WeightedSphereDistancePairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(WeightedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.WeightedSphereDistancePairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(WeightedSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.WeightedSphereDistancePairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(WeightedSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_core.WeightedSphereDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_WeightedSphereDistancePairScore

    def __str__(self):
        r"""__str__(WeightedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.WeightedSphereDistancePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(WeightedSphereDistancePairScore self) -> std::string"""
        return _IMP_core.WeightedSphereDistancePairScore___repr__(self)

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


# Register WeightedSphereDistancePairScore in _IMP_core:
_IMP_core.WeightedSphereDistancePairScore_swigregister(WeightedSphereDistancePairScore)
class SoftSpherePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::SoftSpherePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SoftSpherePairScore self, double k, std::string name="SoftSpherePairScore%1%") -> SoftSpherePairScore
        __init__(SoftSpherePairScore self) -> SoftSpherePairScore
        """
        _IMP_core.SoftSpherePairScore_swiginit(self, _IMP_core.new_SoftSpherePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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_score_functor(self, *args):
        r"""
        get_score_functor(SoftSpherePairScore self) -> IMP::core::SoftSphereDistanceScore
        get_score_functor(SoftSpherePairScore self) -> IMP::core::SoftSphereDistanceScore const &
        """
        return _IMP_core.SoftSpherePairScore_get_score_functor(self, *args)

    def get_k(self):
        r"""get_k(SoftSpherePairScore self) -> double"""
        return _IMP_core.SoftSpherePairScore_get_k(self)

    def get_version_info(self):
        r"""get_version_info(SoftSpherePairScore self) -> VersionInfo"""
        return _IMP_core.SoftSpherePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SoftSpherePairScore

    def __str__(self):
        r"""__str__(SoftSpherePairScore self) -> std::string"""
        return _IMP_core.SoftSpherePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(SoftSpherePairScore self) -> std::string"""
        return _IMP_core.SoftSpherePairScore___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(SoftSpherePairScore self) -> PyObject *"""
        return _IMP_core.SoftSpherePairScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SoftSpherePairScore self, PyObject * p)"""
        return _IMP_core.SoftSpherePairScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        import jax.lax
        def jax_score(jm, k):
            xyzs = jm['xyz'][indexes]
            rs = jm['r'][indexes]
            diff = xyzs[:,0] - xyzs[:,1]
            drs = jnp.linalg.norm(diff, axis=1) - rs.sum(axis=1)
            return 0.5 * k * jax.lax.min(drs, 0.0) ** 2
        f = functools.partial(jax_score, k=self.get_k())
        return self._wrap_jax(m, f)


# Register SoftSpherePairScore in _IMP_core:
_IMP_core.SoftSpherePairScore_swigregister(SoftSpherePairScore)
class SurfaceDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::SurfaceDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(SurfaceDistancePairScore self, UnaryFunction uf, std::string name="SurfaceDistancePairScore%1%") -> SurfaceDistancePairScore"""
        _IMP_core.SurfaceDistancePairScore_swiginit(self, _IMP_core.new_SurfaceDistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(SurfaceDistancePairScore self) -> VersionInfo"""
        return _IMP_core.SurfaceDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceDistancePairScore

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

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

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


# Register SurfaceDistancePairScore in _IMP_core:
_IMP_core.SurfaceDistancePairScore_swigregister(SurfaceDistancePairScore)
class SurfaceHeightPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::SurfaceHeightPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(SurfaceHeightPairScore self, UnaryFunction uf, std::string name="SurfaceHeightPairScore%1%") -> SurfaceHeightPairScore"""
        _IMP_core.SurfaceHeightPairScore_swiginit(self, _IMP_core.new_SurfaceHeightPairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(SurfaceHeightPairScore self) -> VersionInfo"""
        return _IMP_core.SurfaceHeightPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceHeightPairScore

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

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

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


# Register SurfaceHeightPairScore in _IMP_core:
_IMP_core.SurfaceHeightPairScore_swigregister(SurfaceHeightPairScore)
class SurfaceDepthPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::SurfaceDepthPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(SurfaceDepthPairScore self, UnaryFunction uf, std::string name="SurfaceDepthPairScore%1%") -> SurfaceDepthPairScore"""
        _IMP_core.SurfaceDepthPairScore_swiginit(self, _IMP_core.new_SurfaceDepthPairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(SurfaceDepthPairScore self) -> VersionInfo"""
        return _IMP_core.SurfaceDepthPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceDepthPairScore

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

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

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


# Register SurfaceDepthPairScore in _IMP_core:
_IMP_core.SurfaceDepthPairScore_swigregister(SurfaceDepthPairScore)
class HarmonicSurfaceDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::HarmonicSurfaceDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(HarmonicSurfaceDistancePairScore self, double x0, double k, std::string name="HarmonicSurfaceDistancePairScore%1%") -> HarmonicSurfaceDistancePairScore"""
        _IMP_core.HarmonicSurfaceDistancePairScore_swiginit(self, _IMP_core.new_HarmonicSurfaceDistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(HarmonicSurfaceDistancePairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSurfaceDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicSurfaceDistancePairScore

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

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

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


# Register HarmonicSurfaceDistancePairScore in _IMP_core:
_IMP_core.HarmonicSurfaceDistancePairScore_swigregister(HarmonicSurfaceDistancePairScore)
class HarmonicSurfaceHeightPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::HarmonicSurfaceHeightPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(HarmonicSurfaceHeightPairScore self, double x0, double k, std::string name="HarmonicSurfaceHeightPairScore%1%") -> HarmonicSurfaceHeightPairScore"""
        _IMP_core.HarmonicSurfaceHeightPairScore_swiginit(self, _IMP_core.new_HarmonicSurfaceHeightPairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(HarmonicSurfaceHeightPairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSurfaceHeightPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicSurfaceHeightPairScore

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

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

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


# Register HarmonicSurfaceHeightPairScore in _IMP_core:
_IMP_core.HarmonicSurfaceHeightPairScore_swigregister(HarmonicSurfaceHeightPairScore)
class HarmonicSurfaceDepthPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::HarmonicSurfaceDepthPairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(HarmonicSurfaceDepthPairScore self, double x0, double k, std::string name="HarmonicSurfaceDepthPairScore%1%") -> HarmonicSurfaceDepthPairScore"""
        _IMP_core.HarmonicSurfaceDepthPairScore_swiginit(self, _IMP_core.new_HarmonicSurfaceDepthPairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(HarmonicSurfaceDepthPairScore self) -> VersionInfo"""
        return _IMP_core.HarmonicSurfaceDepthPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_HarmonicSurfaceDepthPairScore

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

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

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


# Register HarmonicSurfaceDepthPairScore in _IMP_core:
_IMP_core.HarmonicSurfaceDepthPairScore_swigregister(HarmonicSurfaceDepthPairScore)
class SoftSuperSurfacePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::SoftSuperSurfacePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(SoftSuperSurfacePairScore self, double k, std::string name="SoftSuperSurfacePairScore%1%") -> SoftSuperSurfacePairScore"""
        _IMP_core.SoftSuperSurfacePairScore_swiginit(self, _IMP_core.new_SoftSuperSurfacePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(SoftSuperSurfacePairScore self) -> VersionInfo"""
        return _IMP_core.SoftSuperSurfacePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SoftSuperSurfacePairScore

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

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

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


# Register SoftSuperSurfacePairScore in _IMP_core:
_IMP_core.SoftSuperSurfacePairScore_swigregister(SoftSuperSurfacePairScore)
class SoftSubSurfacePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::SoftSubSurfacePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(SoftSubSurfacePairScore self, double k, std::string name="SoftSubSurfacePairScore%1%") -> SoftSubSurfacePairScore"""
        _IMP_core.SoftSubSurfacePairScore_swiginit(self, _IMP_core.new_SoftSubSurfacePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_version_info(SoftSubSurfacePairScore self) -> VersionInfo"""
        return _IMP_core.SoftSubSurfacePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SoftSubSurfacePairScore

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

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

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


# Register SoftSubSurfacePairScore in _IMP_core:
_IMP_core.SoftSubSurfacePairScore_swigregister(SoftSubSurfacePairScore)
class SurfaceTetheredChain(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::SurfaceTetheredChain class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, link_num, link_length):
        r"""__init__(SurfaceTetheredChain self, int link_num, double link_length) -> SurfaceTetheredChain"""
        _IMP_core.SurfaceTetheredChain_swiginit(self, _IMP_core.new_SurfaceTetheredChain(link_num, link_length))

    def get_version_info(self):
        r"""get_version_info(SurfaceTetheredChain self) -> VersionInfo"""
        return _IMP_core.SurfaceTetheredChain_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceTetheredChain

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

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

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

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

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

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

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

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

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


# Register SurfaceTetheredChain in _IMP_core:
_IMP_core.SurfaceTetheredChain_swigregister(SurfaceTetheredChain)
class SurfaceSymmetryConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::SurfaceSymmetryConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, m, ss, rbs):
        r"""__init__(SurfaceSymmetryConstraint self, Model m, IMP::ParticleIndexPair const & ss, IMP::ParticleIndexPair const & rbs) -> SurfaceSymmetryConstraint"""
        _IMP_core.SurfaceSymmetryConstraint_swiginit(self, _IMP_core.new_SurfaceSymmetryConstraint(m, ss, rbs))

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

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

    def get_version_info(self):
        r"""get_version_info(SurfaceSymmetryConstraint self) -> VersionInfo"""
        return _IMP_core.SurfaceSymmetryConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SurfaceSymmetryConstraint

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

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

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


# Register SurfaceSymmetryConstraint in _IMP_core:
_IMP_core.SurfaceSymmetryConstraint_swigregister(SurfaceSymmetryConstraint)
class SteepestDescent(IMP.AttributeOptimizer):
    r"""Proxy of C++ IMP::core::SteepestDescent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(SteepestDescent self, Model m, std::string name="SteepestDescent%1%") -> SteepestDescent"""
        _IMP_core.SteepestDescent_swiginit(self, _IMP_core.new_SteepestDescent(*args))

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

    def get_version_info(self):
        r"""get_version_info(SteepestDescent self) -> VersionInfo"""
        return _IMP_core.SteepestDescent_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SteepestDescent

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

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

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

    def __str__(self):
        r"""__str__(SteepestDescent self) -> std::string"""
        return _IMP_core.SteepestDescent___str__(self)

    def __repr__(self):
        r"""__repr__(SteepestDescent self) -> std::string"""
        return _IMP_core.SteepestDescent___repr__(self)

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


# Register SteepestDescent in _IMP_core:
_IMP_core.SteepestDescent_swigregister(SteepestDescent)
class TransformedDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::TransformedDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, f, transformation):
        r"""__init__(TransformedDistancePairScore self, UnaryFunction f, Transformation3D transformation) -> TransformedDistancePairScore"""
        _IMP_core.TransformedDistancePairScore_swiginit(self, _IMP_core.new_TransformedDistancePairScore(f, transformation))

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

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(TransformedDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TransformedDistancePairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(TransformedDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TransformedDistancePairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(TransformedDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TransformedDistancePairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(TransformedDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TransformedDistancePairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(TransformedDistancePairScore self) -> VersionInfo"""
        return _IMP_core.TransformedDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TransformedDistancePairScore

    def __str__(self):
        r"""__str__(TransformedDistancePairScore self) -> std::string"""
        return _IMP_core.TransformedDistancePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(TransformedDistancePairScore self) -> std::string"""
        return _IMP_core.TransformedDistancePairScore___repr__(self)

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


# Register TransformedDistancePairScore in _IMP_core:
_IMP_core.TransformedDistancePairScore_swigregister(TransformedDistancePairScore)
class TypedPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::TypedPairScore class."""

    thisown = 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):
        r"""__init__(TypedPairScore self, IntKey typekey, bool allow_invalid_types=True) -> TypedPairScore"""
        _IMP_core.TypedPairScore_swiginit(self, _IMP_core.new_TypedPairScore(typekey, allow_invalid_types))

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

    def set_pair_score(self, ps, atype, btype):
        r"""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):
        r"""do_get_inputs(TypedPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.TypedPairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(TypedPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TypedPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(TypedPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TypedPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(TypedPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TypedPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(TypedPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.TypedPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(TypedPairScore self) -> VersionInfo"""
        return _IMP_core.TypedPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TypedPairScore

    def __str__(self):
        r"""__str__(TypedPairScore self) -> std::string"""
        return _IMP_core.TypedPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(TypedPairScore self) -> std::string"""
        return _IMP_core.TypedPairScore___repr__(self)

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


# Register TypedPairScore in _IMP_core:
_IMP_core.TypedPairScore_swigregister(TypedPairScore)
class RigidBodyDistancePairScore(KClosePairsPairScore):
    r"""Proxy of C++ IMP::core::RigidBodyDistancePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, ps, r):
        r"""__init__(RigidBodyDistancePairScore self, PairScore ps, Refiner r) -> RigidBodyDistancePairScore"""
        _IMP_core.RigidBodyDistancePairScore_swiginit(self, _IMP_core.new_RigidBodyDistancePairScore(ps, r))

    def __str__(self):
        r"""__str__(RigidBodyDistancePairScore self) -> std::string"""
        return _IMP_core.RigidBodyDistancePairScore___str__(self)

    def __repr__(self):
        r"""__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

# Register RigidBodyDistancePairScore in _IMP_core:
_IMP_core.RigidBodyDistancePairScore_swigregister(RigidBodyDistancePairScore)
class RigidBodyAnglePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::core::RigidBodyAnglePairScore class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, f):
        r"""__init__(RigidBodyAnglePairScore self, UnaryFunction f) -> RigidBodyAnglePairScore"""
        _IMP_core.RigidBodyAnglePairScore_swiginit(self, _IMP_core.new_RigidBodyAnglePairScore(f))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(RigidBodyAnglePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RigidBodyAnglePairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(RigidBodyAnglePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RigidBodyAnglePairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(RigidBodyAnglePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RigidBodyAnglePairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(RigidBodyAnglePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.RigidBodyAnglePairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(RigidBodyAnglePairScore self) -> VersionInfo"""
        return _IMP_core.RigidBodyAnglePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyAnglePairScore

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

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

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


# Register RigidBodyAnglePairScore in _IMP_core:
_IMP_core.RigidBodyAnglePairScore_swigregister(RigidBodyAnglePairScore)
class TableRefiner(IMP.Refiner):
    r"""Proxy of C++ IMP::core::TableRefiner class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self):
        r"""__init__(TableRefiner self) -> TableRefiner"""
        _IMP_core.TableRefiner_swiginit(self, _IMP_core.new_TableRefiner())

    def add_particle(self, p, ps):
        r"""add_particle(TableRefiner self, Particle p, IMP::ParticlesTemp const & ps)"""
        return _IMP_core.TableRefiner_add_particle(self, p, ps)

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

    def set_particle(self, p, ps):
        r"""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):
        r"""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):
        r"""get_version_info(TableRefiner self) -> VersionInfo"""
        return _IMP_core.TableRefiner_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TableRefiner

    def __str__(self):
        r"""__str__(TableRefiner self) -> std::string"""
        return _IMP_core.TableRefiner___str__(self)

    def __repr__(self):
        r"""__repr__(TableRefiner self) -> std::string"""
        return _IMP_core.TableRefiner___repr__(self)

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


# Register TableRefiner in _IMP_core:
_IMP_core.TableRefiner_swigregister(TableRefiner)
LOWER = _IMP_core.LOWER

BOTH = _IMP_core.BOTH

UPPER = _IMP_core.UPPER

class MCCGSampler(IMP.Sampler):
    r"""Proxy of C++ IMP::core::MCCGSampler class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(MCCGSampler self, Model m, std::string name="MCCG Sampler %1%") -> MCCGSampler"""
        _IMP_core.MCCGSampler_swiginit(self, _IMP_core.new_MCCGSampler(*args))

    def set_bounding_box(self, bb):
        r"""set_bounding_box(MCCGSampler self, BoundingBox3D bb)"""
        return _IMP_core.MCCGSampler_set_bounding_box(self, bb)

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

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

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

    def get_rejected_configurations(self):
        r"""get_rejected_configurations(MCCGSampler self) -> ConfigurationSet"""
        return _IMP_core.MCCGSampler_get_rejected_configurations(self)
    def __get_optimizer_states(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_optimizer_states,  getfunc=self.get_optimizer_state, erasefunc=self.erase_optimizer_state,  appendfunc=self.add_optimizer_state, extendfunc=self.add_optimizer_states,  clearfunc=self.clear_optimizer_states, indexfunc=self._python_index_optimizer_state)  
    def __set_optimizer_states(self, obj): IMP._list_util.set_varlist(self.optimizer_states, obj)  
    def __del_optimizer_states(self): IMP._list_util.del_varlist(self.optimizer_states)       
    optimizer_states = property(__get_optimizer_states, __set_optimizer_states, __del_optimizer_states, doc="List of ##ucnames")  

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

    def _python_index_optimizer_state(self, d, start, stop):
        r"""_python_index_optimizer_state(MCCGSampler self, OptimizerState d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_core.MCCGSampler__python_index_optimizer_state(self, d, start, stop)

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

    def set_optimizer_states(self, ps):
        r"""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):
        r"""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):
        r"""add_optimizer_state(MCCGSampler self, OptimizerState obj) -> unsigned int"""
        return _IMP_core.MCCGSampler_add_optimizer_state(self, obj)

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

    def clear_optimizer_states(self):
        r"""clear_optimizer_states(MCCGSampler self)"""
        return _IMP_core.MCCGSampler_clear_optimizer_states(self)

    def get_number_of_optimizer_states(self):
        r"""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):
        r"""get_has_optimizer_states(MCCGSampler self) -> bool"""
        return _IMP_core.MCCGSampler_get_has_optimizer_states(self)

    def get_optimizer_state(self, i):
        r"""get_optimizer_state(MCCGSampler self, unsigned int i) -> OptimizerState"""
        return _IMP_core.MCCGSampler_get_optimizer_state(self, i)

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

    def erase_optimizer_state(self, i):
        r"""erase_optimizer_state(MCCGSampler self, unsigned int i)"""
        return _IMP_core.MCCGSampler_erase_optimizer_state(self, i)

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

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

    def get_version_info(self):
        r"""get_version_info(MCCGSampler self) -> VersionInfo"""
        return _IMP_core.MCCGSampler_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_MCCGSampler

    def __str__(self):
        r"""__str__(MCCGSampler self) -> std::string"""
        return _IMP_core.MCCGSampler___str__(self)

    def __repr__(self):
        r"""__repr__(MCCGSampler self) -> std::string"""
        return _IMP_core.MCCGSampler___repr__(self)

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


# Register MCCGSampler in _IMP_core:
_IMP_core.MCCGSampler_swigregister(MCCGSampler)
class MinimumRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::MinimumRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(MinimumRestraint self, unsigned int num, IMP::Restraints const & rs=IMP::Restraints(), std::string name="MinimumRestraint %1%") -> MinimumRestraint"""
        _IMP_core.MinimumRestraint_swiginit(self, _IMP_core.new_MinimumRestraint(*args))

    def do_get_inputs(self):
        r"""do_get_inputs(MinimumRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.MinimumRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(MinimumRestraint self) -> VersionInfo"""
        return _IMP_core.MinimumRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_MinimumRestraint
    def __get_restraints(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_restraints,  getfunc=self.get_restraint, erasefunc=self.erase_restraint,  appendfunc=self.add_restraint, extendfunc=self.add_restraints,  clearfunc=self.clear_restraints, indexfunc=self._python_index_restraint)  
    def __set_restraints(self, obj): IMP._list_util.set_varlist(self.restraints, obj)  
    def __del_restraints(self): IMP._list_util.del_varlist(self.restraints)       
    restraints = property(__get_restraints, __set_restraints, __del_restraints, doc="List of ##ucnames")  

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

    def _python_index_restraint(self, d, start, stop):
        r"""_python_index_restraint(MinimumRestraint self, Restraint d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_core.MinimumRestraint__python_index_restraint(self, d, start, stop)

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

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

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

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

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

    def clear_restraints(self):
        r"""clear_restraints(MinimumRestraint self)"""
        return _IMP_core.MinimumRestraint_clear_restraints(self)

    def get_number_of_restraints(self):
        r"""get_number_of_restraints(MinimumRestraint self) -> unsigned int"""
        return _IMP_core.MinimumRestraint_get_number_of_restraints(self)

    def get_has_restraints(self):
        r"""get_has_restraints(MinimumRestraint self) -> bool"""
        return _IMP_core.MinimumRestraint_get_has_restraints(self)

    def get_restraint(self, i):
        r"""get_restraint(MinimumRestraint self, unsigned int i) -> Restraint"""
        return _IMP_core.MinimumRestraint_get_restraint(self, i)

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

    def erase_restraint(self, i):
        r"""erase_restraint(MinimumRestraint self, unsigned int i)"""
        return _IMP_core.MinimumRestraint_erase_restraint(self, i)

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

    def __str__(self):
        r"""__str__(MinimumRestraint self) -> std::string"""
        return _IMP_core.MinimumRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(MinimumRestraint self) -> std::string"""
        return _IMP_core.MinimumRestraint___repr__(self)

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


# Register MinimumRestraint in _IMP_core:
_IMP_core.MinimumRestraint_swigregister(MinimumRestraint)
class Gaussian(RigidBody):
    r"""Proxy of C++ IMP::core::Gaussian class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Gaussian self) -> Gaussian
        __init__(Gaussian self, Model m, ParticleIndex id) -> Gaussian
        __init__(Gaussian self, _ParticleAdaptor d) -> Gaussian
        """
        _IMP_core.Gaussian_swiginit(self, _IMP_core.new_Gaussian(*args))

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

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

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

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

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

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

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

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

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

    def set_gaussian(self, g):
        r"""set_gaussian(Gaussian self, Gaussian3D g)"""
        return _IMP_core.Gaussian_set_gaussian(self, g)

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

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Gaussian self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Gaussian self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Gaussian self, SparseStringKey a0, IMP::String a1)
        add_attribute(Gaussian self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Gaussian_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Gaussian self, SparseFloatKey a0) -> IMP::Float
        get_value(Gaussian self, SparseIntKey a0) -> IMP::Int
        get_value(Gaussian self, SparseStringKey a0) -> IMP::String
        get_value(Gaussian self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Gaussian_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Gaussian self, SparseFloatKey a0, IMP::Float a1)
        set_value(Gaussian self, SparseIntKey a0, IMP::Int a1)
        set_value(Gaussian self, SparseStringKey a0, IMP::String a1)
        set_value(Gaussian self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Gaussian_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Gaussian self, SparseFloatKey a0)
        remove_attribute(Gaussian self, SparseIntKey a0)
        remove_attribute(Gaussian self, SparseStringKey a0)
        remove_attribute(Gaussian self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Gaussian_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Gaussian self, SparseFloatKey a0) -> bool
        has_attribute(Gaussian self, SparseIntKey a0) -> bool
        has_attribute(Gaussian self, SparseStringKey a0) -> bool
        has_attribute(Gaussian self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Gaussian_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Gaussian self, FloatKey a0) -> bool"""
        return _IMP_core.Gaussian_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Gaussian self) -> PyObject *"""
        return _IMP_core.Gaussian__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Gaussian self, PyObject * p)"""
        return _IMP_core.Gaussian__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Gaussian

# Register Gaussian in _IMP_core:
_IMP_core.Gaussian_swigregister(Gaussian)
class PairRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::PairRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(PairRestraint self, Model m, PairScore ss, IMP::ParticleIndexPair const & vt, std::string name="PairRestraint %1%") -> PairRestraint
        __init__(PairRestraint self) -> PairRestraint
        """
        _IMP_core.PairRestraint_swiginit(self, _IMP_core.new_PairRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(PairRestraint self) -> PairScore"""
        return _IMP_core.PairRestraint_get_score_object(self)

    def get_index(self):
        r"""get_index(PairRestraint self) -> IMP::PairScore::IndexArgument"""
        return _IMP_core.PairRestraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(PairRestraint self) -> VersionInfo"""
        return _IMP_core.PairRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_PairRestraint

    def __str__(self):
        r"""__str__(PairRestraint self) -> std::string"""
        return _IMP_core.PairRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(PairRestraint self) -> std::string"""
        return _IMP_core.PairRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(PairRestraint self) -> PyObject *"""
        return _IMP_core.PairRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PairRestraint self, PyObject * p)"""
        return _IMP_core.PairRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        from . import _jax_util
        return _jax_util._get_jax_restraint(self)


# Register PairRestraint in _IMP_core:
_IMP_core.PairRestraint_swigregister(PairRestraint)
class SingletonRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::SingletonRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SingletonRestraint self, Model m, SingletonScore ss, ParticleIndex vt, std::string name="SingletonRestraint %1%") -> SingletonRestraint
        __init__(SingletonRestraint self) -> SingletonRestraint
        """
        _IMP_core.SingletonRestraint_swiginit(self, _IMP_core.new_SingletonRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(SingletonRestraint self) -> SingletonScore"""
        return _IMP_core.SingletonRestraint_get_score_object(self)

    def get_index(self):
        r"""get_index(SingletonRestraint self) -> ParticleIndex"""
        return _IMP_core.SingletonRestraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(SingletonRestraint self) -> VersionInfo"""
        return _IMP_core.SingletonRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SingletonRestraint

    def __str__(self):
        r"""__str__(SingletonRestraint self) -> std::string"""
        return _IMP_core.SingletonRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(SingletonRestraint self) -> std::string"""
        return _IMP_core.SingletonRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(SingletonRestraint self) -> PyObject *"""
        return _IMP_core.SingletonRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SingletonRestraint self, PyObject * p)"""
        return _IMP_core.SingletonRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        from . import _jax_util
        return _jax_util._get_jax_restraint(self)


# Register SingletonRestraint in _IMP_core:
_IMP_core.SingletonRestraint_swigregister(SingletonRestraint)
class TripletRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::TripletRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(TripletRestraint self, Model m, TripletScore ss, IMP::ParticleIndexTriplet const & vt, std::string name="TripletRestraint %1%") -> TripletRestraint
        __init__(TripletRestraint self) -> TripletRestraint
        """
        _IMP_core.TripletRestraint_swiginit(self, _IMP_core.new_TripletRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(TripletRestraint self) -> TripletScore"""
        return _IMP_core.TripletRestraint_get_score_object(self)

    def get_index(self):
        r"""get_index(TripletRestraint self) -> IMP::TripletScore::IndexArgument"""
        return _IMP_core.TripletRestraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(TripletRestraint self) -> VersionInfo"""
        return _IMP_core.TripletRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TripletRestraint

    def __str__(self):
        r"""__str__(TripletRestraint self) -> std::string"""
        return _IMP_core.TripletRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(TripletRestraint self) -> std::string"""
        return _IMP_core.TripletRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(TripletRestraint self) -> PyObject *"""
        return _IMP_core.TripletRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(TripletRestraint self, PyObject * p)"""
        return _IMP_core.TripletRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register TripletRestraint in _IMP_core:
_IMP_core.TripletRestraint_swigregister(TripletRestraint)
class QuadRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::QuadRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(QuadRestraint self, Model m, QuadScore ss, IMP::ParticleIndexQuad const & vt, std::string name="QuadRestraint %1%") -> QuadRestraint
        __init__(QuadRestraint self) -> QuadRestraint
        """
        _IMP_core.QuadRestraint_swiginit(self, _IMP_core.new_QuadRestraint(*args))

    def get_score_object(self):
        r"""get_score_object(QuadRestraint self) -> QuadScore"""
        return _IMP_core.QuadRestraint_get_score_object(self)

    def get_index(self):
        r"""get_index(QuadRestraint self) -> IMP::QuadScore::IndexArgument"""
        return _IMP_core.QuadRestraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(QuadRestraint self) -> VersionInfo"""
        return _IMP_core.QuadRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_QuadRestraint

    def __str__(self):
        r"""__str__(QuadRestraint self) -> std::string"""
        return _IMP_core.QuadRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(QuadRestraint self) -> std::string"""
        return _IMP_core.QuadRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(QuadRestraint self) -> PyObject *"""
        return _IMP_core.QuadRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(QuadRestraint self, PyObject * p)"""
        return _IMP_core.QuadRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register QuadRestraint in _IMP_core:
_IMP_core.QuadRestraint_swigregister(QuadRestraint)
class SingletonConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::SingletonConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SingletonConstraint self, SingletonModifier before, SingletonModifier after, Model m, ParticleIndex vt, std::string name="SingletonConstraint %1%", bool can_skip=False) -> SingletonConstraint
        __init__(SingletonConstraint self) -> SingletonConstraint
        """
        _IMP_core.SingletonConstraint_swiginit(self, _IMP_core.new_SingletonConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(SingletonConstraint self) -> SingletonModifier"""
        return _IMP_core.SingletonConstraint_get_before_modifier(self)

    def get_index(self):
        r"""get_index(SingletonConstraint self) -> ParticleIndex"""
        return _IMP_core.SingletonConstraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(SingletonConstraint self) -> VersionInfo"""
        return _IMP_core.SingletonConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_SingletonConstraint

    def __str__(self):
        r"""__str__(SingletonConstraint self) -> std::string"""
        return _IMP_core.SingletonConstraint___str__(self)

    def __repr__(self):
        r"""__repr__(SingletonConstraint self) -> std::string"""
        return _IMP_core.SingletonConstraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(SingletonConstraint self) -> PyObject *"""
        return _IMP_core.SingletonConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SingletonConstraint self, PyObject * p)"""
        return _IMP_core.SingletonConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self):
        import jax.numpy as jnp
        indexes = jnp.array([self.get_index()])
        mod = self.get_before_modifier().get_derived_object()
        ji = mod._get_jax(self.get_model(), indexes)
        return self._wrap_jax(ji.apply_func, keys=ji._keys)


# Register SingletonConstraint in _IMP_core:
_IMP_core.SingletonConstraint_swigregister(SingletonConstraint)
class PairConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::PairConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(PairConstraint self, PairModifier before, PairModifier after, Model m, IMP::ParticleIndexPair const & vt, std::string name="PairConstraint %1%", bool can_skip=False) -> PairConstraint
        __init__(PairConstraint self) -> PairConstraint
        """
        _IMP_core.PairConstraint_swiginit(self, _IMP_core.new_PairConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(PairConstraint self) -> PairModifier"""
        return _IMP_core.PairConstraint_get_before_modifier(self)

    def get_index(self):
        r"""get_index(PairConstraint self) -> IMP::PairModifier::IndexArgument"""
        return _IMP_core.PairConstraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(PairConstraint self) -> VersionInfo"""
        return _IMP_core.PairConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_PairConstraint

    def __str__(self):
        r"""__str__(PairConstraint self) -> std::string"""
        return _IMP_core.PairConstraint___str__(self)

    def __repr__(self):
        r"""__repr__(PairConstraint self) -> std::string"""
        return _IMP_core.PairConstraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(PairConstraint self) -> PyObject *"""
        return _IMP_core.PairConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PairConstraint self, PyObject * p)"""
        return _IMP_core.PairConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register PairConstraint in _IMP_core:
_IMP_core.PairConstraint_swigregister(PairConstraint)
class TripletConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::TripletConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(TripletConstraint self, TripletModifier before, TripletModifier after, Model m, IMP::ParticleIndexTriplet const & vt, std::string name="TripletConstraint %1%", bool can_skip=False) -> TripletConstraint
        __init__(TripletConstraint self) -> TripletConstraint
        """
        _IMP_core.TripletConstraint_swiginit(self, _IMP_core.new_TripletConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(TripletConstraint self) -> TripletModifier"""
        return _IMP_core.TripletConstraint_get_before_modifier(self)

    def get_index(self):
        r"""get_index(TripletConstraint self) -> IMP::TripletModifier::IndexArgument"""
        return _IMP_core.TripletConstraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(TripletConstraint self) -> VersionInfo"""
        return _IMP_core.TripletConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TripletConstraint

    def __str__(self):
        r"""__str__(TripletConstraint self) -> std::string"""
        return _IMP_core.TripletConstraint___str__(self)

    def __repr__(self):
        r"""__repr__(TripletConstraint self) -> std::string"""
        return _IMP_core.TripletConstraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(TripletConstraint self) -> PyObject *"""
        return _IMP_core.TripletConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(TripletConstraint self, PyObject * p)"""
        return _IMP_core.TripletConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register TripletConstraint in _IMP_core:
_IMP_core.TripletConstraint_swigregister(TripletConstraint)
class QuadConstraint(IMP.Constraint):
    r"""Proxy of C++ IMP::core::QuadConstraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(QuadConstraint self, QuadModifier before, QuadModifier after, Model m, IMP::ParticleIndexQuad const & vt, std::string name="QuadConstraint %1%", bool can_skip=False) -> QuadConstraint
        __init__(QuadConstraint self) -> QuadConstraint
        """
        _IMP_core.QuadConstraint_swiginit(self, _IMP_core.new_QuadConstraint(*args))

    def get_before_modifier(self):
        r"""get_before_modifier(QuadConstraint self) -> QuadModifier"""
        return _IMP_core.QuadConstraint_get_before_modifier(self)

    def get_index(self):
        r"""get_index(QuadConstraint self) -> IMP::QuadModifier::IndexArgument"""
        return _IMP_core.QuadConstraint_get_index(self)

    def get_version_info(self):
        r"""get_version_info(QuadConstraint self) -> VersionInfo"""
        return _IMP_core.QuadConstraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_QuadConstraint

    def __str__(self):
        r"""__str__(QuadConstraint self) -> std::string"""
        return _IMP_core.QuadConstraint___str__(self)

    def __repr__(self):
        r"""__repr__(QuadConstraint self) -> std::string"""
        return _IMP_core.QuadConstraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(QuadConstraint self) -> PyObject *"""
        return _IMP_core.QuadConstraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(QuadConstraint self, PyObject * p)"""
        return _IMP_core.QuadConstraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register QuadConstraint in _IMP_core:
_IMP_core.QuadConstraint_swigregister(QuadConstraint)
class ConstantSingletonPredicate(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::core::ConstantSingletonPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ConstantSingletonPredicate self, int v, std::string name="ConstSingletonPredicate%1%") -> ConstantSingletonPredicate
        __init__(ConstantSingletonPredicate self) -> ConstantSingletonPredicate
        """
        _IMP_core.ConstantSingletonPredicate_swiginit(self, _IMP_core.new_ConstantSingletonPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(ConstantSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantSingletonPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ConstantSingletonPredicate

    def __str__(self):
        r"""__str__(ConstantSingletonPredicate self) -> std::string"""
        return _IMP_core.ConstantSingletonPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(ConstantSingletonPredicate self) -> std::string"""
        return _IMP_core.ConstantSingletonPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ConstantSingletonPredicate self) -> PyObject *"""
        return _IMP_core.ConstantSingletonPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConstantSingletonPredicate self, PyObject * p)"""
        return _IMP_core.ConstantSingletonPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ConstantSingletonPredicate in _IMP_core:
_IMP_core.ConstantSingletonPredicate_swigregister(ConstantSingletonPredicate)
class UnorderedTypeSingletonPredicate(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::core::UnorderedTypeSingletonPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(UnorderedTypeSingletonPredicate self, std::string name="UnorderedTypeSingletonPredicate%1%") -> UnorderedTypeSingletonPredicate"""
        _IMP_core.UnorderedTypeSingletonPredicate_swiginit(self, _IMP_core.new_UnorderedTypeSingletonPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(UnorderedTypeSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypeSingletonPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_UnorderedTypeSingletonPredicate

    def __str__(self):
        r"""__str__(UnorderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeSingletonPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(UnorderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeSingletonPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(UnorderedTypeSingletonPredicate self) -> PyObject *"""
        return _IMP_core.UnorderedTypeSingletonPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnorderedTypeSingletonPredicate self, PyObject * p)"""
        return _IMP_core.UnorderedTypeSingletonPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register UnorderedTypeSingletonPredicate in _IMP_core:
_IMP_core.UnorderedTypeSingletonPredicate_swigregister(UnorderedTypeSingletonPredicate)
class OrderedTypeSingletonPredicate(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::core::OrderedTypeSingletonPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(OrderedTypeSingletonPredicate self, std::string name="OrderedTypeSingletonPredicate%1%") -> OrderedTypeSingletonPredicate"""
        _IMP_core.OrderedTypeSingletonPredicate_swiginit(self, _IMP_core.new_OrderedTypeSingletonPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(OrderedTypeSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypeSingletonPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_OrderedTypeSingletonPredicate

    def __str__(self):
        r"""__str__(OrderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeSingletonPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(OrderedTypeSingletonPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeSingletonPredicate___repr__(self)

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


# Register OrderedTypeSingletonPredicate in _IMP_core:
_IMP_core.OrderedTypeSingletonPredicate_swigregister(OrderedTypeSingletonPredicate)
class AllSameSingletonPredicate(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::core::AllSameSingletonPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(AllSameSingletonPredicate self, std::string name="AllSameSingletonPredicate%1%") -> AllSameSingletonPredicate"""
        _IMP_core.AllSameSingletonPredicate_swiginit(self, _IMP_core.new_AllSameSingletonPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(AllSameSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.AllSameSingletonPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_AllSameSingletonPredicate

    def __str__(self):
        r"""__str__(AllSameSingletonPredicate self) -> std::string"""
        return _IMP_core.AllSameSingletonPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(AllSameSingletonPredicate self) -> std::string"""
        return _IMP_core.AllSameSingletonPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(AllSameSingletonPredicate self) -> PyObject *"""
        return _IMP_core.AllSameSingletonPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AllSameSingletonPredicate self, PyObject * p)"""
        return _IMP_core.AllSameSingletonPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register AllSameSingletonPredicate in _IMP_core:
_IMP_core.AllSameSingletonPredicate_swigregister(AllSameSingletonPredicate)
class CoinFlipSingletonPredicate(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::core::CoinFlipSingletonPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(CoinFlipSingletonPredicate self, double p, std::string name="CoinFlipSingletonPredicate%1%") -> CoinFlipSingletonPredicate"""
        _IMP_core.CoinFlipSingletonPredicate_swiginit(self, _IMP_core.new_CoinFlipSingletonPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(CoinFlipSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipSingletonPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_CoinFlipSingletonPredicate

    def __str__(self):
        r"""__str__(CoinFlipSingletonPredicate self) -> std::string"""
        return _IMP_core.CoinFlipSingletonPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(CoinFlipSingletonPredicate self) -> std::string"""
        return _IMP_core.CoinFlipSingletonPredicate___repr__(self)

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


# Register CoinFlipSingletonPredicate in _IMP_core:
_IMP_core.CoinFlipSingletonPredicate_swigregister(CoinFlipSingletonPredicate)
class ConstantPairPredicate(IMP.PairPredicate):
    r"""Proxy of C++ IMP::core::ConstantPairPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ConstantPairPredicate self, int v, std::string name="ConstPairPredicate%1%") -> ConstantPairPredicate
        __init__(ConstantPairPredicate self) -> ConstantPairPredicate
        """
        _IMP_core.ConstantPairPredicate_swiginit(self, _IMP_core.new_ConstantPairPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(ConstantPairPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantPairPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ConstantPairPredicate

    def __str__(self):
        r"""__str__(ConstantPairPredicate self) -> std::string"""
        return _IMP_core.ConstantPairPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(ConstantPairPredicate self) -> std::string"""
        return _IMP_core.ConstantPairPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ConstantPairPredicate self) -> PyObject *"""
        return _IMP_core.ConstantPairPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConstantPairPredicate self, PyObject * p)"""
        return _IMP_core.ConstantPairPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ConstantPairPredicate in _IMP_core:
_IMP_core.ConstantPairPredicate_swigregister(ConstantPairPredicate)
class UnorderedTypePairPredicate(IMP.PairPredicate):
    r"""Proxy of C++ IMP::core::UnorderedTypePairPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(UnorderedTypePairPredicate self, std::string name="UnorderedTypePairPredicate%1%") -> UnorderedTypePairPredicate"""
        _IMP_core.UnorderedTypePairPredicate_swiginit(self, _IMP_core.new_UnorderedTypePairPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(UnorderedTypePairPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypePairPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_UnorderedTypePairPredicate

    def __str__(self):
        r"""__str__(UnorderedTypePairPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypePairPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(UnorderedTypePairPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypePairPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(UnorderedTypePairPredicate self) -> PyObject *"""
        return _IMP_core.UnorderedTypePairPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnorderedTypePairPredicate self, PyObject * p)"""
        return _IMP_core.UnorderedTypePairPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register UnorderedTypePairPredicate in _IMP_core:
_IMP_core.UnorderedTypePairPredicate_swigregister(UnorderedTypePairPredicate)
class OrderedTypePairPredicate(IMP.PairPredicate):
    r"""Proxy of C++ IMP::core::OrderedTypePairPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(OrderedTypePairPredicate self, std::string name="OrderedTypePairPredicate%1%") -> OrderedTypePairPredicate"""
        _IMP_core.OrderedTypePairPredicate_swiginit(self, _IMP_core.new_OrderedTypePairPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(OrderedTypePairPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypePairPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_OrderedTypePairPredicate

    def __str__(self):
        r"""__str__(OrderedTypePairPredicate self) -> std::string"""
        return _IMP_core.OrderedTypePairPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(OrderedTypePairPredicate self) -> std::string"""
        return _IMP_core.OrderedTypePairPredicate___repr__(self)

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


# Register OrderedTypePairPredicate in _IMP_core:
_IMP_core.OrderedTypePairPredicate_swigregister(OrderedTypePairPredicate)
class AllSamePairPredicate(IMP.PairPredicate):
    r"""Proxy of C++ IMP::core::AllSamePairPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(AllSamePairPredicate self, std::string name="AllSamePairPredicate%1%") -> AllSamePairPredicate"""
        _IMP_core.AllSamePairPredicate_swiginit(self, _IMP_core.new_AllSamePairPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(AllSamePairPredicate self) -> VersionInfo"""
        return _IMP_core.AllSamePairPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_AllSamePairPredicate

    def __str__(self):
        r"""__str__(AllSamePairPredicate self) -> std::string"""
        return _IMP_core.AllSamePairPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(AllSamePairPredicate self) -> std::string"""
        return _IMP_core.AllSamePairPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(AllSamePairPredicate self) -> PyObject *"""
        return _IMP_core.AllSamePairPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AllSamePairPredicate self, PyObject * p)"""
        return _IMP_core.AllSamePairPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register AllSamePairPredicate in _IMP_core:
_IMP_core.AllSamePairPredicate_swigregister(AllSamePairPredicate)
class CoinFlipPairPredicate(IMP.PairPredicate):
    r"""Proxy of C++ IMP::core::CoinFlipPairPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(CoinFlipPairPredicate self, double p, std::string name="CoinFlipPairPredicate%1%") -> CoinFlipPairPredicate"""
        _IMP_core.CoinFlipPairPredicate_swiginit(self, _IMP_core.new_CoinFlipPairPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(CoinFlipPairPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipPairPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_CoinFlipPairPredicate

    def __str__(self):
        r"""__str__(CoinFlipPairPredicate self) -> std::string"""
        return _IMP_core.CoinFlipPairPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(CoinFlipPairPredicate self) -> std::string"""
        return _IMP_core.CoinFlipPairPredicate___repr__(self)

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


# Register CoinFlipPairPredicate in _IMP_core:
_IMP_core.CoinFlipPairPredicate_swigregister(CoinFlipPairPredicate)
class ConstantTripletPredicate(IMP.TripletPredicate):
    r"""Proxy of C++ IMP::core::ConstantTripletPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ConstantTripletPredicate self, int v, std::string name="ConstTripletPredicate%1%") -> ConstantTripletPredicate
        __init__(ConstantTripletPredicate self) -> ConstantTripletPredicate
        """
        _IMP_core.ConstantTripletPredicate_swiginit(self, _IMP_core.new_ConstantTripletPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(ConstantTripletPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantTripletPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ConstantTripletPredicate

    def __str__(self):
        r"""__str__(ConstantTripletPredicate self) -> std::string"""
        return _IMP_core.ConstantTripletPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(ConstantTripletPredicate self) -> std::string"""
        return _IMP_core.ConstantTripletPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ConstantTripletPredicate self) -> PyObject *"""
        return _IMP_core.ConstantTripletPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConstantTripletPredicate self, PyObject * p)"""
        return _IMP_core.ConstantTripletPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ConstantTripletPredicate in _IMP_core:
_IMP_core.ConstantTripletPredicate_swigregister(ConstantTripletPredicate)
class UnorderedTypeTripletPredicate(IMP.TripletPredicate):
    r"""Proxy of C++ IMP::core::UnorderedTypeTripletPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(UnorderedTypeTripletPredicate self, std::string name="UnorderedTypeTripletPredicate%1%") -> UnorderedTypeTripletPredicate"""
        _IMP_core.UnorderedTypeTripletPredicate_swiginit(self, _IMP_core.new_UnorderedTypeTripletPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(UnorderedTypeTripletPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypeTripletPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_UnorderedTypeTripletPredicate

    def __str__(self):
        r"""__str__(UnorderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeTripletPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(UnorderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeTripletPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(UnorderedTypeTripletPredicate self) -> PyObject *"""
        return _IMP_core.UnorderedTypeTripletPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnorderedTypeTripletPredicate self, PyObject * p)"""
        return _IMP_core.UnorderedTypeTripletPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register UnorderedTypeTripletPredicate in _IMP_core:
_IMP_core.UnorderedTypeTripletPredicate_swigregister(UnorderedTypeTripletPredicate)
class OrderedTypeTripletPredicate(IMP.TripletPredicate):
    r"""Proxy of C++ IMP::core::OrderedTypeTripletPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(OrderedTypeTripletPredicate self, std::string name="OrderedTypeTripletPredicate%1%") -> OrderedTypeTripletPredicate"""
        _IMP_core.OrderedTypeTripletPredicate_swiginit(self, _IMP_core.new_OrderedTypeTripletPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(OrderedTypeTripletPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypeTripletPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_OrderedTypeTripletPredicate

    def __str__(self):
        r"""__str__(OrderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeTripletPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(OrderedTypeTripletPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeTripletPredicate___repr__(self)

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


# Register OrderedTypeTripletPredicate in _IMP_core:
_IMP_core.OrderedTypeTripletPredicate_swigregister(OrderedTypeTripletPredicate)
class AllSameTripletPredicate(IMP.TripletPredicate):
    r"""Proxy of C++ IMP::core::AllSameTripletPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(AllSameTripletPredicate self, std::string name="AllSameTripletPredicate%1%") -> AllSameTripletPredicate"""
        _IMP_core.AllSameTripletPredicate_swiginit(self, _IMP_core.new_AllSameTripletPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(AllSameTripletPredicate self) -> VersionInfo"""
        return _IMP_core.AllSameTripletPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_AllSameTripletPredicate

    def __str__(self):
        r"""__str__(AllSameTripletPredicate self) -> std::string"""
        return _IMP_core.AllSameTripletPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(AllSameTripletPredicate self) -> std::string"""
        return _IMP_core.AllSameTripletPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(AllSameTripletPredicate self) -> PyObject *"""
        return _IMP_core.AllSameTripletPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AllSameTripletPredicate self, PyObject * p)"""
        return _IMP_core.AllSameTripletPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register AllSameTripletPredicate in _IMP_core:
_IMP_core.AllSameTripletPredicate_swigregister(AllSameTripletPredicate)
class CoinFlipTripletPredicate(IMP.TripletPredicate):
    r"""Proxy of C++ IMP::core::CoinFlipTripletPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(CoinFlipTripletPredicate self, double p, std::string name="CoinFlipTripletPredicate%1%") -> CoinFlipTripletPredicate"""
        _IMP_core.CoinFlipTripletPredicate_swiginit(self, _IMP_core.new_CoinFlipTripletPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(CoinFlipTripletPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipTripletPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_CoinFlipTripletPredicate

    def __str__(self):
        r"""__str__(CoinFlipTripletPredicate self) -> std::string"""
        return _IMP_core.CoinFlipTripletPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(CoinFlipTripletPredicate self) -> std::string"""
        return _IMP_core.CoinFlipTripletPredicate___repr__(self)

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


# Register CoinFlipTripletPredicate in _IMP_core:
_IMP_core.CoinFlipTripletPredicate_swigregister(CoinFlipTripletPredicate)
class ConstantQuadPredicate(IMP.QuadPredicate):
    r"""Proxy of C++ IMP::core::ConstantQuadPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ConstantQuadPredicate self, int v, std::string name="ConstQuadPredicate%1%") -> ConstantQuadPredicate
        __init__(ConstantQuadPredicate self) -> ConstantQuadPredicate
        """
        _IMP_core.ConstantQuadPredicate_swiginit(self, _IMP_core.new_ConstantQuadPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(ConstantQuadPredicate self) -> VersionInfo"""
        return _IMP_core.ConstantQuadPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_ConstantQuadPredicate

    def __str__(self):
        r"""__str__(ConstantQuadPredicate self) -> std::string"""
        return _IMP_core.ConstantQuadPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(ConstantQuadPredicate self) -> std::string"""
        return _IMP_core.ConstantQuadPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ConstantQuadPredicate self) -> PyObject *"""
        return _IMP_core.ConstantQuadPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConstantQuadPredicate self, PyObject * p)"""
        return _IMP_core.ConstantQuadPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register ConstantQuadPredicate in _IMP_core:
_IMP_core.ConstantQuadPredicate_swigregister(ConstantQuadPredicate)
class UnorderedTypeQuadPredicate(IMP.QuadPredicate):
    r"""Proxy of C++ IMP::core::UnorderedTypeQuadPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(UnorderedTypeQuadPredicate self, std::string name="UnorderedTypeQuadPredicate%1%") -> UnorderedTypeQuadPredicate"""
        _IMP_core.UnorderedTypeQuadPredicate_swiginit(self, _IMP_core.new_UnorderedTypeQuadPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(UnorderedTypeQuadPredicate self) -> VersionInfo"""
        return _IMP_core.UnorderedTypeQuadPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_UnorderedTypeQuadPredicate

    def __str__(self):
        r"""__str__(UnorderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeQuadPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(UnorderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.UnorderedTypeQuadPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(UnorderedTypeQuadPredicate self) -> PyObject *"""
        return _IMP_core.UnorderedTypeQuadPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(UnorderedTypeQuadPredicate self, PyObject * p)"""
        return _IMP_core.UnorderedTypeQuadPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register UnorderedTypeQuadPredicate in _IMP_core:
_IMP_core.UnorderedTypeQuadPredicate_swigregister(UnorderedTypeQuadPredicate)
class OrderedTypeQuadPredicate(IMP.QuadPredicate):
    r"""Proxy of C++ IMP::core::OrderedTypeQuadPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(OrderedTypeQuadPredicate self, std::string name="OrderedTypeQuadPredicate%1%") -> OrderedTypeQuadPredicate"""
        _IMP_core.OrderedTypeQuadPredicate_swiginit(self, _IMP_core.new_OrderedTypeQuadPredicate(*args))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(OrderedTypeQuadPredicate self) -> VersionInfo"""
        return _IMP_core.OrderedTypeQuadPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_OrderedTypeQuadPredicate

    def __str__(self):
        r"""__str__(OrderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeQuadPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(OrderedTypeQuadPredicate self) -> std::string"""
        return _IMP_core.OrderedTypeQuadPredicate___repr__(self)

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


# Register OrderedTypeQuadPredicate in _IMP_core:
_IMP_core.OrderedTypeQuadPredicate_swigregister(OrderedTypeQuadPredicate)
class AllSameQuadPredicate(IMP.QuadPredicate):
    r"""Proxy of C++ IMP::core::AllSameQuadPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(AllSameQuadPredicate self, std::string name="AllSameQuadPredicate%1%") -> AllSameQuadPredicate"""
        _IMP_core.AllSameQuadPredicate_swiginit(self, _IMP_core.new_AllSameQuadPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(AllSameQuadPredicate self) -> VersionInfo"""
        return _IMP_core.AllSameQuadPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_AllSameQuadPredicate

    def __str__(self):
        r"""__str__(AllSameQuadPredicate self) -> std::string"""
        return _IMP_core.AllSameQuadPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(AllSameQuadPredicate self) -> std::string"""
        return _IMP_core.AllSameQuadPredicate___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(AllSameQuadPredicate self) -> PyObject *"""
        return _IMP_core.AllSameQuadPredicate__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AllSameQuadPredicate self, PyObject * p)"""
        return _IMP_core.AllSameQuadPredicate__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register AllSameQuadPredicate in _IMP_core:
_IMP_core.AllSameQuadPredicate_swigregister(AllSameQuadPredicate)
class CoinFlipQuadPredicate(IMP.QuadPredicate):
    r"""Proxy of C++ IMP::core::CoinFlipQuadPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(CoinFlipQuadPredicate self, double p, std::string name="CoinFlipQuadPredicate%1%") -> CoinFlipQuadPredicate"""
        _IMP_core.CoinFlipQuadPredicate_swiginit(self, _IMP_core.new_CoinFlipQuadPredicate(*args))

    def do_get_inputs(self, arg2, arg3):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(CoinFlipQuadPredicate self) -> VersionInfo"""
        return _IMP_core.CoinFlipQuadPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_CoinFlipQuadPredicate

    def __str__(self):
        r"""__str__(CoinFlipQuadPredicate self) -> std::string"""
        return _IMP_core.CoinFlipQuadPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(CoinFlipQuadPredicate self) -> std::string"""
        return _IMP_core.CoinFlipQuadPredicate___repr__(self)

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


# Register CoinFlipQuadPredicate in _IMP_core:
_IMP_core.CoinFlipQuadPredicate_swigregister(CoinFlipQuadPredicate)
class InBoundingBox3DSingletonPredicate(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::core::InBoundingBox3DSingletonPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(InBoundingBox3DSingletonPredicate self, BoundingBox3D bb, std::string name="InBoundingBox3DSingletonPredicate%1%") -> InBoundingBox3DSingletonPredicate"""
        _IMP_core.InBoundingBox3DSingletonPredicate_swiginit(self, _IMP_core.new_InBoundingBox3DSingletonPredicate(*args))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(InBoundingBox3DSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.InBoundingBox3DSingletonPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_InBoundingBox3DSingletonPredicate

    def __str__(self):
        r"""__str__(InBoundingBox3DSingletonPredicate self) -> std::string"""
        return _IMP_core.InBoundingBox3DSingletonPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(InBoundingBox3DSingletonPredicate self) -> std::string"""
        return _IMP_core.InBoundingBox3DSingletonPredicate___repr__(self)

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


# Register InBoundingBox3DSingletonPredicate in _IMP_core:
_IMP_core.InBoundingBox3DSingletonPredicate_swigregister(InBoundingBox3DSingletonPredicate)
class AttributeSingletonPredicate(IMP.SingletonPredicate):
    r"""Proxy of C++ IMP::core::AttributeSingletonPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(AttributeSingletonPredicate self, IntKey bb, std::string name="AttributeSingletonPredicate%1%") -> AttributeSingletonPredicate"""
        _IMP_core.AttributeSingletonPredicate_swiginit(self, _IMP_core.new_AttributeSingletonPredicate(*args))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(AttributeSingletonPredicate self) -> VersionInfo"""
        return _IMP_core.AttributeSingletonPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_AttributeSingletonPredicate

    def __str__(self):
        r"""__str__(AttributeSingletonPredicate self) -> std::string"""
        return _IMP_core.AttributeSingletonPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(AttributeSingletonPredicate self) -> std::string"""
        return _IMP_core.AttributeSingletonPredicate___repr__(self)

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


# Register AttributeSingletonPredicate in _IMP_core:
_IMP_core.AttributeSingletonPredicate_swigregister(AttributeSingletonPredicate)
class IsCollisionPairPredicate(IMP.PairPredicate):
    r"""Proxy of C++ IMP::core::IsCollisionPairPredicate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""__init__(IsCollisionPairPredicate self, std::string name="CollisionPairPredicate%1%") -> IsCollisionPairPredicate"""
        _IMP_core.IsCollisionPairPredicate_swiginit(self, _IMP_core.new_IsCollisionPairPredicate(*args))

    def do_get_inputs(self, m, pi):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""get_version_info(IsCollisionPairPredicate self) -> VersionInfo"""
        return _IMP_core.IsCollisionPairPredicate_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_IsCollisionPairPredicate

    def __str__(self):
        r"""__str__(IsCollisionPairPredicate self) -> std::string"""
        return _IMP_core.IsCollisionPairPredicate___str__(self)

    def __repr__(self):
        r"""__repr__(IsCollisionPairPredicate self) -> std::string"""
        return _IMP_core.IsCollisionPairPredicate___repr__(self)

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


# Register IsCollisionPairPredicate in _IMP_core:
_IMP_core.IsCollisionPairPredicate_swigregister(IsCollisionPairPredicate)
class AngleRestraint(TripletRestraint):
    r"""Proxy of C++ IMP::core::AngleRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(AngleRestraint self, Model m, UnaryFunction score_func, _ParticleIndexAdaptor p1, _ParticleIndexAdaptor p2, _ParticleIndexAdaptor p3) -> AngleRestraint
        __init__(AngleRestraint self) -> AngleRestraint
        """
        _IMP_core.AngleRestraint_swiginit(self, _IMP_core.new_AngleRestraint(*args))
    __swig_destroy__ = _IMP_core.delete_AngleRestraint

    def __str__(self):
        r"""__str__(AngleRestraint self) -> std::string"""
        return _IMP_core.AngleRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(AngleRestraint self) -> std::string"""
        return _IMP_core.AngleRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(AngleRestraint self) -> PyObject *"""
        return _IMP_core.AngleRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AngleRestraint self, PyObject * p)"""
        return _IMP_core.AngleRestraint__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register AngleRestraint in _IMP_core:
_IMP_core.AngleRestraint_swigregister(AngleRestraint)
class RigidBodyMover(MonteCarloMover):
    r"""Proxy of C++ IMP::core::RigidBodyMover class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(RigidBodyMover self, Model m, ParticleIndex pi, IMP::Float max_translation, IMP::Float max_rotation) -> RigidBodyMover
        __init__(RigidBodyMover self) -> RigidBodyMover
        """
        _IMP_core.RigidBodyMover_swiginit(self, _IMP_core.new_RigidBodyMover(*args))

    def set_maximum_translation(self, mt):
        r"""set_maximum_translation(RigidBodyMover self, IMP::Float mt)"""
        return _IMP_core.RigidBodyMover_set_maximum_translation(self, mt)

    def set_maximum_rotation(self, mr):
        r"""set_maximum_rotation(RigidBodyMover self, IMP::Float mr)"""
        return _IMP_core.RigidBodyMover_set_maximum_rotation(self, mr)

    def get_maximum_translation(self):
        r"""get_maximum_translation(RigidBodyMover self) -> IMP::Float"""
        return _IMP_core.RigidBodyMover_get_maximum_translation(self)

    def get_maximum_rotation(self):
        r"""get_maximum_rotation(RigidBodyMover self) -> IMP::Float"""
        return _IMP_core.RigidBodyMover_get_maximum_rotation(self)

    def get_index(self):
        r"""get_index(RigidBodyMover self) -> ParticleIndex"""
        return _IMP_core.RigidBodyMover_get_index(self)

    def get_version_info(self):
        r"""get_version_info(RigidBodyMover self) -> VersionInfo"""
        return _IMP_core.RigidBodyMover_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyMover

    def __str__(self):
        r"""__str__(RigidBodyMover self) -> std::string"""
        return _IMP_core.RigidBodyMover___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyMover self) -> std::string"""
        return _IMP_core.RigidBodyMover___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(RigidBodyMover self) -> PyObject *"""
        return _IMP_core.RigidBodyMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RigidBodyMover self, PyObject * p)"""
        return _IMP_core.RigidBodyMover__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register RigidBodyMover in _IMP_core:
_IMP_core.RigidBodyMover_swigregister(RigidBodyMover)
class RigidBodyTunneler(MonteCarloMover):
    r"""Proxy of C++ IMP::core::RigidBodyTunneler class."""

    thisown = 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.):
        r"""__init__(RigidBodyTunneler self, Model m, IMP::ParticleIndexes pis, ParticleIndex ref, double k, double move_probability=1.) -> RigidBodyTunneler"""
        _IMP_core.RigidBodyTunneler_swiginit(self, _IMP_core.new_RigidBodyTunneler(m, pis, ref, k, move_probability))

    def add_entry_point(self, fl):
        r"""add_entry_point(RigidBodyTunneler self, IMP::Floats fl)"""
        return _IMP_core.RigidBodyTunneler_add_entry_point(self, fl)

    def reset_stats(self):
        r"""reset_stats(RigidBodyTunneler self)"""
        return _IMP_core.RigidBodyTunneler_reset_stats(self)

    def get_number_of_rejected_moves(self):
        r"""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):
        r"""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):
        r"""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):
        r"""get_number_of_calls(RigidBodyTunneler self) -> unsigned int"""
        return _IMP_core.RigidBodyTunneler_get_number_of_calls(self)

    @staticmethod
    def get_reduced_coordinates(*args):
        r"""
        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)

    @staticmethod
    def set_reduced_coordinates(m, target, ref, coords):
        r"""set_reduced_coordinates(Model m, ParticleIndex target, ParticleIndex ref, IMP::Floats coords)"""
        return _IMP_core.RigidBodyTunneler_set_reduced_coordinates(m, target, ref, coords)

    def get_version_info(self):
        r"""get_version_info(RigidBodyTunneler self) -> VersionInfo"""
        return _IMP_core.RigidBodyTunneler_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyTunneler

    def __str__(self):
        r"""__str__(RigidBodyTunneler self) -> std::string"""
        return _IMP_core.RigidBodyTunneler___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyTunneler self) -> std::string"""
        return _IMP_core.RigidBodyTunneler___repr__(self)

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


# Register RigidBodyTunneler in _IMP_core:
_IMP_core.RigidBodyTunneler_swigregister(RigidBodyTunneler)
class RigidBodyUmbrella(IMP.Restraint):
    r"""Proxy of C++ IMP::core::RigidBodyUmbrella class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(RigidBodyUmbrella self, Model m, ParticleIndex pi, ParticleIndex ref, IMP::Floats x0, double alpha, double k, std::string name="RigidBodyUmbrella %1%") -> RigidBodyUmbrella
        __init__(RigidBodyUmbrella self, Model m, ParticleIndex pi, ParticleIndex ref, double _lambda, IMP::Floats x1, IMP::Floats x2, double alpha, double k, std::string name="RigidBodyUmbrella %1%") -> RigidBodyUmbrella
        """
        _IMP_core.RigidBodyUmbrella_swiginit(self, _IMP_core.new_RigidBodyUmbrella(*args))

    def set_x0(self, *args):
        r"""
        set_x0(RigidBodyUmbrella self, IMP::Floats x0)
        set_x0(RigidBodyUmbrella self, double _lambda, IMP::Floats x1, IMP::Floats x2)
        """
        return _IMP_core.RigidBodyUmbrella_set_x0(self, *args)

    def get_x0(self):
        r"""get_x0(RigidBodyUmbrella self) -> IMP::Floats"""
        return _IMP_core.RigidBodyUmbrella_get_x0(self)

    def get_x(self):
        r"""get_x(RigidBodyUmbrella self) -> IMP::Floats"""
        return _IMP_core.RigidBodyUmbrella_get_x(self)

    def set_alpha(self, alpha):
        r"""set_alpha(RigidBodyUmbrella self, double alpha)"""
        return _IMP_core.RigidBodyUmbrella_set_alpha(self, alpha)

    def set_k(self, k):
        r"""set_k(RigidBodyUmbrella self, double k)"""
        return _IMP_core.RigidBodyUmbrella_set_k(self, k)

    def get_version_info(self):
        r"""get_version_info(RigidBodyUmbrella self) -> VersionInfo"""
        return _IMP_core.RigidBodyUmbrella_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_RigidBodyUmbrella

    def __str__(self):
        r"""__str__(RigidBodyUmbrella self) -> std::string"""
        return _IMP_core.RigidBodyUmbrella___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyUmbrella self) -> std::string"""
        return _IMP_core.RigidBodyUmbrella___repr__(self)

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


# Register RigidBodyUmbrella in _IMP_core:
_IMP_core.RigidBodyUmbrella_swigregister(RigidBodyUmbrella)
class VolumeRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::VolumeRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, f, sc, volume):
        r"""__init__(VolumeRestraint self, UnaryFunction f, SingletonContainer sc, double volume) -> VolumeRestraint"""
        _IMP_core.VolumeRestraint_swiginit(self, _IMP_core.new_VolumeRestraint(f, sc, volume))

    def do_get_inputs(self):
        r"""do_get_inputs(VolumeRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.VolumeRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(VolumeRestraint self) -> VersionInfo"""
        return _IMP_core.VolumeRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_VolumeRestraint

    def __str__(self):
        r"""__str__(VolumeRestraint self) -> std::string"""
        return _IMP_core.VolumeRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(VolumeRestraint self) -> std::string"""
        return _IMP_core.VolumeRestraint___repr__(self)

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


# Register VolumeRestraint in _IMP_core:
_IMP_core.VolumeRestraint_swigregister(VolumeRestraint)

def get_centroid(ps):
    r"""get_centroid(IMP::core::XYZs const & ps) -> Vector3D"""
    return _IMP_core.get_centroid(ps)

def get_bounding_box(ps):
    r"""get_bounding_box(IMP::core::XYZRs const & ps) -> BoundingBox3D"""
    return _IMP_core.get_bounding_box(ps)
class MoveStatisticsScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::core::MoveStatisticsScoreState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, ps):
        r"""__init__(MoveStatisticsScoreState self, IMP::ParticlesTemp const & ps) -> MoveStatisticsScoreState"""
        _IMP_core.MoveStatisticsScoreState_swiginit(self, _IMP_core.new_MoveStatisticsScoreState(ps))

    def show_statistics(self, *args):
        r"""show_statistics(MoveStatisticsScoreState self, _ostream out=std::cout)"""
        return _IMP_core.MoveStatisticsScoreState_show_statistics(self, *args)

    def reset(self):
        r"""reset(MoveStatisticsScoreState self)"""
        return _IMP_core.MoveStatisticsScoreState_reset(self)

    def do_before_evaluate(self):
        r"""do_before_evaluate(MoveStatisticsScoreState self)"""
        return _IMP_core.MoveStatisticsScoreState_do_before_evaluate(self)

    def do_after_evaluate(self, da):
        r"""do_after_evaluate(MoveStatisticsScoreState self, DerivativeAccumulator da)"""
        return _IMP_core.MoveStatisticsScoreState_do_after_evaluate(self, da)

    def do_get_inputs(self):
        r"""do_get_inputs(MoveStatisticsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.MoveStatisticsScoreState_do_get_inputs(self)

    def do_get_outputs(self):
        r"""do_get_outputs(MoveStatisticsScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_core.MoveStatisticsScoreState_do_get_outputs(self)

    def get_version_info(self):
        r"""get_version_info(MoveStatisticsScoreState self) -> VersionInfo"""
        return _IMP_core.MoveStatisticsScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_MoveStatisticsScoreState

    def __str__(self):
        r"""__str__(MoveStatisticsScoreState self) -> std::string"""
        return _IMP_core.MoveStatisticsScoreState___str__(self)

    def __repr__(self):
        r"""__repr__(MoveStatisticsScoreState self) -> std::string"""
        return _IMP_core.MoveStatisticsScoreState___repr__(self)

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


# Register MoveStatisticsScoreState in _IMP_core:
_IMP_core.MoveStatisticsScoreState_swigregister(MoveStatisticsScoreState)
IMP_PARTICLE_TYPE_INDEX = _IMP_core.IMP_PARTICLE_TYPE_INDEX

class Typed(IMP.Decorator):
    r"""Proxy of C++ IMP::core::Typed class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    @staticmethod
    def get_type_key():
        r"""get_type_key() -> IntKey"""
        return _IMP_core.Typed_get_type_key()

    def __init__(self, *args):
        r"""
        __init__(Typed self) -> Typed
        __init__(Typed self, Model m, ParticleIndex id) -> Typed
        __init__(Typed self, _ParticleAdaptor d) -> Typed
        """
        _IMP_core.Typed_swiginit(self, _IMP_core.new_Typed(*args))

    def show(self, *args):
        r"""show(Typed self, _ostream out=std::cout)"""
        return _IMP_core.Typed_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, ParticleType t) -> Typed
        setup_particle(_ParticleAdaptor pa, ParticleType t) -> Typed
        """
        return _IMP_core.Typed_setup_particle(*args)

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

    def get_type(self):
        r"""get_type(Typed self) -> ParticleType"""
        return _IMP_core.Typed_get_type(self)

    def set_type(self, pt):
        r"""set_type(Typed self, ParticleType pt)"""
        return _IMP_core.Typed_set_type(self, pt)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Typed self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Typed self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Typed self, SparseStringKey a0, IMP::String a1)
        add_attribute(Typed self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Typed_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Typed self, SparseFloatKey a0) -> IMP::Float
        get_value(Typed self, SparseIntKey a0) -> IMP::Int
        get_value(Typed self, SparseStringKey a0) -> IMP::String
        get_value(Typed self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Typed_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Typed self, SparseFloatKey a0, IMP::Float a1)
        set_value(Typed self, SparseIntKey a0, IMP::Int a1)
        set_value(Typed self, SparseStringKey a0, IMP::String a1)
        set_value(Typed self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Typed_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Typed self, SparseFloatKey a0)
        remove_attribute(Typed self, SparseIntKey a0)
        remove_attribute(Typed self, SparseStringKey a0)
        remove_attribute(Typed self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Typed_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Typed self, SparseFloatKey a0) -> bool
        has_attribute(Typed self, SparseIntKey a0) -> bool
        has_attribute(Typed self, SparseStringKey a0) -> bool
        has_attribute(Typed self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Typed_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(Typed self, FloatKey a0) -> double"""
        return _IMP_core.Typed_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(Typed self) -> std::string"""
        return _IMP_core.Typed_get_name(self)

    def clear_caches(self):
        r"""clear_caches(Typed self)"""
        return _IMP_core.Typed_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(Typed self, std::string a0)"""
        return _IMP_core.Typed_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Typed self, FloatKey a0) -> bool"""
        return _IMP_core.Typed_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(Typed self) -> IMP::CheckLevel"""
        return _IMP_core.Typed_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(Typed self, Typed o) -> bool
        __eq__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(Typed self, Typed o) -> bool
        __ne__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(Typed self, Typed o) -> bool
        __le__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(Typed self, Typed o) -> bool
        __lt__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(Typed self, Typed o) -> bool
        __ge__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(Typed self, Typed o) -> bool
        __gt__(Typed self, Particle d) -> bool
        """
        return _IMP_core.Typed___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(Typed self) -> std::size_t"""
        return _IMP_core.Typed___hash__(self)

    def __str__(self):
        r"""__str__(Typed self) -> std::string"""
        return _IMP_core.Typed___str__(self)

    def __repr__(self):
        r"""__repr__(Typed self) -> std::string"""
        return _IMP_core.Typed___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Typed self) -> PyObject *"""
        return _IMP_core.Typed__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Typed self, PyObject * p)"""
        return _IMP_core.Typed__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Typed

# Register Typed in _IMP_core:
_IMP_core.Typed_swigregister(Typed)

def __lshift__(*args):
    r"""
    __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):
    r"""Proxy of C++ IMP::core::WriteRestraintScoresOptimizerState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, rs, out):
        r"""__init__(WriteRestraintScoresOptimizerState self, IMP::Restraints const & rs, TextOutput out) -> WriteRestraintScoresOptimizerState"""
        _IMP_core.WriteRestraintScoresOptimizerState_swiginit(self, _IMP_core.new_WriteRestraintScoresOptimizerState(rs, out))

    def get_version_info(self):
        r"""get_version_info(WriteRestraintScoresOptimizerState self) -> VersionInfo"""
        return _IMP_core.WriteRestraintScoresOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_WriteRestraintScoresOptimizerState

    def __str__(self):
        r"""__str__(WriteRestraintScoresOptimizerState self) -> std::string"""
        return _IMP_core.WriteRestraintScoresOptimizerState___str__(self)

    def __repr__(self):
        r"""__repr__(WriteRestraintScoresOptimizerState self) -> std::string"""
        return _IMP_core.WriteRestraintScoresOptimizerState___repr__(self)

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


# Register WriteRestraintScoresOptimizerState in _IMP_core:
_IMP_core.WriteRestraintScoresOptimizerState_swigregister(WriteRestraintScoresOptimizerState)

def assign_blame(rs, ps, attribute):
    r"""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):
    r"""create_blame_geometries(IMP::RestraintsTemp const & rs, IMP::ParticlesTemp const & ps, double max=NO_MAX, std::string name=std::string()) -> IMP::display::Geometries"""
    return _IMP_core.create_blame_geometries(*args)
class MultipleBinormalRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::core::MultipleBinormalRestraint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, m, q1, q2):
        r"""__init__(MultipleBinormalRestraint self, Model m, IMP::ParticleIndexQuad const & q1, IMP::ParticleIndexQuad const & q2) -> MultipleBinormalRestraint"""
        _IMP_core.MultipleBinormalRestraint_swiginit(self, _IMP_core.new_MultipleBinormalRestraint(m, q1, q2))

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

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

    def get_version_info(self):
        r"""get_version_info(MultipleBinormalRestraint self) -> VersionInfo"""
        return _IMP_core.MultipleBinormalRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_MultipleBinormalRestraint

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

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

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


# Register MultipleBinormalRestraint in _IMP_core:
_IMP_core.MultipleBinormalRestraint_swigregister(MultipleBinormalRestraint)
class BinormalTerm(object):
    r"""Proxy of C++ IMP::core::BinormalTerm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self):
        r"""__init__(BinormalTerm self) -> BinormalTerm"""
        _IMP_core.BinormalTerm_swiginit(self, _IMP_core.new_BinormalTerm())

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(BinormalTerm self) -> PyObject *"""
        return _IMP_core.BinormalTerm__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(BinormalTerm self, PyObject * p)"""
        return _IMP_core.BinormalTerm__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_BinormalTerm

# Register BinormalTerm in _IMP_core:
_IMP_core.BinormalTerm_swigregister(BinormalTerm)
class Provenance(IMP.Decorator):
    r"""Proxy of C++ IMP::core::Provenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

    def __init__(self, *args):
        r"""
        __init__(Provenance self) -> Provenance
        __init__(Provenance self, Model m, ParticleIndex id) -> Provenance
        __init__(Provenance self, _ParticleAdaptor d) -> Provenance
        """
        _IMP_core.Provenance_swiginit(self, _IMP_core.new_Provenance(*args))

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Provenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Provenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Provenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(Provenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Provenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Provenance self, SparseFloatKey a0) -> IMP::Float
        get_value(Provenance self, SparseIntKey a0) -> IMP::Int
        get_value(Provenance self, SparseStringKey a0) -> IMP::String
        get_value(Provenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Provenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Provenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(Provenance self, SparseIntKey a0, IMP::Int a1)
        set_value(Provenance self, SparseStringKey a0, IMP::String a1)
        set_value(Provenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Provenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Provenance self, SparseFloatKey a0)
        remove_attribute(Provenance self, SparseIntKey a0)
        remove_attribute(Provenance self, SparseStringKey a0)
        remove_attribute(Provenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Provenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Provenance self, SparseFloatKey a0) -> bool
        has_attribute(Provenance self, SparseIntKey a0) -> bool
        has_attribute(Provenance self, SparseStringKey a0) -> bool
        has_attribute(Provenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Provenance_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Provenance self, FloatKey a0) -> bool"""
        return _IMP_core.Provenance_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Provenance self) -> PyObject *"""
        return _IMP_core.Provenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Provenance self, PyObject * p)"""
        return _IMP_core.Provenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Provenance

# Register Provenance in _IMP_core:
_IMP_core.Provenance_swigregister(Provenance)
class StructureProvenance(Provenance):
    r"""Proxy of C++ IMP::core::StructureProvenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(StructureProvenance self) -> StructureProvenance
        __init__(StructureProvenance self, Model m, ParticleIndex id) -> StructureProvenance
        __init__(StructureProvenance self, _ParticleAdaptor d) -> StructureProvenance
        """
        _IMP_core.StructureProvenance_swiginit(self, _IMP_core.new_StructureProvenance(*args))

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

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

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, std::string filename, std::string chain_id, int residue_offset) -> StructureProvenance
        setup_particle(_ParticleAdaptor pa, 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 pa, std::string filename, std::string chain_id) -> StructureProvenance
        setup_particle(Model m, ParticleIndex pi, StructureProvenance o) -> StructureProvenance
        setup_particle(_ParticleAdaptor pa, StructureProvenance o) -> StructureProvenance
        """
        return _IMP_core.StructureProvenance_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(StructureProvenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(StructureProvenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(StructureProvenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(StructureProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.StructureProvenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(StructureProvenance self, SparseFloatKey a0) -> IMP::Float
        get_value(StructureProvenance self, SparseIntKey a0) -> IMP::Int
        get_value(StructureProvenance self, SparseStringKey a0) -> IMP::String
        get_value(StructureProvenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.StructureProvenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(StructureProvenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(StructureProvenance self, SparseIntKey a0, IMP::Int a1)
        set_value(StructureProvenance self, SparseStringKey a0, IMP::String a1)
        set_value(StructureProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.StructureProvenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(StructureProvenance self, SparseFloatKey a0)
        remove_attribute(StructureProvenance self, SparseIntKey a0)
        remove_attribute(StructureProvenance self, SparseStringKey a0)
        remove_attribute(StructureProvenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.StructureProvenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(StructureProvenance self, SparseFloatKey a0) -> bool
        has_attribute(StructureProvenance self, SparseIntKey a0) -> bool
        has_attribute(StructureProvenance self, SparseStringKey a0) -> bool
        has_attribute(StructureProvenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.StructureProvenance_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(StructureProvenance self, FloatKey a0) -> bool"""
        return _IMP_core.StructureProvenance_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(StructureProvenance self) -> PyObject *"""
        return _IMP_core.StructureProvenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(StructureProvenance self, PyObject * p)"""
        return _IMP_core.StructureProvenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_StructureProvenance

# Register StructureProvenance in _IMP_core:
_IMP_core.StructureProvenance_swigregister(StructureProvenance)
class SampleProvenance(Provenance):
    r"""Proxy of C++ IMP::core::SampleProvenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(SampleProvenance self) -> SampleProvenance
        __init__(SampleProvenance self, Model m, ParticleIndex id) -> SampleProvenance
        __init__(SampleProvenance self, _ParticleAdaptor d) -> SampleProvenance
        """
        _IMP_core.SampleProvenance_swiginit(self, _IMP_core.new_SampleProvenance(*args))

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

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

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, std::string method, int frames, int iterations, int replicas) -> SampleProvenance
        setup_particle(_ParticleAdaptor pa, 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 pa, std::string method, int frames, int iterations) -> SampleProvenance
        setup_particle(Model m, ParticleIndex pi, SampleProvenance o) -> SampleProvenance
        setup_particle(_ParticleAdaptor pa, SampleProvenance o) -> SampleProvenance
        """
        return _IMP_core.SampleProvenance_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(SampleProvenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(SampleProvenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(SampleProvenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(SampleProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.SampleProvenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(SampleProvenance self, SparseFloatKey a0) -> IMP::Float
        get_value(SampleProvenance self, SparseIntKey a0) -> IMP::Int
        get_value(SampleProvenance self, SparseStringKey a0) -> IMP::String
        get_value(SampleProvenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.SampleProvenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(SampleProvenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(SampleProvenance self, SparseIntKey a0, IMP::Int a1)
        set_value(SampleProvenance self, SparseStringKey a0, IMP::String a1)
        set_value(SampleProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.SampleProvenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(SampleProvenance self, SparseFloatKey a0)
        remove_attribute(SampleProvenance self, SparseIntKey a0)
        remove_attribute(SampleProvenance self, SparseStringKey a0)
        remove_attribute(SampleProvenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.SampleProvenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(SampleProvenance self, SparseFloatKey a0) -> bool
        has_attribute(SampleProvenance self, SparseIntKey a0) -> bool
        has_attribute(SampleProvenance self, SparseStringKey a0) -> bool
        has_attribute(SampleProvenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.SampleProvenance_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(SampleProvenance self, FloatKey a0) -> bool"""
        return _IMP_core.SampleProvenance_get_is_optimized(self, a0)

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(SampleProvenance self) -> PyObject *"""
        return _IMP_core.SampleProvenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SampleProvenance self, PyObject * p)"""
        return _IMP_core.SampleProvenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_SampleProvenance

# Register SampleProvenance in _IMP_core:
_IMP_core.SampleProvenance_swigregister(SampleProvenance)
class CombineProvenance(Provenance):
    r"""Proxy of C++ IMP::core::CombineProvenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

    def __init__(self, *args):
        r"""
        __init__(CombineProvenance self) -> CombineProvenance
        __init__(CombineProvenance self, Model m, ParticleIndex id) -> CombineProvenance
        __init__(CombineProvenance self, _ParticleAdaptor d) -> CombineProvenance
        """
        _IMP_core.CombineProvenance_swiginit(self, _IMP_core.new_CombineProvenance(*args))

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

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

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

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(CombineProvenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(CombineProvenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(CombineProvenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(CombineProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.CombineProvenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(CombineProvenance self, SparseFloatKey a0) -> IMP::Float
        get_value(CombineProvenance self, SparseIntKey a0) -> IMP::Int
        get_value(CombineProvenance self, SparseStringKey a0) -> IMP::String
        get_value(CombineProvenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.CombineProvenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(CombineProvenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(CombineProvenance self, SparseIntKey a0, IMP::Int a1)
        set_value(CombineProvenance self, SparseStringKey a0, IMP::String a1)
        set_value(CombineProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.CombineProvenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(CombineProvenance self, SparseFloatKey a0)
        remove_attribute(CombineProvenance self, SparseIntKey a0)
        remove_attribute(CombineProvenance self, SparseStringKey a0)
        remove_attribute(CombineProvenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.CombineProvenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(CombineProvenance self, SparseFloatKey a0) -> bool
        has_attribute(CombineProvenance self, SparseIntKey a0) -> bool
        has_attribute(CombineProvenance self, SparseStringKey a0) -> bool
        has_attribute(CombineProvenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.CombineProvenance_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(CombineProvenance self, FloatKey a0) -> double"""
        return _IMP_core.CombineProvenance_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(CombineProvenance self) -> std::string"""
        return _IMP_core.CombineProvenance_get_name(self)

    def clear_caches(self):
        r"""clear_caches(CombineProvenance self)"""
        return _IMP_core.CombineProvenance_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(CombineProvenance self, std::string a0)"""
        return _IMP_core.CombineProvenance_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(CombineProvenance self, FloatKey a0) -> bool"""
        return _IMP_core.CombineProvenance_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(CombineProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.CombineProvenance_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(CombineProvenance self, CombineProvenance o) -> bool
        __eq__(CombineProvenance self, Particle d) -> bool
        """
        return _IMP_core.CombineProvenance___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(CombineProvenance self, CombineProvenance o) -> bool
        __ne__(CombineProvenance self, Particle d) -> bool
        """
        return _IMP_core.CombineProvenance___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(CombineProvenance self, CombineProvenance o) -> bool
        __le__(CombineProvenance self, Particle d) -> bool
        """
        return _IMP_core.CombineProvenance___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(CombineProvenance self, CombineProvenance o) -> bool
        __lt__(CombineProvenance self, Particle d) -> bool
        """
        return _IMP_core.CombineProvenance___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(CombineProvenance self, CombineProvenance o) -> bool
        __ge__(CombineProvenance self, Particle d) -> bool
        """
        return _IMP_core.CombineProvenance___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(CombineProvenance self, CombineProvenance o) -> bool
        __gt__(CombineProvenance self, Particle d) -> bool
        """
        return _IMP_core.CombineProvenance___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(CombineProvenance self) -> std::size_t"""
        return _IMP_core.CombineProvenance___hash__(self)

    def __str__(self):
        r"""__str__(CombineProvenance self) -> std::string"""
        return _IMP_core.CombineProvenance___str__(self)

    def __repr__(self):
        r"""__repr__(CombineProvenance self) -> std::string"""
        return _IMP_core.CombineProvenance___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(CombineProvenance self) -> PyObject *"""
        return _IMP_core.CombineProvenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(CombineProvenance self, PyObject * p)"""
        return _IMP_core.CombineProvenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_CombineProvenance

# Register CombineProvenance in _IMP_core:
_IMP_core.CombineProvenance_swigregister(CombineProvenance)
class FilterProvenance(Provenance):
    r"""Proxy of C++ IMP::core::FilterProvenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def set_method(self, method):
        r"""set_method(FilterProvenance self, std::string method)"""
        return _IMP_core.FilterProvenance_set_method(self, method)

    def get_method(self):
        r"""get_method(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance_get_method(self)

    def set_number_of_frames(self, frames):
        r"""set_number_of_frames(FilterProvenance self, int frames)"""
        return _IMP_core.FilterProvenance_set_number_of_frames(self, frames)

    def get_number_of_frames(self):
        r"""get_number_of_frames(FilterProvenance self) -> int"""
        return _IMP_core.FilterProvenance_get_number_of_frames(self)

    def set_threshold(self, threshold):
        r"""set_threshold(FilterProvenance self, double threshold)"""
        return _IMP_core.FilterProvenance_set_threshold(self, threshold)

    def get_threshold(self):
        r"""get_threshold(FilterProvenance self) -> double"""
        return _IMP_core.FilterProvenance_get_threshold(self)

    def __init__(self, *args):
        r"""
        __init__(FilterProvenance self) -> FilterProvenance
        __init__(FilterProvenance self, Model m, ParticleIndex id) -> FilterProvenance
        __init__(FilterProvenance self, _ParticleAdaptor d) -> FilterProvenance
        """
        _IMP_core.FilterProvenance_swiginit(self, _IMP_core.new_FilterProvenance(*args))

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_core.FilterProvenance_get_is_setup(*args)

    def show(self, *args):
        r"""show(FilterProvenance self, _ostream out=std::cout)"""
        return _IMP_core.FilterProvenance_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, std::string method, double threshold, int frames) -> FilterProvenance
        setup_particle(_ParticleAdaptor pa, std::string method, double threshold, int frames) -> FilterProvenance
        setup_particle(Model m, ParticleIndex pi, FilterProvenance o) -> FilterProvenance
        setup_particle(_ParticleAdaptor pa, FilterProvenance o) -> FilterProvenance
        """
        return _IMP_core.FilterProvenance_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(FilterProvenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(FilterProvenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(FilterProvenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(FilterProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.FilterProvenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(FilterProvenance self, SparseFloatKey a0) -> IMP::Float
        get_value(FilterProvenance self, SparseIntKey a0) -> IMP::Int
        get_value(FilterProvenance self, SparseStringKey a0) -> IMP::String
        get_value(FilterProvenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.FilterProvenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(FilterProvenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(FilterProvenance self, SparseIntKey a0, IMP::Int a1)
        set_value(FilterProvenance self, SparseStringKey a0, IMP::String a1)
        set_value(FilterProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.FilterProvenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(FilterProvenance self, SparseFloatKey a0)
        remove_attribute(FilterProvenance self, SparseIntKey a0)
        remove_attribute(FilterProvenance self, SparseStringKey a0)
        remove_attribute(FilterProvenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.FilterProvenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(FilterProvenance self, SparseFloatKey a0) -> bool
        has_attribute(FilterProvenance self, SparseIntKey a0) -> bool
        has_attribute(FilterProvenance self, SparseStringKey a0) -> bool
        has_attribute(FilterProvenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.FilterProvenance_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(FilterProvenance self, FloatKey a0) -> double"""
        return _IMP_core.FilterProvenance_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance_get_name(self)

    def clear_caches(self):
        r"""clear_caches(FilterProvenance self)"""
        return _IMP_core.FilterProvenance_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(FilterProvenance self, std::string a0)"""
        return _IMP_core.FilterProvenance_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(FilterProvenance self, FloatKey a0) -> bool"""
        return _IMP_core.FilterProvenance_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(FilterProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.FilterProvenance_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(FilterProvenance self, FilterProvenance o) -> bool
        __eq__(FilterProvenance self, Particle d) -> bool
        """
        return _IMP_core.FilterProvenance___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(FilterProvenance self, FilterProvenance o) -> bool
        __ne__(FilterProvenance self, Particle d) -> bool
        """
        return _IMP_core.FilterProvenance___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(FilterProvenance self, FilterProvenance o) -> bool
        __le__(FilterProvenance self, Particle d) -> bool
        """
        return _IMP_core.FilterProvenance___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(FilterProvenance self, FilterProvenance o) -> bool
        __lt__(FilterProvenance self, Particle d) -> bool
        """
        return _IMP_core.FilterProvenance___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(FilterProvenance self, FilterProvenance o) -> bool
        __ge__(FilterProvenance self, Particle d) -> bool
        """
        return _IMP_core.FilterProvenance___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(FilterProvenance self, FilterProvenance o) -> bool
        __gt__(FilterProvenance self, Particle d) -> bool
        """
        return _IMP_core.FilterProvenance___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(FilterProvenance self) -> std::size_t"""
        return _IMP_core.FilterProvenance___hash__(self)

    def __str__(self):
        r"""__str__(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance___str__(self)

    def __repr__(self):
        r"""__repr__(FilterProvenance self) -> std::string"""
        return _IMP_core.FilterProvenance___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(FilterProvenance self) -> PyObject *"""
        return _IMP_core.FilterProvenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(FilterProvenance self, PyObject * p)"""
        return _IMP_core.FilterProvenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_FilterProvenance

# Register FilterProvenance in _IMP_core:
_IMP_core.FilterProvenance_swigregister(FilterProvenance)
class ClusterProvenance(Provenance):
    r"""Proxy of C++ IMP::core::ClusterProvenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def set_number_of_members(self, members):
        r"""set_number_of_members(ClusterProvenance self, int members)"""
        return _IMP_core.ClusterProvenance_set_number_of_members(self, members)

    def get_number_of_members(self):
        r"""get_number_of_members(ClusterProvenance self) -> int"""
        return _IMP_core.ClusterProvenance_get_number_of_members(self)

    def set_precision(self, precision):
        r"""set_precision(ClusterProvenance self, double precision)"""
        return _IMP_core.ClusterProvenance_set_precision(self, precision)

    def get_precision(self):
        r"""get_precision(ClusterProvenance self) -> double"""
        return _IMP_core.ClusterProvenance_get_precision(self)

    def set_density(self, density):
        r"""set_density(ClusterProvenance self, std::string density)"""
        return _IMP_core.ClusterProvenance_set_density(self, density)

    def get_density(self):
        r"""get_density(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance_get_density(self)

    def __init__(self, *args):
        r"""
        __init__(ClusterProvenance self) -> ClusterProvenance
        __init__(ClusterProvenance self, Model m, ParticleIndex id) -> ClusterProvenance
        __init__(ClusterProvenance self, _ParticleAdaptor d) -> ClusterProvenance
        """
        _IMP_core.ClusterProvenance_swiginit(self, _IMP_core.new_ClusterProvenance(*args))

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_core.ClusterProvenance_get_is_setup(*args)

    def show(self, *args):
        r"""show(ClusterProvenance self, _ostream out=std::cout)"""
        return _IMP_core.ClusterProvenance_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, int members) -> ClusterProvenance
        setup_particle(_ParticleAdaptor pa, int members) -> ClusterProvenance
        setup_particle(Model m, ParticleIndex pi, int members, double precision) -> ClusterProvenance
        setup_particle(_ParticleAdaptor pa, int members, double precision) -> ClusterProvenance
        setup_particle(Model m, ParticleIndex pi, int members, double precision, std::string density) -> ClusterProvenance
        setup_particle(_ParticleAdaptor pa, int members, double precision, std::string density) -> ClusterProvenance
        setup_particle(Model m, ParticleIndex pi, ClusterProvenance o) -> ClusterProvenance
        setup_particle(_ParticleAdaptor pa, ClusterProvenance o) -> ClusterProvenance
        """
        return _IMP_core.ClusterProvenance_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(ClusterProvenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(ClusterProvenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(ClusterProvenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(ClusterProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.ClusterProvenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(ClusterProvenance self, SparseFloatKey a0) -> IMP::Float
        get_value(ClusterProvenance self, SparseIntKey a0) -> IMP::Int
        get_value(ClusterProvenance self, SparseStringKey a0) -> IMP::String
        get_value(ClusterProvenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.ClusterProvenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(ClusterProvenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(ClusterProvenance self, SparseIntKey a0, IMP::Int a1)
        set_value(ClusterProvenance self, SparseStringKey a0, IMP::String a1)
        set_value(ClusterProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.ClusterProvenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(ClusterProvenance self, SparseFloatKey a0)
        remove_attribute(ClusterProvenance self, SparseIntKey a0)
        remove_attribute(ClusterProvenance self, SparseStringKey a0)
        remove_attribute(ClusterProvenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.ClusterProvenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(ClusterProvenance self, SparseFloatKey a0) -> bool
        has_attribute(ClusterProvenance self, SparseIntKey a0) -> bool
        has_attribute(ClusterProvenance self, SparseStringKey a0) -> bool
        has_attribute(ClusterProvenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.ClusterProvenance_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(ClusterProvenance self, FloatKey a0) -> double"""
        return _IMP_core.ClusterProvenance_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance_get_name(self)

    def clear_caches(self):
        r"""clear_caches(ClusterProvenance self)"""
        return _IMP_core.ClusterProvenance_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(ClusterProvenance self, std::string a0)"""
        return _IMP_core.ClusterProvenance_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(ClusterProvenance self, FloatKey a0) -> bool"""
        return _IMP_core.ClusterProvenance_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(ClusterProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.ClusterProvenance_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(ClusterProvenance self, ClusterProvenance o) -> bool
        __eq__(ClusterProvenance self, Particle d) -> bool
        """
        return _IMP_core.ClusterProvenance___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(ClusterProvenance self, ClusterProvenance o) -> bool
        __ne__(ClusterProvenance self, Particle d) -> bool
        """
        return _IMP_core.ClusterProvenance___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(ClusterProvenance self, ClusterProvenance o) -> bool
        __le__(ClusterProvenance self, Particle d) -> bool
        """
        return _IMP_core.ClusterProvenance___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(ClusterProvenance self, ClusterProvenance o) -> bool
        __lt__(ClusterProvenance self, Particle d) -> bool
        """
        return _IMP_core.ClusterProvenance___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(ClusterProvenance self, ClusterProvenance o) -> bool
        __ge__(ClusterProvenance self, Particle d) -> bool
        """
        return _IMP_core.ClusterProvenance___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(ClusterProvenance self, ClusterProvenance o) -> bool
        __gt__(ClusterProvenance self, Particle d) -> bool
        """
        return _IMP_core.ClusterProvenance___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(ClusterProvenance self) -> std::size_t"""
        return _IMP_core.ClusterProvenance___hash__(self)

    def __str__(self):
        r"""__str__(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance___str__(self)

    def __repr__(self):
        r"""__repr__(ClusterProvenance self) -> std::string"""
        return _IMP_core.ClusterProvenance___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ClusterProvenance self) -> PyObject *"""
        return _IMP_core.ClusterProvenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ClusterProvenance self, PyObject * p)"""
        return _IMP_core.ClusterProvenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_ClusterProvenance

# Register ClusterProvenance in _IMP_core:
_IMP_core.ClusterProvenance_swigregister(ClusterProvenance)
class ScriptProvenance(Provenance):
    r"""Proxy of C++ IMP::core::ScriptProvenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def set_filename(self, filename):
        r"""set_filename(ScriptProvenance self, std::string filename)"""
        return _IMP_core.ScriptProvenance_set_filename(self, filename)

    def get_filename(self):
        r"""get_filename(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance_get_filename(self)

    def __init__(self, *args):
        r"""
        __init__(ScriptProvenance self) -> ScriptProvenance
        __init__(ScriptProvenance self, Model m, ParticleIndex id) -> ScriptProvenance
        __init__(ScriptProvenance self, _ParticleAdaptor d) -> ScriptProvenance
        """
        _IMP_core.ScriptProvenance_swiginit(self, _IMP_core.new_ScriptProvenance(*args))

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_core.ScriptProvenance_get_is_setup(*args)

    def show(self, *args):
        r"""show(ScriptProvenance self, _ostream out=std::cout)"""
        return _IMP_core.ScriptProvenance_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, std::string filename) -> ScriptProvenance
        setup_particle(_ParticleAdaptor pa, std::string filename) -> ScriptProvenance
        setup_particle(Model m, ParticleIndex pi, ScriptProvenance o) -> ScriptProvenance
        setup_particle(_ParticleAdaptor pa, ScriptProvenance o) -> ScriptProvenance
        """
        return _IMP_core.ScriptProvenance_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(ScriptProvenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(ScriptProvenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(ScriptProvenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(ScriptProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.ScriptProvenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(ScriptProvenance self, SparseFloatKey a0) -> IMP::Float
        get_value(ScriptProvenance self, SparseIntKey a0) -> IMP::Int
        get_value(ScriptProvenance self, SparseStringKey a0) -> IMP::String
        get_value(ScriptProvenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.ScriptProvenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(ScriptProvenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(ScriptProvenance self, SparseIntKey a0, IMP::Int a1)
        set_value(ScriptProvenance self, SparseStringKey a0, IMP::String a1)
        set_value(ScriptProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.ScriptProvenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(ScriptProvenance self, SparseFloatKey a0)
        remove_attribute(ScriptProvenance self, SparseIntKey a0)
        remove_attribute(ScriptProvenance self, SparseStringKey a0)
        remove_attribute(ScriptProvenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.ScriptProvenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(ScriptProvenance self, SparseFloatKey a0) -> bool
        has_attribute(ScriptProvenance self, SparseIntKey a0) -> bool
        has_attribute(ScriptProvenance self, SparseStringKey a0) -> bool
        has_attribute(ScriptProvenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.ScriptProvenance_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(ScriptProvenance self, FloatKey a0) -> double"""
        return _IMP_core.ScriptProvenance_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance_get_name(self)

    def clear_caches(self):
        r"""clear_caches(ScriptProvenance self)"""
        return _IMP_core.ScriptProvenance_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(ScriptProvenance self, std::string a0)"""
        return _IMP_core.ScriptProvenance_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(ScriptProvenance self, FloatKey a0) -> bool"""
        return _IMP_core.ScriptProvenance_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(ScriptProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.ScriptProvenance_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(ScriptProvenance self, ScriptProvenance o) -> bool
        __eq__(ScriptProvenance self, Particle d) -> bool
        """
        return _IMP_core.ScriptProvenance___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(ScriptProvenance self, ScriptProvenance o) -> bool
        __ne__(ScriptProvenance self, Particle d) -> bool
        """
        return _IMP_core.ScriptProvenance___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(ScriptProvenance self, ScriptProvenance o) -> bool
        __le__(ScriptProvenance self, Particle d) -> bool
        """
        return _IMP_core.ScriptProvenance___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(ScriptProvenance self, ScriptProvenance o) -> bool
        __lt__(ScriptProvenance self, Particle d) -> bool
        """
        return _IMP_core.ScriptProvenance___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(ScriptProvenance self, ScriptProvenance o) -> bool
        __ge__(ScriptProvenance self, Particle d) -> bool
        """
        return _IMP_core.ScriptProvenance___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(ScriptProvenance self, ScriptProvenance o) -> bool
        __gt__(ScriptProvenance self, Particle d) -> bool
        """
        return _IMP_core.ScriptProvenance___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(ScriptProvenance self) -> std::size_t"""
        return _IMP_core.ScriptProvenance___hash__(self)

    def __str__(self):
        r"""__str__(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance___str__(self)

    def __repr__(self):
        r"""__repr__(ScriptProvenance self) -> std::string"""
        return _IMP_core.ScriptProvenance___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ScriptProvenance self) -> PyObject *"""
        return _IMP_core.ScriptProvenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ScriptProvenance self, PyObject * p)"""
        return _IMP_core.ScriptProvenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_ScriptProvenance

# Register ScriptProvenance in _IMP_core:
_IMP_core.ScriptProvenance_swigregister(ScriptProvenance)
class SoftwareProvenance(Provenance):
    r"""Proxy of C++ IMP::core::SoftwareProvenance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def set_software_name(self, name):
        r"""set_software_name(SoftwareProvenance self, std::string name)"""
        return _IMP_core.SoftwareProvenance_set_software_name(self, name)

    def get_software_name(self):
        r"""get_software_name(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_software_name(self)

    def set_version(self, version):
        r"""set_version(SoftwareProvenance self, std::string version)"""
        return _IMP_core.SoftwareProvenance_set_version(self, version)

    def get_version(self):
        r"""get_version(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_version(self)

    def set_location(self, location):
        r"""set_location(SoftwareProvenance self, std::string location)"""
        return _IMP_core.SoftwareProvenance_set_location(self, location)

    def get_location(self):
        r"""get_location(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_location(self)

    def __init__(self, *args):
        r"""
        __init__(SoftwareProvenance self) -> SoftwareProvenance
        __init__(SoftwareProvenance self, Model m, ParticleIndex id) -> SoftwareProvenance
        __init__(SoftwareProvenance self, _ParticleAdaptor d) -> SoftwareProvenance
        """
        _IMP_core.SoftwareProvenance_swiginit(self, _IMP_core.new_SoftwareProvenance(*args))

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_core.SoftwareProvenance_get_is_setup(*args)

    def show(self, *args):
        r"""show(SoftwareProvenance self, _ostream out=std::cout)"""
        return _IMP_core.SoftwareProvenance_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, std::string name, std::string version, std::string location) -> SoftwareProvenance
        setup_particle(_ParticleAdaptor pa, std::string name, std::string version, std::string location) -> SoftwareProvenance
        setup_particle(Model m, ParticleIndex pi, SoftwareProvenance o) -> SoftwareProvenance
        setup_particle(_ParticleAdaptor pa, SoftwareProvenance o) -> SoftwareProvenance
        """
        return _IMP_core.SoftwareProvenance_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(SoftwareProvenance self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(SoftwareProvenance self, SparseIntKey a0, IMP::Int a1)
        add_attribute(SoftwareProvenance self, SparseStringKey a0, IMP::String a1)
        add_attribute(SoftwareProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.SoftwareProvenance_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(SoftwareProvenance self, SparseFloatKey a0) -> IMP::Float
        get_value(SoftwareProvenance self, SparseIntKey a0) -> IMP::Int
        get_value(SoftwareProvenance self, SparseStringKey a0) -> IMP::String
        get_value(SoftwareProvenance self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.SoftwareProvenance_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(SoftwareProvenance self, SparseFloatKey a0, IMP::Float a1)
        set_value(SoftwareProvenance self, SparseIntKey a0, IMP::Int a1)
        set_value(SoftwareProvenance self, SparseStringKey a0, IMP::String a1)
        set_value(SoftwareProvenance self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.SoftwareProvenance_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(SoftwareProvenance self, SparseFloatKey a0)
        remove_attribute(SoftwareProvenance self, SparseIntKey a0)
        remove_attribute(SoftwareProvenance self, SparseStringKey a0)
        remove_attribute(SoftwareProvenance self, SparseParticleIndexKey a0)
        """
        return _IMP_core.SoftwareProvenance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(SoftwareProvenance self, SparseFloatKey a0) -> bool
        has_attribute(SoftwareProvenance self, SparseIntKey a0) -> bool
        has_attribute(SoftwareProvenance self, SparseStringKey a0) -> bool
        has_attribute(SoftwareProvenance self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.SoftwareProvenance_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(SoftwareProvenance self, FloatKey a0) -> double"""
        return _IMP_core.SoftwareProvenance_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance_get_name(self)

    def clear_caches(self):
        r"""clear_caches(SoftwareProvenance self)"""
        return _IMP_core.SoftwareProvenance_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(SoftwareProvenance self, std::string a0)"""
        return _IMP_core.SoftwareProvenance_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(SoftwareProvenance self, FloatKey a0) -> bool"""
        return _IMP_core.SoftwareProvenance_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(SoftwareProvenance self) -> IMP::CheckLevel"""
        return _IMP_core.SoftwareProvenance_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(SoftwareProvenance self, SoftwareProvenance o) -> bool
        __eq__(SoftwareProvenance self, Particle d) -> bool
        """
        return _IMP_core.SoftwareProvenance___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(SoftwareProvenance self, SoftwareProvenance o) -> bool
        __ne__(SoftwareProvenance self, Particle d) -> bool
        """
        return _IMP_core.SoftwareProvenance___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(SoftwareProvenance self, SoftwareProvenance o) -> bool
        __le__(SoftwareProvenance self, Particle d) -> bool
        """
        return _IMP_core.SoftwareProvenance___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(SoftwareProvenance self, SoftwareProvenance o) -> bool
        __lt__(SoftwareProvenance self, Particle d) -> bool
        """
        return _IMP_core.SoftwareProvenance___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(SoftwareProvenance self, SoftwareProvenance o) -> bool
        __ge__(SoftwareProvenance self, Particle d) -> bool
        """
        return _IMP_core.SoftwareProvenance___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(SoftwareProvenance self, SoftwareProvenance o) -> bool
        __gt__(SoftwareProvenance self, Particle d) -> bool
        """
        return _IMP_core.SoftwareProvenance___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(SoftwareProvenance self) -> std::size_t"""
        return _IMP_core.SoftwareProvenance___hash__(self)

    def __str__(self):
        r"""__str__(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance___str__(self)

    def __repr__(self):
        r"""__repr__(SoftwareProvenance self) -> std::string"""
        return _IMP_core.SoftwareProvenance___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(SoftwareProvenance self) -> PyObject *"""
        return _IMP_core.SoftwareProvenance__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SoftwareProvenance self, PyObject * p)"""
        return _IMP_core.SoftwareProvenance__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_SoftwareProvenance

# Register SoftwareProvenance in _IMP_core:
_IMP_core.SoftwareProvenance_swigregister(SoftwareProvenance)
class Provenanced(IMP.Decorator):
    r"""Proxy of C++ IMP::core::Provenanced class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def get_provenance(self):
        r"""get_provenance(Provenanced self) -> Provenance"""
        return _IMP_core.Provenanced_get_provenance(self)

    def set_provenance(self, p):
        r"""set_provenance(Provenanced self, Provenance p)"""
        return _IMP_core.Provenanced_set_provenance(self, p)

    def __init__(self, *args):
        r"""
        __init__(Provenanced self) -> Provenanced
        __init__(Provenanced self, Model m, ParticleIndex id) -> Provenanced
        __init__(Provenanced self, _ParticleAdaptor d) -> Provenanced
        """
        _IMP_core.Provenanced_swiginit(self, _IMP_core.new_Provenanced(*args))

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_core.Provenanced_get_is_setup(*args)

    def show(self, *args):
        r"""show(Provenanced self, _ostream out=std::cout)"""
        return _IMP_core.Provenanced_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, Provenance p) -> Provenanced
        setup_particle(_ParticleAdaptor pa, Provenance p) -> Provenanced
        """
        return _IMP_core.Provenanced_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        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)
        add_attribute(Provenanced self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(Provenanced self, SparseIntKey a0, IMP::Int a1)
        add_attribute(Provenanced self, SparseStringKey a0, IMP::String a1)
        add_attribute(Provenanced self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Provenanced_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        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
        get_value(Provenanced self, SparseFloatKey a0) -> IMP::Float
        get_value(Provenanced self, SparseIntKey a0) -> IMP::Int
        get_value(Provenanced self, SparseStringKey a0) -> IMP::String
        get_value(Provenanced self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_core.Provenanced_get_value(self, *args)

    def set_value(self, *args):
        r"""
        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)
        set_value(Provenanced self, SparseFloatKey a0, IMP::Float a1)
        set_value(Provenanced self, SparseIntKey a0, IMP::Int a1)
        set_value(Provenanced self, SparseStringKey a0, IMP::String a1)
        set_value(Provenanced self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_core.Provenanced_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        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)
        remove_attribute(Provenanced self, SparseFloatKey a0)
        remove_attribute(Provenanced self, SparseIntKey a0)
        remove_attribute(Provenanced self, SparseStringKey a0)
        remove_attribute(Provenanced self, SparseParticleIndexKey a0)
        """
        return _IMP_core.Provenanced_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        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
        has_attribute(Provenanced self, SparseFloatKey a0) -> bool
        has_attribute(Provenanced self, SparseIntKey a0) -> bool
        has_attribute(Provenanced self, SparseStringKey a0) -> bool
        has_attribute(Provenanced self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_core.Provenanced_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(Provenanced self, FloatKey a0) -> double"""
        return _IMP_core.Provenanced_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(Provenanced self) -> std::string"""
        return _IMP_core.Provenanced_get_name(self)

    def clear_caches(self):
        r"""clear_caches(Provenanced self)"""
        return _IMP_core.Provenanced_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(Provenanced self, std::string a0)"""
        return _IMP_core.Provenanced_set_name(self, a0)

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Provenanced self, FloatKey a0) -> bool"""
        return _IMP_core.Provenanced_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(Provenanced self) -> IMP::CheckLevel"""
        return _IMP_core.Provenanced_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(Provenanced self, Provenanced o) -> bool
        __eq__(Provenanced self, Particle d) -> bool
        """
        return _IMP_core.Provenanced___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(Provenanced self, Provenanced o) -> bool
        __ne__(Provenanced self, Particle d) -> bool
        """
        return _IMP_core.Provenanced___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(Provenanced self, Provenanced o) -> bool
        __le__(Provenanced self, Particle d) -> bool
        """
        return _IMP_core.Provenanced___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(Provenanced self, Provenanced o) -> bool
        __lt__(Provenanced self, Particle d) -> bool
        """
        return _IMP_core.Provenanced___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(Provenanced self, Provenanced o) -> bool
        __ge__(Provenanced self, Particle d) -> bool
        """
        return _IMP_core.Provenanced___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(Provenanced self, Provenanced o) -> bool
        __gt__(Provenanced self, Particle d) -> bool
        """
        return _IMP_core.Provenanced___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(Provenanced self) -> std::size_t"""
        return _IMP_core.Provenanced___hash__(self)

    def __str__(self):
        r"""__str__(Provenanced self) -> std::string"""
        return _IMP_core.Provenanced___str__(self)

    def __repr__(self):
        r"""__repr__(Provenanced self) -> std::string"""
        return _IMP_core.Provenanced___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Provenanced self) -> PyObject *"""
        return _IMP_core.Provenanced__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Provenanced self, PyObject * p)"""
        return _IMP_core.Provenanced__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_core.delete_Provenanced

# Register Provenanced in _IMP_core:
_IMP_core.Provenanced_swigregister(Provenanced)

def add_provenance(m, pi, p):
    r"""add_provenance(Model m, ParticleIndex pi, Provenance p)"""
    return _IMP_core.add_provenance(m, pi, p)

def create_clone(p):
    r"""create_clone(Provenance p) -> Provenance"""
    return _IMP_core.create_clone(p)

def get_transformation_aligning_first_to_second(*args):
    r"""
    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 >,std::allocator< IMP::algebra::VectorD< 3 > > > const & b) -> Transformation3D
    get_transformation_aligning_first_to_second(IMP::Vector< IMP::algebra::VectorD< 3 >,std::allocator< 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):
    r"""create_restraint(PairScore ps, IMP::ParticlePair pp) -> Restraint"""
    return _IMP_core.create_restraint(ps, pp)
class TruncatedHarmonicLowerBound(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::TruncatedHarmonic< IMP::core::LOWER > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(TruncatedHarmonicLowerBound self, IMP::Float center, IMP::Float k, IMP::Float threshold, IMP::Float limit) -> TruncatedHarmonicLowerBound
        __init__(TruncatedHarmonicLowerBound self, IMP::Float center, IMP::Float k, IMP::Float threshold) -> TruncatedHarmonicLowerBound
        """
        _IMP_core.TruncatedHarmonicLowerBound_swiginit(self, _IMP_core.new_TruncatedHarmonicLowerBound(*args))

    def get_version_info(self):
        r"""get_version_info(TruncatedHarmonicLowerBound self) -> VersionInfo"""
        return _IMP_core.TruncatedHarmonicLowerBound_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TruncatedHarmonicLowerBound

    def __str__(self):
        r"""__str__(TruncatedHarmonicLowerBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicLowerBound___str__(self)

    def __repr__(self):
        r"""__repr__(TruncatedHarmonicLowerBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicLowerBound___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_TruncatedHarmonic(o)


# Register TruncatedHarmonicLowerBound in _IMP_core:
_IMP_core.TruncatedHarmonicLowerBound_swigregister(TruncatedHarmonicLowerBound)
class TruncatedHarmonicUpperBound(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::TruncatedHarmonic< IMP::core::UPPER > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(TruncatedHarmonicUpperBound self, IMP::Float center, IMP::Float k, IMP::Float threshold, IMP::Float limit) -> TruncatedHarmonicUpperBound
        __init__(TruncatedHarmonicUpperBound self, IMP::Float center, IMP::Float k, IMP::Float threshold) -> TruncatedHarmonicUpperBound
        """
        _IMP_core.TruncatedHarmonicUpperBound_swiginit(self, _IMP_core.new_TruncatedHarmonicUpperBound(*args))

    def get_version_info(self):
        r"""get_version_info(TruncatedHarmonicUpperBound self) -> VersionInfo"""
        return _IMP_core.TruncatedHarmonicUpperBound_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TruncatedHarmonicUpperBound

    def __str__(self):
        r"""__str__(TruncatedHarmonicUpperBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicUpperBound___str__(self)

    def __repr__(self):
        r"""__repr__(TruncatedHarmonicUpperBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicUpperBound___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_TruncatedHarmonic(o)


# Register TruncatedHarmonicUpperBound in _IMP_core:
_IMP_core.TruncatedHarmonicUpperBound_swigregister(TruncatedHarmonicUpperBound)
class TruncatedHarmonicBound(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::core::TruncatedHarmonic< IMP::core::BOTH > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(TruncatedHarmonicBound self, IMP::Float center, IMP::Float k, IMP::Float threshold, IMP::Float limit) -> TruncatedHarmonicBound
        __init__(TruncatedHarmonicBound self, IMP::Float center, IMP::Float k, IMP::Float threshold) -> TruncatedHarmonicBound
        """
        _IMP_core.TruncatedHarmonicBound_swiginit(self, _IMP_core.new_TruncatedHarmonicBound(*args))

    def get_version_info(self):
        r"""get_version_info(TruncatedHarmonicBound self) -> VersionInfo"""
        return _IMP_core.TruncatedHarmonicBound_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_TruncatedHarmonicBound

    def __str__(self):
        r"""__str__(TruncatedHarmonicBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicBound___str__(self)

    def __repr__(self):
        r"""__repr__(TruncatedHarmonicBound self) -> std::string"""
        return _IMP_core.TruncatedHarmonicBound___repr__(self)

    @staticmethod
    def get_from(o):
       return _object_cast_to_TruncatedHarmonic(o)


# Register TruncatedHarmonicBound in _IMP_core:
_IMP_core.TruncatedHarmonicBound_swigregister(TruncatedHarmonicBound)
class ParticleType(IMP._Value):
    r"""Proxy of C++ IMP::Key< 34897493 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ParticleType self) -> ParticleType
        __init__(ParticleType self, std::string const & c, bool is_implicit_add_permitted=True) -> ParticleType
        __init__(ParticleType self, unsigned int i) -> ParticleType
        """
        _IMP_core.ParticleType_swiginit(self, _IMP_core.new_ParticleType(*args))

    @staticmethod
    def add_key(sc):
        r"""add_key(std::string sc) -> unsigned int"""
        return _IMP_core.ParticleType_add_key(sc)

    @staticmethod
    def get_key_exists(sc):
        r"""get_key_exists(std::string sc) -> bool"""
        return _IMP_core.ParticleType_get_key_exists(sc)

    def get_string(self):
        r"""get_string(ParticleType self) -> std::string const"""
        return _IMP_core.ParticleType_get_string(self)

    def __cmp__(self, o):
        r"""__cmp__(ParticleType self, ParticleType o) -> int"""
        return _IMP_core.ParticleType___cmp__(self, o)

    def __eq__(self, o):
        r"""__eq__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___eq__(self, o)

    def __ne__(self, o):
        r"""__ne__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___ne__(self, o)

    def __lt__(self, o):
        r"""__lt__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___lt__(self, o)

    def __gt__(self, o):
        r"""__gt__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___gt__(self, o)

    def __ge__(self, o):
        r"""__ge__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___ge__(self, o)

    def __le__(self, o):
        r"""__le__(ParticleType self, ParticleType o) -> bool"""
        return _IMP_core.ParticleType___le__(self, o)

    def __hash__(self):
        r"""__hash__(ParticleType self) -> std::size_t"""
        return _IMP_core.ParticleType___hash__(self)

    def show(self, *args):
        r"""show(ParticleType self, _ostream out=std::cout)"""
        return _IMP_core.ParticleType_show(self, *args)

    @staticmethod
    def add_alias(old_key, new_name):
        r"""add_alias(ParticleType old_key, std::string new_name) -> ParticleType"""
        return _IMP_core.ParticleType_add_alias(old_key, new_name)

    @staticmethod
    def get_number_of_keys():
        r"""get_number_of_keys() -> unsigned int"""
        return _IMP_core.ParticleType_get_number_of_keys()

    def get_index(self):
        r"""get_index(ParticleType self) -> unsigned int"""
        return _IMP_core.ParticleType_get_index(self)

    @staticmethod
    def show_all(out):
        r"""show_all(_ostream out)"""
        return _IMP_core.ParticleType_show_all(out)

    @staticmethod
    def get_all_strings():
        r"""get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_core.ParticleType_get_all_strings()

    @staticmethod
    def get_number_unique():
        r"""get_number_unique() -> unsigned int"""
        return _IMP_core.ParticleType_get_number_unique()

    def __str__(self):
        r"""__str__(ParticleType self) -> std::string"""
        return _IMP_core.ParticleType___str__(self)

    def __repr__(self):
        r"""__repr__(ParticleType self) -> std::string"""
        return _IMP_core.ParticleType___repr__(self)
    __swig_destroy__ = _IMP_core.delete_ParticleType

# Register ParticleType in _IMP_core:
_IMP_core.ParticleType_swigregister(ParticleType)
class AttributeSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::core::GenericAttributeSingletonScore< UnaryFunction > class."""

    thisown = 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):
        r"""__init__(AttributeSingletonScore self, UnaryFunction f, FloatKey k) -> AttributeSingletonScore"""
        _IMP_core.AttributeSingletonScore_swiginit(self, _IMP_core.new_AttributeSingletonScore(f, k))

    def do_get_inputs(self, m, pis):
        r"""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):
        r"""get_unary_function(AttributeSingletonScore self) -> UnaryFunction"""
        return _IMP_core.AttributeSingletonScore_get_unary_function(self)

    def get_key(self):
        r"""get_key(AttributeSingletonScore self) -> FloatKey"""
        return _IMP_core.AttributeSingletonScore_get_key(self)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(AttributeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AttributeSingletonScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(AttributeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AttributeSingletonScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(AttributeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AttributeSingletonScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(AttributeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.AttributeSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(AttributeSingletonScore self) -> VersionInfo"""
        return _IMP_core.AttributeSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_AttributeSingletonScore

    @staticmethod
    def get_from(o):
       return _object_cast_to_AttributeSingletonScore(o)


    def _get_jax(self, m, indexes):
        def score_float_key(jm, key, uf):
            return uf(jm[key][indexes])

        def score_xyz_key(jm, xyz_index, uf):
            return uf(jm['xyz'][indexes, xyz_index])

        uf = self.get_unary_function().get_derived_object()._get_jax()
        key = self.get_key()
    # First 7 FloatKeys are reserved in IMP and have to be handled
    # specially
        if key.get_index() >= 7:
            need_keys = [key]
            f = functools.partial(score_float_key, key=key.get_string(), uf=uf)
        elif key == XYZR.get_radius_key():
            need_keys = []  # We already have the radius in the JAX model
            f = functools.partial(score_float_key, key='r', uf=uf)
        elif key in XYZ.get_xyz_keys():
            need_keys = []  # We already have coordinates in the JAX model
            xyz_index = XYZ.get_xyz_keys().index(key)
            f = functools.partial(score_xyz_key, xyz_index=xyz_index, uf=uf)
        else:
            raise NotImplementedError("No support for key %s" % key)
        return self._wrap_jax(m, f, keys=need_keys)


# Register AttributeSingletonScore in _IMP_core:
_IMP_core.AttributeSingletonScore_swigregister(AttributeSingletonScore)

def create_generic_attribute_singleton_score(uf, k):
    r"""create_generic_attribute_singleton_score(UnaryFunction uf, FloatKey k) -> AttributeSingletonScore"""
    return _IMP_core.create_generic_attribute_singleton_score(uf, k)
class BoundingBox3DSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::core::GenericBoundingBox3DSingletonScore< UnaryFunction > class."""

    thisown = 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):
        r"""__init__(BoundingBox3DSingletonScore self, UnaryFunction f, BoundingBox3D bb) -> BoundingBox3DSingletonScore"""
        _IMP_core.BoundingBox3DSingletonScore_swiginit(self, _IMP_core.new_BoundingBox3DSingletonScore(f, bb))

    def get_unary_function(self):
        r"""get_unary_function(BoundingBox3DSingletonScore self) -> UnaryFunction"""
        return _IMP_core.BoundingBox3DSingletonScore_get_unary_function(self)

    def get_bounding_box(self):
        r"""get_bounding_box(BoundingBox3DSingletonScore self) -> BoundingBox3D"""
        return _IMP_core.BoundingBox3DSingletonScore_get_bounding_box(self)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(BoundingBox3DSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_core.BoundingBox3DSingletonScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(BoundingBox3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingBox3DSingletonScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(BoundingBox3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingBox3DSingletonScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(BoundingBox3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingBox3DSingletonScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(BoundingBox3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingBox3DSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(BoundingBox3DSingletonScore self) -> VersionInfo"""
        return _IMP_core.BoundingBox3DSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_BoundingBox3DSingletonScore

    @staticmethod
    def get_from(o):
       return _object_cast_to_BoundingBox3DSingletonScore(o)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        def score(jm, box_min, box_max, uf):
            xyzs = jm['xyz'][indexes]
    # This calculates the distance and the score for every point,
    # even those inside the box. IMP just returns zero for points
    # inside the box, skipping the distance calculation.
    # The implementation here is *probably* faster on a GPU since
    # we reduce the use of conditionals, and JAX will likely skip
    # the sqrt if uf is a harmonic, but this should be benchmarked.
            drs = jnp.linalg.norm(
                xyzs - jnp.clip(xyzs, box_min, box_max), axis=1)
            return uf(drs)
        uf = self.get_unary_function().get_derived_object()
        bb = self.get_bounding_box()
        f = functools.partial(score, box_min=jnp.asarray(bb.get_corner(0)),
                              box_max=jnp.asarray(bb.get_corner(1)),
                              uf=uf._get_jax())
        return self._wrap_jax(m, f)


# Register BoundingBox3DSingletonScore in _IMP_core:
_IMP_core.BoundingBox3DSingletonScore_swigregister(BoundingBox3DSingletonScore)

def create_bounding_box_3d_singleton_score(f, bb):
    r"""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):
    r"""Proxy of C++ IMP::core::GenericBoundingSphere3DSingletonScore< UnaryFunction > class."""

    thisown = 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):
        r"""__init__(BoundingSphere3DSingletonScore self, UnaryFunction f, Sphere3D sphere) -> BoundingSphere3DSingletonScore"""
        _IMP_core.BoundingSphere3DSingletonScore_swiginit(self, _IMP_core.new_BoundingSphere3DSingletonScore(f, sphere))

    def do_get_inputs(self, m, pis):
        r"""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_unary_function(self):
        r"""get_unary_function(BoundingSphere3DSingletonScore self) -> UnaryFunction"""
        return _IMP_core.BoundingSphere3DSingletonScore_get_unary_function(self)

    def get_sphere(self):
        r"""get_sphere(BoundingSphere3DSingletonScore self) -> Sphere3D"""
        return _IMP_core.BoundingSphere3DSingletonScore_get_sphere(self)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(BoundingSphere3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingSphere3DSingletonScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(BoundingSphere3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingSphere3DSingletonScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(BoundingSphere3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingSphere3DSingletonScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(BoundingSphere3DSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.BoundingSphere3DSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(BoundingSphere3DSingletonScore self) -> VersionInfo"""
        return _IMP_core.BoundingSphere3DSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_BoundingSphere3DSingletonScore

    @staticmethod
    def get_from(o):
       return _object_cast_to_BoundingSphere3DSingletonScore(o)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        import jax.lax
        def score_with_radius(jm, inds, center, radius):
            xyzs = jm['xyz'][inds]
            radii = jm['r'][inds]
            drs = jnp.linalg.norm(xyzs - center) + radii - radius
            return jax.lax.select(drs < 0.000001, jnp.zeros_like(drs), uf(drs))
        def score_without_radius(jm, inds, center, radius):
            xyzs = jm['xyz'][inds]
            drs = jnp.linalg.norm(xyzs - center) - radius
            return jax.lax.select(drs < 0.000001, jnp.zeros_like(drs), uf(drs))
        without_radii_inds = []
        with_radii_inds = []
        for ind in indexes:
            if XYZR.get_is_setup(m, ind):
                with_radii_inds.append(ind)
            else:
                without_radii_inds.append(ind)
        without_radii_inds = jnp.asarray(without_radii_inds)
        with_radii_inds = jnp.asarray(with_radii_inds)
        uf = self.get_unary_function().get_derived_object()._get_jax()
        sphere = self.get_sphere()
        radius = sphere.get_radius()
        center = jnp.asarray(sphere.get_center())
        def score(jm):
            s = 0.
            if without_radii_inds.size > 0:
                s += score_without_radius(jm, without_radii_inds,
                                          center, radius)
            if with_radii_inds.size > 0:
                s += score_with_radius(jm, with_radii_inds, center, radius)
            return s
        return self._wrap_jax(m, score)


# Register BoundingSphere3DSingletonScore in _IMP_core:
_IMP_core.BoundingSphere3DSingletonScore_swigregister(BoundingSphere3DSingletonScore)

def create_bounding_sphere_3d_singleton_score(f, sphere):
    r"""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):
    r"""Proxy of C++ IMP::core::GenericDistanceToSingletonScore< UnaryFunction > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(DistanceToSingletonScore self, UnaryFunction f, Vector3D pt) -> DistanceToSingletonScore
        __init__(DistanceToSingletonScore self) -> DistanceToSingletonScore
        """
        _IMP_core.DistanceToSingletonScore_swiginit(self, _IMP_core.new_DistanceToSingletonScore(*args))

    def do_get_inputs(self, m, pis):
        r"""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_unary_function(self):
        r"""get_unary_function(DistanceToSingletonScore self) -> UnaryFunction"""
        return _IMP_core.DistanceToSingletonScore_get_unary_function(self)

    def get_point(self):
        r"""get_point(DistanceToSingletonScore self) -> Vector3D"""
        return _IMP_core.DistanceToSingletonScore_get_point(self)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(DistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.DistanceToSingletonScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(DistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.DistanceToSingletonScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(DistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_core.DistanceToSingletonScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(DistanceToSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_core.DistanceToSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(DistanceToSingletonScore self) -> VersionInfo"""
        return _IMP_core.DistanceToSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_core.delete_DistanceToSingletonScore

    @staticmethod
    def get_from(o):
       return _object_cast_to_DistanceToSingletonScore(o)


    def _get_as_binary(self):
        r"""_get_as_binary(DistanceToSingletonScore self) -> PyObject *"""
        return _IMP_core.DistanceToSingletonScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DistanceToSingletonScore self, PyObject * p)"""
        return _IMP_core.DistanceToSingletonScore__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


    def _get_jax(self, m, indexes):
        import jax.numpy as jnp
        def score(jm, point, uf):
            xyzs = jm['xyz'][indexes]
            drs = jnp.linalg.norm(xyzs - point, axis=1)
            return uf(drs)
        uf = self.get_unary_function().get_derived_object()
        f = functools.partial(score, point=jnp.array(self.get_point()),
                              uf=uf._get_jax())
        return self._wrap_jax(m, f)


# Register DistanceToSingletonScore in _IMP_core:
_IMP_core.DistanceToSingletonScore_swigregister(DistanceToSingletonScore)

def create_distance_to_singleton_score(f, pt):
    r"""create_distance_to_singleton_score(UnaryFunction f, Vector3D pt) -> DistanceToSingletonScore"""
    return _IMP_core.create_distance_to_singleton_score(f, pt)

class SphereDistancePairScore(_SphereDistancePairScore.__bases__[0]):
    def __init__(self, uf):
        if isinstance(uf, HarmonicUpperBound):
            p = HarmonicUpperBoundSphereDistancePairScore(
                    uf.get_mean(), uf.get_k())
        elif isinstance(uf, HarmonicLowerBound):
            if uf.get_mean() == 0.0:
                p = SoftSpherePairScore(uf.get_k())
            else:
                p = _SphereDistancePairScore(uf)
        elif isinstance(uf, Harmonic):
            p = HarmonicSphereDistancePairScore(
                    uf.get_mean(), uf.get_k())
        else:
            p = _SphereDistancePairScore(uf)
        self.__dict__['_proxied'] = p
    def __getattr__(self, key):
        return getattr(self._proxied, key)
    def __setattr__(self, key, val):
        return setattr(self._proxied, key, val)

    def __getstate__(self):
        return self.__dict__['_proxied']

    def __setstate__(self, p):
        self.__dict__['_proxied'] = p

    def _get_jax(self, *args, **kwargs):
        return self._proxied._get_jax(*args, **kwargs)

    @staticmethod
    def get_from(o):
        try:
            p = HarmonicUpperBoundSphereDistancePairScore.get_from(o)
        except ValueError:
            try:
                p = HarmonicSphereDistancePairScore.get_from(o)
            except ValueError:
                try:
                    p = SoftSpherePairScore.get_from(o)
                except ValueError:
                    p = _SphereDistancePairScore.get_from(o)
        obj = object.__new__(SphereDistancePairScore)
        obj.__dict__['_proxied'] = p
        return obj



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_name():
    r"""get_module_name() -> std::string const"""
    return _IMP_core.get_module_name()

def get_module_version():
    r"""get_module_version() -> std::string const"""
    return _IMP_core.get_module_version()

def get_example_path(fname):
    r"""get_example_path(std::string fname) -> std::string"""
    return _IMP_core.get_example_path(fname)

def get_data_path(fname):
    r"""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()