spb/__init__.py

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




from sys import version_info as _swig_python_version_info
import _IMP_spb

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_SPB_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_SPB_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_spb.delete_IMP_SPB_SwigPyIterator

    def value(self):
        r"""value(IMP_SPB_SwigPyIterator self) -> PyObject *"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(IMP_SPB_SwigPyIterator self, size_t n=1) -> IMP_SPB_SwigPyIterator"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(IMP_SPB_SwigPyIterator self, size_t n=1) -> IMP_SPB_SwigPyIterator"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(IMP_SPB_SwigPyIterator self, IMP_SPB_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(IMP_SPB_SwigPyIterator self, IMP_SPB_SwigPyIterator x) -> bool"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(IMP_SPB_SwigPyIterator self) -> IMP_SPB_SwigPyIterator"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_copy(self)

    def next(self):
        r"""next(IMP_SPB_SwigPyIterator self) -> PyObject *"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(IMP_SPB_SwigPyIterator self) -> PyObject *"""
        return _IMP_spb.IMP_SPB_SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(IMP_SPB_SwigPyIterator self) -> PyObject *"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(IMP_SPB_SwigPyIterator self, ptrdiff_t n) -> IMP_SPB_SwigPyIterator"""
        return _IMP_spb.IMP_SPB_SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(IMP_SPB_SwigPyIterator self, IMP_SPB_SwigPyIterator x) -> bool"""
        return _IMP_spb.IMP_SPB_SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(IMP_SPB_SwigPyIterator self, IMP_SPB_SwigPyIterator x) -> bool"""
        return _IMP_spb.IMP_SPB_SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(IMP_SPB_SwigPyIterator self, ptrdiff_t n) -> IMP_SPB_SwigPyIterator"""
        return _IMP_spb.IMP_SPB_SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(IMP_SPB_SwigPyIterator self, ptrdiff_t n) -> IMP_SPB_SwigPyIterator"""
        return _IMP_spb.IMP_SPB_SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(IMP_SPB_SwigPyIterator self, ptrdiff_t n) -> IMP_SPB_SwigPyIterator"""
        return _IMP_spb.IMP_SPB_SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(IMP_SPB_SwigPyIterator self, ptrdiff_t n) -> IMP_SPB_SwigPyIterator
        __sub__(IMP_SPB_SwigPyIterator self, IMP_SPB_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_spb.IMP_SPB_SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register IMP_SPB_SwigPyIterator in _IMP_spb:
_IMP_spb.IMP_SPB_SwigPyIterator_swigregister(IMP_SPB_SwigPyIterator)

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

IMP_DEBUG = _IMP_spb.IMP_DEBUG

IMP_RELEASE = _IMP_spb.IMP_RELEASE

IMP_SILENT = _IMP_spb.IMP_SILENT

IMP_PROGRESS = _IMP_spb.IMP_PROGRESS

IMP_TERSE = _IMP_spb.IMP_TERSE

IMP_VERBOSE = _IMP_spb.IMP_VERBOSE

IMP_MEMORY = _IMP_spb.IMP_MEMORY

IMP_NONE = _IMP_spb.IMP_NONE

IMP_USAGE = _IMP_spb.IMP_USAGE

IMP_INTERNAL = _IMP_spb.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_spb.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_spb.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_spb.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_spb.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_spb.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_spb.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_spb.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_spb.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_spb.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_spb.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_spb.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_spb._ostream_write(self, osa_buf)

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

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_spb.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_spb.IMP_CGAL_HAS_BOOST_SYSTEM

IMP_CGAL_HAS_NUMPY = _IMP_spb.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_spb.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_MPI_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_MPI_HAS_BOOST_FILESYSTEM

IMP_MPI_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_MPI_HAS_BOOST_PROGRAMOPTIONS

IMP_MPI_HAS_BOOST_RANDOM = _IMP_spb.IMP_MPI_HAS_BOOST_RANDOM

IMP_MPI_HAS_BOOST_SYSTEM = _IMP_spb.IMP_MPI_HAS_BOOST_SYSTEM

IMP_MPI_HAS_NUMPY = _IMP_spb.IMP_MPI_HAS_NUMPY

IMPMPI_SHOW_WARNINGS = _IMP_spb.IMPMPI_SHOW_WARNINGS

import IMP.mpi
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_spb.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_spb.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_spb.IMP_ALGEBRA_HAS_BOOST_SYSTEM

IMP_ALGEBRA_HAS_CGAL = _IMP_spb.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_spb.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_spb.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_spb.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_spb.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_spb.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_spb.IMP_DISPLAY_HAS_BOOST_SYSTEM

IMP_DISPLAY_HAS_CGAL = _IMP_spb.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_spb.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_spb.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_GSL_HAS_IMP_CGAL = _IMP_spb.IMP_GSL_HAS_IMP_CGAL

IMP_GSL_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_GSL_HAS_BOOST_FILESYSTEM

IMP_GSL_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_GSL_HAS_BOOST_PROGRAMOPTIONS

IMP_GSL_HAS_BOOST_RANDOM = _IMP_spb.IMP_GSL_HAS_BOOST_RANDOM

IMP_GSL_HAS_BOOST_SYSTEM = _IMP_spb.IMP_GSL_HAS_BOOST_SYSTEM

IMP_GSL_HAS_CGAL = _IMP_spb.IMP_GSL_HAS_CGAL

IMP_GSL_HAS_NUMPY = _IMP_spb.IMP_GSL_HAS_NUMPY

IMPGSL_SHOW_WARNINGS = _IMP_spb.IMPGSL_SHOW_WARNINGS

import IMP.gsl
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_spb.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_spb.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_spb.IMP_STATISTICS_HAS_IMP_CGAL

IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_spb.IMP_STATISTICS_HAS_BOOST_RANDOM

IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_spb.IMP_STATISTICS_HAS_BOOST_SYSTEM

IMP_STATISTICS_HAS_CGAL = _IMP_spb.IMP_STATISTICS_HAS_CGAL

IMP_STATISTICS_HAS_NUMPY = _IMP_spb.IMP_STATISTICS_HAS_NUMPY

IMPSTATISTICS_SHOW_WARNINGS = _IMP_spb.IMPSTATISTICS_SHOW_WARNINGS

import IMP.statistics
IMP_CORE_HAS_IMP_CGAL = _IMP_spb.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_spb.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_spb.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_BOOST_SYSTEM = _IMP_spb.IMP_CORE_HAS_BOOST_SYSTEM

IMP_CORE_HAS_CGAL = _IMP_spb.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_spb.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_spb.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_spb.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_spb.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_spb.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_spb.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_spb.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_spb.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_spb.IMP_CONTAINER_HAS_BOOST_SYSTEM

IMP_CONTAINER_HAS_CGAL = _IMP_spb.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_spb.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_spb.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_spb.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_spb.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_spb.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_spb.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
IMP_SYMMETRY_HAS_IMP_CGAL = _IMP_spb.IMP_SYMMETRY_HAS_IMP_CGAL

IMP_SYMMETRY_HAS_IMP_DISPLAY = _IMP_spb.IMP_SYMMETRY_HAS_IMP_DISPLAY

IMP_SYMMETRY_HAS_IMP_KERNEL = _IMP_spb.IMP_SYMMETRY_HAS_IMP_KERNEL

IMP_SYMMETRY_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_SYMMETRY_HAS_IMP_SCORE_FUNCTOR

IMP_SYMMETRY_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_SYMMETRY_HAS_BOOST_FILESYSTEM

IMP_SYMMETRY_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_SYMMETRY_HAS_BOOST_PROGRAMOPTIONS

IMP_SYMMETRY_HAS_BOOST_RANDOM = _IMP_spb.IMP_SYMMETRY_HAS_BOOST_RANDOM

IMP_SYMMETRY_HAS_BOOST_SYSTEM = _IMP_spb.IMP_SYMMETRY_HAS_BOOST_SYSTEM

IMP_SYMMETRY_HAS_CGAL = _IMP_spb.IMP_SYMMETRY_HAS_CGAL

IMP_SYMMETRY_HAS_HDF5 = _IMP_spb.IMP_SYMMETRY_HAS_HDF5

IMP_SYMMETRY_HAS_NUMPY = _IMP_spb.IMP_SYMMETRY_HAS_NUMPY

IMP_SYMMETRY_HAS_PYTHON_IHM = _IMP_spb.IMP_SYMMETRY_HAS_PYTHON_IHM

IMPSYMMETRY_SHOW_WARNINGS = _IMP_spb.IMPSYMMETRY_SHOW_WARNINGS

import IMP.symmetry
IMP_ATOM_HAS_IMP_CGAL = _IMP_spb.IMP_ATOM_HAS_IMP_CGAL

IMP_ATOM_HAS_IMP_KERNEL = _IMP_spb.IMP_ATOM_HAS_IMP_KERNEL

IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

IMP_ATOM_HAS_BOOST_RANDOM = _IMP_spb.IMP_ATOM_HAS_BOOST_RANDOM

IMP_ATOM_HAS_BOOST_REGEX = _IMP_spb.IMP_ATOM_HAS_BOOST_REGEX

IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_spb.IMP_ATOM_HAS_BOOST_SYSTEM

IMP_ATOM_HAS_CGAL = _IMP_spb.IMP_ATOM_HAS_CGAL

IMP_ATOM_HAS_HDF5 = _IMP_spb.IMP_ATOM_HAS_HDF5

IMP_ATOM_HAS_NUMPY = _IMP_spb.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_spb.IMP_ATOM_HAS_PYTHON_IHM

IMPATOM_SHOW_WARNINGS = _IMP_spb.IMPATOM_SHOW_WARNINGS

IMP_ATOM_TYPE_INDEX = _IMP_spb.IMP_ATOM_TYPE_INDEX

IMP_RESIDUE_TYPE_INDEX = _IMP_spb.IMP_RESIDUE_TYPE_INDEX

IMP_HIERARCHY_TYPE_INDEX = _IMP_spb.IMP_HIERARCHY_TYPE_INDEX

IMP_CHAIN_TYPE_INDEX = _IMP_spb.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_spb.IMP_EM_HAS_IMP_CGAL

IMP_EM_HAS_IMP_CONTAINER = _IMP_spb.IMP_EM_HAS_IMP_CONTAINER

IMP_EM_HAS_IMP_DISPLAY = _IMP_spb.IMP_EM_HAS_IMP_DISPLAY

IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_EM_HAS_IMP_SCORE_FUNCTOR

IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_EM_HAS_BOOST_FILESYSTEM

IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_EM_HAS_BOOST_PROGRAMOPTIONS

IMP_EM_HAS_BOOST_RANDOM = _IMP_spb.IMP_EM_HAS_BOOST_RANDOM

IMP_EM_HAS_BOOST_REGEX = _IMP_spb.IMP_EM_HAS_BOOST_REGEX

IMP_EM_HAS_BOOST_SYSTEM = _IMP_spb.IMP_EM_HAS_BOOST_SYSTEM

IMP_EM_HAS_CGAL = _IMP_spb.IMP_EM_HAS_CGAL

IMP_EM_HAS_HDF5 = _IMP_spb.IMP_EM_HAS_HDF5

IMP_EM_HAS_NUMPY = _IMP_spb.IMP_EM_HAS_NUMPY

IMP_EM_HAS_PYTHON_IHM = _IMP_spb.IMP_EM_HAS_PYTHON_IHM

IMPEM_SHOW_WARNINGS = _IMP_spb.IMPEM_SHOW_WARNINGS

import IMP.em
IMP_SAXS_HAS_IMP_CGAL = _IMP_spb.IMP_SAXS_HAS_IMP_CGAL

IMP_SAXS_HAS_IMP_CONTAINER = _IMP_spb.IMP_SAXS_HAS_IMP_CONTAINER

IMP_SAXS_HAS_IMP_DISPLAY = _IMP_spb.IMP_SAXS_HAS_IMP_DISPLAY

IMP_SAXS_HAS_IMP_KERNEL = _IMP_spb.IMP_SAXS_HAS_IMP_KERNEL

IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_SAXS_HAS_BOOST_FILESYSTEM

IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

IMP_SAXS_HAS_BOOST_RANDOM = _IMP_spb.IMP_SAXS_HAS_BOOST_RANDOM

IMP_SAXS_HAS_BOOST_REGEX = _IMP_spb.IMP_SAXS_HAS_BOOST_REGEX

IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_spb.IMP_SAXS_HAS_BOOST_SYSTEM

IMP_SAXS_HAS_CGAL = _IMP_spb.IMP_SAXS_HAS_CGAL

IMP_SAXS_HAS_HDF5 = _IMP_spb.IMP_SAXS_HAS_HDF5

IMP_SAXS_HAS_NUMPY = _IMP_spb.IMP_SAXS_HAS_NUMPY

IMP_SAXS_HAS_PYTHON_IHM = _IMP_spb.IMP_SAXS_HAS_PYTHON_IHM

IMPSAXS_SHOW_WARNINGS = _IMP_spb.IMPSAXS_SHOW_WARNINGS

import IMP.saxs
IMP_ISD_HAS_IMP_CGAL = _IMP_spb.IMP_ISD_HAS_IMP_CGAL

IMP_ISD_HAS_IMP_DISPLAY = _IMP_spb.IMP_ISD_HAS_IMP_DISPLAY

IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_ISD_HAS_IMP_SCORE_FUNCTOR

IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_ISD_HAS_BOOST_FILESYSTEM

IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS

IMP_ISD_HAS_BOOST_RANDOM = _IMP_spb.IMP_ISD_HAS_BOOST_RANDOM

IMP_ISD_HAS_BOOST_REGEX = _IMP_spb.IMP_ISD_HAS_BOOST_REGEX

IMP_ISD_HAS_BOOST_SYSTEM = _IMP_spb.IMP_ISD_HAS_BOOST_SYSTEM

IMP_ISD_HAS_CGAL = _IMP_spb.IMP_ISD_HAS_CGAL

IMP_ISD_HAS_HDF5 = _IMP_spb.IMP_ISD_HAS_HDF5

IMP_ISD_HAS_NUMPY = _IMP_spb.IMP_ISD_HAS_NUMPY

IMP_ISD_HAS_PYTHON_IHM = _IMP_spb.IMP_ISD_HAS_PYTHON_IHM

IMPISD_SHOW_WARNINGS = _IMP_spb.IMPISD_SHOW_WARNINGS

import IMP.isd
IMP_RMF_HAS_IMP_CGAL = _IMP_spb.IMP_RMF_HAS_IMP_CGAL

IMP_RMF_HAS_IMP_EM = _IMP_spb.IMP_RMF_HAS_IMP_EM

IMP_RMF_HAS_IMP_SAXS = _IMP_spb.IMP_RMF_HAS_IMP_SAXS

IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_RMF_HAS_IMP_SCORE_FUNCTOR

IMP_RMF_HAS_IMP_STATISTICS = _IMP_spb.IMP_RMF_HAS_IMP_STATISTICS

IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_RMF_HAS_BOOST_FILESYSTEM

IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS

IMP_RMF_HAS_BOOST_RANDOM = _IMP_spb.IMP_RMF_HAS_BOOST_RANDOM

IMP_RMF_HAS_BOOST_REGEX = _IMP_spb.IMP_RMF_HAS_BOOST_REGEX

IMP_RMF_HAS_BOOST_SYSTEM = _IMP_spb.IMP_RMF_HAS_BOOST_SYSTEM

IMP_RMF_HAS_CGAL = _IMP_spb.IMP_RMF_HAS_CGAL

IMP_RMF_HAS_HDF5 = _IMP_spb.IMP_RMF_HAS_HDF5

IMP_RMF_HAS_NUMPY = _IMP_spb.IMP_RMF_HAS_NUMPY

IMP_RMF_HAS_PYTHON_IHM = _IMP_spb.IMP_RMF_HAS_PYTHON_IHM

IMPRMF_SHOW_WARNINGS = _IMP_spb.IMPRMF_SHOW_WARNINGS

import IMP.rmf
import RMF
IMP_DOMINO_HAS_IMP_ATOM = _IMP_spb.IMP_DOMINO_HAS_IMP_ATOM

IMP_DOMINO_HAS_IMP_CGAL = _IMP_spb.IMP_DOMINO_HAS_IMP_CGAL

IMP_DOMINO_HAS_IMP_EM = _IMP_spb.IMP_DOMINO_HAS_IMP_EM

IMP_DOMINO_HAS_IMP_ISD = _IMP_spb.IMP_DOMINO_HAS_IMP_ISD

IMP_DOMINO_HAS_IMP_KERNEL = _IMP_spb.IMP_DOMINO_HAS_IMP_KERNEL

IMP_DOMINO_HAS_IMP_RMF = _IMP_spb.IMP_DOMINO_HAS_IMP_RMF

IMP_DOMINO_HAS_IMP_SAXS = _IMP_spb.IMP_DOMINO_HAS_IMP_SAXS

IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR

IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_DOMINO_HAS_BOOST_FILESYSTEM

IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS

IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_spb.IMP_DOMINO_HAS_BOOST_RANDOM

IMP_DOMINO_HAS_BOOST_REGEX = _IMP_spb.IMP_DOMINO_HAS_BOOST_REGEX

IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_spb.IMP_DOMINO_HAS_BOOST_SYSTEM

IMP_DOMINO_HAS_CGAL = _IMP_spb.IMP_DOMINO_HAS_CGAL

IMP_DOMINO_HAS_HDF5 = _IMP_spb.IMP_DOMINO_HAS_HDF5

IMP_DOMINO_HAS_NUMPY = _IMP_spb.IMP_DOMINO_HAS_NUMPY

IMP_DOMINO_HAS_RMF = _IMP_spb.IMP_DOMINO_HAS_RMF

IMP_DOMINO_HAS_PYTHON_IHM = _IMP_spb.IMP_DOMINO_HAS_PYTHON_IHM

IMPDOMINO_SHOW_WARNINGS = _IMP_spb.IMPDOMINO_SHOW_WARNINGS

import RMF_HDF5
import IMP.domino
IMP_EM2D_HAS_IMP_CGAL = _IMP_spb.IMP_EM2D_HAS_IMP_CGAL

IMP_EM2D_HAS_IMP_ISD = _IMP_spb.IMP_EM2D_HAS_IMP_ISD

IMP_EM2D_HAS_IMP_KERNEL = _IMP_spb.IMP_EM2D_HAS_IMP_KERNEL

IMP_EM2D_HAS_IMP_RMF = _IMP_spb.IMP_EM2D_HAS_IMP_RMF

IMP_EM2D_HAS_IMP_SAXS = _IMP_spb.IMP_EM2D_HAS_IMP_SAXS

IMP_EM2D_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_EM2D_HAS_IMP_SCORE_FUNCTOR

IMP_EM2D_HAS_IMP_STATISTICS = _IMP_spb.IMP_EM2D_HAS_IMP_STATISTICS

IMP_EM2D_HAS_BOOST_GRAPH = _IMP_spb.IMP_EM2D_HAS_BOOST_GRAPH

IMP_EM2D_HAS_BOOST_RANDOM = _IMP_spb.IMP_EM2D_HAS_BOOST_RANDOM

IMP_EM2D_HAS_BOOST_REGEX = _IMP_spb.IMP_EM2D_HAS_BOOST_REGEX

IMP_EM2D_HAS_BOOST_SYSTEM = _IMP_spb.IMP_EM2D_HAS_BOOST_SYSTEM

IMP_EM2D_HAS_CGAL = _IMP_spb.IMP_EM2D_HAS_CGAL

IMP_EM2D_HAS_GSL = _IMP_spb.IMP_EM2D_HAS_GSL

IMP_EM2D_HAS_HDF5 = _IMP_spb.IMP_EM2D_HAS_HDF5

IMP_EM2D_HAS_NUMPY = _IMP_spb.IMP_EM2D_HAS_NUMPY

IMP_EM2D_HAS_OPENCV3 = _IMP_spb.IMP_EM2D_HAS_OPENCV3

IMP_EM2D_HAS_RMF = _IMP_spb.IMP_EM2D_HAS_RMF

IMP_EM2D_HAS_PYTHON_IHM = _IMP_spb.IMP_EM2D_HAS_PYTHON_IHM

IMP_EM2D_HAS_OPENCV21 = _IMP_spb.IMP_EM2D_HAS_OPENCV21

IMP_EM2D_HAS_OPENCV22 = _IMP_spb.IMP_EM2D_HAS_OPENCV22

IMPEM2D_SHOW_WARNINGS = _IMP_spb.IMPEM2D_SHOW_WARNINGS

import IMP.em2d
IMP_SPB_HAS_IMP_ALGEBRA = _IMP_spb.IMP_SPB_HAS_IMP_ALGEBRA

IMP_SPB_HAS_IMP_CGAL = _IMP_spb.IMP_SPB_HAS_IMP_CGAL

IMP_SPB_HAS_IMP_DISPLAY = _IMP_spb.IMP_SPB_HAS_IMP_DISPLAY

IMP_SPB_HAS_IMP_DOMINO = _IMP_spb.IMP_SPB_HAS_IMP_DOMINO

IMP_SPB_HAS_IMP_EM = _IMP_spb.IMP_SPB_HAS_IMP_EM

IMP_SPB_HAS_IMP_GSL = _IMP_spb.IMP_SPB_HAS_IMP_GSL

IMP_SPB_HAS_IMP_KERNEL = _IMP_spb.IMP_SPB_HAS_IMP_KERNEL

IMP_SPB_HAS_IMP_SCORE_FUNCTOR = _IMP_spb.IMP_SPB_HAS_IMP_SCORE_FUNCTOR

IMP_SPB_HAS_BOOST_FILESYSTEM = _IMP_spb.IMP_SPB_HAS_BOOST_FILESYSTEM

IMP_SPB_HAS_BOOST_GRAPH = _IMP_spb.IMP_SPB_HAS_BOOST_GRAPH

IMP_SPB_HAS_BOOST_PROGRAMOPTIONS = _IMP_spb.IMP_SPB_HAS_BOOST_PROGRAMOPTIONS

IMP_SPB_HAS_BOOST_RANDOM = _IMP_spb.IMP_SPB_HAS_BOOST_RANDOM

IMP_SPB_HAS_BOOST_REGEX = _IMP_spb.IMP_SPB_HAS_BOOST_REGEX

IMP_SPB_HAS_BOOST_SYSTEM = _IMP_spb.IMP_SPB_HAS_BOOST_SYSTEM

IMP_SPB_HAS_CGAL = _IMP_spb.IMP_SPB_HAS_CGAL

IMP_SPB_HAS_FFTW3 = _IMP_spb.IMP_SPB_HAS_FFTW3

IMP_SPB_HAS_GSL = _IMP_spb.IMP_SPB_HAS_GSL

IMP_SPB_HAS_HDF5 = _IMP_spb.IMP_SPB_HAS_HDF5

IMP_SPB_HAS_MPI = _IMP_spb.IMP_SPB_HAS_MPI

IMP_SPB_HAS_NUMPY = _IMP_spb.IMP_SPB_HAS_NUMPY

IMP_SPB_HAS_OPENCV3 = _IMP_spb.IMP_SPB_HAS_OPENCV3

IMP_SPB_HAS_RMF = _IMP_spb.IMP_SPB_HAS_RMF

IMP_SPB_HAS_PYTHON_IHM = _IMP_spb.IMP_SPB_HAS_PYTHON_IHM

IMPSPB_SHOW_WARNINGS = _IMP_spb.IMPSPB_SHOW_WARNINGS


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


_value_types.append("HelixDecorator")


_object_types.append("AttributeDistancePairScore")


def _object_cast_to_AttributeDistancePairScore(o):
    r"""_object_cast_to_AttributeDistancePairScore(Object o) -> AttributeDistancePairScore"""
    return _IMP_spb._object_cast_to_AttributeDistancePairScore(o)

_object_types.append("BoxedMover")


def _object_cast_to_BoxedMover(o):
    r"""_object_cast_to_BoxedMover(Object o) -> BoxedMover"""
    return _IMP_spb._object_cast_to_BoxedMover(o)

_object_types.append("CellMover")


def _object_cast_to_CellMover(o):
    r"""_object_cast_to_CellMover(Object o) -> CellMover"""
    return _IMP_spb._object_cast_to_CellMover(o)

_object_types.append("ChiSquareMetric")


_object_types.append("ContactMapMetric")


def _object_cast_to_ContactMapMetric(o):
    r"""_object_cast_to_ContactMapMetric(Object o) -> ContactMapMetric"""
    return _IMP_spb._object_cast_to_ContactMapMetric(o)

_object_types.append("DiameterRgyrRestraint")


def _object_cast_to_DiameterRgyrRestraint(o):
    r"""_object_cast_to_DiameterRgyrRestraint(Object o) -> DiameterRgyrRestraint"""
    return _IMP_spb._object_cast_to_DiameterRgyrRestraint(o)

_object_types.append("DistanceRMSDMetric")


def _object_cast_to_DistanceRMSDMetric(o):
    r"""_object_cast_to_DistanceRMSDMetric(Object o) -> DistanceRMSDMetric"""
    return _IMP_spb._object_cast_to_DistanceRMSDMetric(o)

_object_types.append("Gaussian")


def _object_cast_to_Gaussian(o):
    r"""_object_cast_to_Gaussian(Object o) -> Gaussian"""
    return _IMP_spb._object_cast_to_Gaussian(o)

_object_types.append("ISDRestraint")


_object_types.append("KinkPairScore")


def _object_cast_to_KinkPairScore(o):
    r"""_object_cast_to_KinkPairScore(Object o) -> KinkPairScore"""
    return _IMP_spb._object_cast_to_KinkPairScore(o)

_object_types.append("MolecularDynamicsWithWte")


def _object_cast_to_MolecularDynamicsWithWte(o):
    r"""_object_cast_to_MolecularDynamicsWithWte(Object o) -> MolecularDynamicsWithWte"""
    return _IMP_spb._object_cast_to_MolecularDynamicsWithWte(o)

_object_types.append("MonteCarloWithWte")


def _object_cast_to_MonteCarloWithWte(o):
    r"""_object_cast_to_MonteCarloWithWte(Object o) -> MonteCarloWithWte"""
    return _IMP_spb._object_cast_to_MonteCarloWithWte(o)

_object_types.append("NuisanceRangeModifier")


def _object_cast_to_NuisanceRangeModifier(o):
    r"""_object_cast_to_NuisanceRangeModifier(Object o) -> NuisanceRangeModifier"""
    return _IMP_spb._object_cast_to_NuisanceRangeModifier(o)

_object_types.append("PbcBoxedMover")


def _object_cast_to_PbcBoxedMover(o):
    r"""_object_cast_to_PbcBoxedMover(Object o) -> PbcBoxedMover"""
    return _IMP_spb._object_cast_to_PbcBoxedMover(o)

_object_types.append("PbcBoxedRigidBodyMover")


def _object_cast_to_PbcBoxedRigidBodyMover(o):
    r"""_object_cast_to_PbcBoxedRigidBodyMover(Object o) -> PbcBoxedRigidBodyMover"""
    return _IMP_spb._object_cast_to_PbcBoxedRigidBodyMover(o)

_object_types.append("RigidBodyNewMover")


def _object_cast_to_RigidBodyNewMover(o):
    r"""_object_cast_to_RigidBodyNewMover(Object o) -> RigidBodyNewMover"""
    return _IMP_spb._object_cast_to_RigidBodyNewMover(o)

_object_types.append("RigidBodyPackingScore")


def _object_cast_to_RigidBodyPackingScore(o):
    r"""_object_cast_to_RigidBodyPackingScore(Object o) -> RigidBodyPackingScore"""
    return _IMP_spb._object_cast_to_RigidBodyPackingScore(o)

_object_types.append("RMSDMetric")


def _object_cast_to_RMSDMetric(o):
    r"""_object_cast_to_RMSDMetric(Object o) -> RMSDMetric"""
    return _IMP_spb._object_cast_to_RMSDMetric(o)

_object_types.append("SameParticlePairFilter")


def _object_cast_to_SameParticlePairFilter(o):
    r"""_object_cast_to_SameParticlePairFilter(Object o) -> SameParticlePairFilter"""
    return _IMP_spb._object_cast_to_SameParticlePairFilter(o)

_object_types.append("SameRigidBodyPairFilter")


def _object_cast_to_SameRigidBodyPairFilter(o):
    r"""_object_cast_to_SameRigidBodyPairFilter(Object o) -> SameRigidBodyPairFilter"""
    return _IMP_spb._object_cast_to_SameRigidBodyPairFilter(o)

_object_types.append("TiltSingletonScore")


def _object_cast_to_TiltSingletonScore(o):
    r"""_object_cast_to_TiltSingletonScore(Object o) -> TiltSingletonScore"""
    return _IMP_spb._object_cast_to_TiltSingletonScore(o)

_object_types.append("TransformationSymmetry")


_object_types.append("TwoStateGoModelRestraint")


def _object_cast_to_TwoStateGoModelRestraint(o):
    r"""_object_cast_to_TwoStateGoModelRestraint(Object o) -> TwoStateGoModelRestraint"""
    return _IMP_spb._object_cast_to_TwoStateGoModelRestraint(o)

_object_types.append("UniformBoundedRestraint")


def _object_cast_to_UniformBoundedRestraint(o):
    r"""_object_cast_to_UniformBoundedRestraint(Object o) -> UniformBoundedRestraint"""
    return _IMP_spb._object_cast_to_UniformBoundedRestraint(o)
class AttributeDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::spb::AttributeDistancePairScore class."""

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

    def __init__(self, f, k):
        r"""__init__(AttributeDistancePairScore self, UnaryFunction f, FloatKey k) -> AttributeDistancePairScore"""
        _IMP_spb.AttributeDistancePairScore_swiginit(self, _IMP_spb.new_AttributeDistancePairScore(f, k))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(AttributeDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.AttributeDistancePairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(AttributeDistancePairScore 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_spb.AttributeDistancePairScore_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(AttributeDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.AttributeDistancePairScore_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(AttributeDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.AttributeDistancePairScore_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(AttributeDistancePairScore 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_spb.AttributeDistancePairScore_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(AttributeDistancePairScore self) -> VersionInfo"""
        return _IMP_spb.AttributeDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_AttributeDistancePairScore

    def show(self, *args):
        r"""show(AttributeDistancePairScore self, _ostream out=std::cout)"""
        return _IMP_spb.AttributeDistancePairScore_show(self, *args)

    def __str__(self):
        r"""__str__(AttributeDistancePairScore self) -> std::string"""
        return _IMP_spb.AttributeDistancePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(AttributeDistancePairScore self) -> std::string"""
        return _IMP_spb.AttributeDistancePairScore___repr__(self)

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


# Register AttributeDistancePairScore in _IMP_spb:
_IMP_spb.AttributeDistancePairScore_swigregister(AttributeDistancePairScore)
class BoxedMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::spb::BoxedMover class."""

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

    def __init__(self, p, max_tr, centers):
        r"""__init__(BoxedMover self, Particle p, IMP::Float max_tr, IMP::algebra::Vector3Ds centers) -> BoxedMover"""
        _IMP_spb.BoxedMover_swiginit(self, _IMP_spb.new_BoxedMover(p, max_tr, centers))

    def get_version_info(self):
        r"""get_version_info(BoxedMover self) -> VersionInfo"""
        return _IMP_spb.BoxedMover_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_BoxedMover

    def show(self, *args):
        r"""show(BoxedMover self, _ostream out=std::cout)"""
        return _IMP_spb.BoxedMover_show(self, *args)

    def __str__(self):
        r"""__str__(BoxedMover self) -> std::string"""
        return _IMP_spb.BoxedMover___str__(self)

    def __repr__(self):
        r"""__repr__(BoxedMover self) -> std::string"""
        return _IMP_spb.BoxedMover___repr__(self)

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


# Register BoxedMover in _IMP_spb:
_IMP_spb.BoxedMover_swigregister(BoxedMover)
class CellMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::spb::CellMover class."""

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

    def __init__(self, p, ps, max_translation):
        r"""__init__(CellMover self, Particle p, IMP::Particles ps, IMP::Float max_translation) -> CellMover"""
        _IMP_spb.CellMover_swiginit(self, _IMP_spb.new_CellMover(p, ps, max_translation))

    def get_version_info(self):
        r"""get_version_info(CellMover self) -> VersionInfo"""
        return _IMP_spb.CellMover_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_CellMover

    def show(self, *args):
        r"""show(CellMover self, _ostream out=std::cout)"""
        return _IMP_spb.CellMover_show(self, *args)

    def __str__(self):
        r"""__str__(CellMover self) -> std::string"""
        return _IMP_spb.CellMover___str__(self)

    def __repr__(self):
        r"""__repr__(CellMover self) -> std::string"""
        return _IMP_spb.CellMover___repr__(self)

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


# Register CellMover in _IMP_spb:
_IMP_spb.CellMover_swigregister(CellMover)
class ChiSquareMetric(IMP.statistics.Metric):
    r"""Proxy of C++ IMP::spb::ChiSquareMetric class."""

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

    def __init__(self, nu_exp, constr_type=0):
        r"""__init__(ChiSquareMetric self, IMP::Floats nu_exp, int constr_type=0) -> ChiSquareMetric"""
        _IMP_spb.ChiSquareMetric_swiginit(self, _IMP_spb.new_ChiSquareMetric(nu_exp, constr_type))

    def add_configuration(self, nu, stddev, weight=1.0):
        r"""add_configuration(ChiSquareMetric self, IMP::Floats nu, IMP::Floats stddev, double weight=1.0)"""
        return _IMP_spb.ChiSquareMetric_add_configuration(self, nu, stddev, weight)

    def get_nu(self, i):
        r"""get_nu(ChiSquareMetric self, unsigned int i) -> IMP::Floats"""
        return _IMP_spb.ChiSquareMetric_get_nu(self, i)

    def get_stddev(self, i):
        r"""get_stddev(ChiSquareMetric self, unsigned int i) -> IMP::Floats"""
        return _IMP_spb.ChiSquareMetric_get_stddev(self, i)

    def get_weight(self, i):
        r"""get_weight(ChiSquareMetric self, unsigned int i) -> IMP::Float"""
        return _IMP_spb.ChiSquareMetric_get_weight(self, i)

    def get_chisquare_exp(self, i):
        r"""get_chisquare_exp(ChiSquareMetric self, unsigned int i) -> double"""
        return _IMP_spb.ChiSquareMetric_get_chisquare_exp(self, i)

    def get_version_info(self):
        r"""get_version_info(ChiSquareMetric self) -> VersionInfo"""
        return _IMP_spb.ChiSquareMetric_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_ChiSquareMetric

    def __str__(self):
        r"""__str__(ChiSquareMetric self) -> std::string"""
        return _IMP_spb.ChiSquareMetric___str__(self)

    def __repr__(self):
        r"""__repr__(ChiSquareMetric self) -> std::string"""
        return _IMP_spb.ChiSquareMetric___repr__(self)

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


# Register ChiSquareMetric in _IMP_spb:
_IMP_spb.ChiSquareMetric_swigregister(ChiSquareMetric)
class ContactMapMetric(IMP.statistics.Metric):
    r"""Proxy of C++ IMP::spb::ContactMapMetric class."""

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

    def __init__(self, ps, r0, nn, mm):
        r"""__init__(ContactMapMetric self, IMP::Particles ps, double r0, int nn, int mm) -> ContactMapMetric"""
        _IMP_spb.ContactMapMetric_swiginit(self, _IMP_spb.new_ContactMapMetric(ps, r0, nn, mm))

    def add_configuration(self, weight=1.0):
        r"""add_configuration(ContactMapMetric self, double weight=1.0)"""
        return _IMP_spb.ContactMapMetric_add_configuration(self, weight)

    def add_map(self, matrix, weight=1.0):
        r"""add_map(ContactMapMetric self, IMP::Floats matrix, double weight=1.0)"""
        return _IMP_spb.ContactMapMetric_add_map(self, matrix, weight)

    def get_weight(self, i):
        r"""get_weight(ContactMapMetric self, unsigned int i) -> IMP::Float"""
        return _IMP_spb.ContactMapMetric_get_weight(self, i)

    def get_item(self, i):
        r"""get_item(ContactMapMetric self, unsigned int i) -> IMP::Floats"""
        return _IMP_spb.ContactMapMetric_get_item(self, i)

    def get_version_info(self):
        r"""get_version_info(ContactMapMetric self) -> VersionInfo"""
        return _IMP_spb.ContactMapMetric_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_ContactMapMetric

    def __str__(self):
        r"""__str__(ContactMapMetric self) -> std::string"""
        return _IMP_spb.ContactMapMetric___str__(self)

    def __repr__(self):
        r"""__repr__(ContactMapMetric self) -> std::string"""
        return _IMP_spb.ContactMapMetric___repr__(self)

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


# Register ContactMapMetric in _IMP_spb:
_IMP_spb.ContactMapMetric_swigregister(ContactMapMetric)
class DiameterRgyrRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::spb::DiameterRgyrRestraint class."""

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

    def __init__(self, ps, diameter, rgyr, kappa):
        r"""__init__(DiameterRgyrRestraint self, IMP::Particles ps, IMP::Float diameter, IMP::Float rgyr, IMP::Float kappa) -> DiameterRgyrRestraint"""
        _IMP_spb.DiameterRgyrRestraint_swiginit(self, _IMP_spb.new_DiameterRgyrRestraint(ps, diameter, rgyr, kappa))

    def do_get_inputs(self):
        r"""do_get_inputs(DiameterRgyrRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.DiameterRgyrRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(DiameterRgyrRestraint self) -> VersionInfo"""
        return _IMP_spb.DiameterRgyrRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_DiameterRgyrRestraint

    def __str__(self):
        r"""__str__(DiameterRgyrRestraint self) -> std::string"""
        return _IMP_spb.DiameterRgyrRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(DiameterRgyrRestraint self) -> std::string"""
        return _IMP_spb.DiameterRgyrRestraint___repr__(self)

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


# Register DiameterRgyrRestraint in _IMP_spb:
_IMP_spb.DiameterRgyrRestraint_swigregister(DiameterRgyrRestraint)
class DistanceRMSDMetric(IMP.statistics.Metric):
    r"""Proxy of C++ IMP::spb::DistanceRMSDMetric class."""

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

    def __init__(self, ps, align, tr, px, py, pz):
        r"""__init__(DistanceRMSDMetric self, IMP::Particles ps, IMP::Ints align, IMP::algebra::Transformation3Ds tr, Particle px, Particle py, Particle pz) -> DistanceRMSDMetric"""
        _IMP_spb.DistanceRMSDMetric_swiginit(self, _IMP_spb.new_DistanceRMSDMetric(ps, align, tr, px, py, pz))

    def add_configuration(self, weight=1.0):
        r"""add_configuration(DistanceRMSDMetric self, double weight=1.0)"""
        return _IMP_spb.DistanceRMSDMetric_add_configuration(self, weight)

    def get_weight(self, i):
        r"""get_weight(DistanceRMSDMetric self, unsigned int i) -> IMP::Float"""
        return _IMP_spb.DistanceRMSDMetric_get_weight(self, i)

    def get_version_info(self):
        r"""get_version_info(DistanceRMSDMetric self) -> VersionInfo"""
        return _IMP_spb.DistanceRMSDMetric_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_DistanceRMSDMetric

    def __str__(self):
        r"""__str__(DistanceRMSDMetric self) -> std::string"""
        return _IMP_spb.DistanceRMSDMetric___str__(self)

    def __repr__(self):
        r"""__repr__(DistanceRMSDMetric self) -> std::string"""
        return _IMP_spb.DistanceRMSDMetric___repr__(self)

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


# Register DistanceRMSDMetric in _IMP_spb:
_IMP_spb.DistanceRMSDMetric_swigregister(DistanceRMSDMetric)

def create_gromos_clustering(d, cutoff):
    r"""create_gromos_clustering(Metric d, double cutoff) -> PartitionalClustering"""
    return _IMP_spb.create_gromos_clustering(d, cutoff)
class Gaussian(IMP.UnaryFunction):
    r"""Proxy of C++ IMP::spb::Gaussian class."""

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

    def __init__(self, Emin, Zmin, sigma):
        r"""__init__(Gaussian self, IMP::Float Emin, IMP::Float Zmin, IMP::Float sigma) -> Gaussian"""
        _IMP_spb.Gaussian_swiginit(self, _IMP_spb.new_Gaussian(Emin, Zmin, sigma))

    def get_version_info(self):
        r"""get_version_info(Gaussian self) -> VersionInfo"""
        return _IMP_spb.Gaussian_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_Gaussian

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

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

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


# Register Gaussian in _IMP_spb:
_IMP_spb.Gaussian_swigregister(Gaussian)
class HelixDecorator(IMP.Decorator):
    r"""Proxy of C++ IMP::spb::HelixDecorator 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__(HelixDecorator self) -> HelixDecorator
        __init__(HelixDecorator self, Model m, ParticleIndex id) -> HelixDecorator
        __init__(HelixDecorator self, _ParticleAdaptor d) -> HelixDecorator
        """
        _IMP_spb.HelixDecorator_swiginit(self, _IMP_spb.new_HelixDecorator(*args))

    def show(self, *args):
        r"""show(HelixDecorator self, _ostream out=std::cout)"""
        return _IMP_spb.HelixDecorator_show(self, *args)

    @staticmethod
    def setup_particle(p, b, e):
        r"""setup_particle(Particle p, IMP::Float b, IMP::Float e) -> HelixDecorator"""
        return _IMP_spb.HelixDecorator_setup_particle(p, b, e)

    def get_begin(self):
        r"""get_begin(HelixDecorator self) -> IMP::Float"""
        return _IMP_spb.HelixDecorator_get_begin(self)

    def get_end(self):
        r"""get_end(HelixDecorator self) -> IMP::Float"""
        return _IMP_spb.HelixDecorator_get_end(self)

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex id) -> bool
        """
        return _IMP_spb.HelixDecorator_get_is_setup(*args)

    def set_begin(self, v):
        r"""set_begin(HelixDecorator self, IMP::Float v)"""
        return _IMP_spb.HelixDecorator_set_begin(self, v)

    def set_end(self, v):
        r"""set_end(HelixDecorator self, IMP::Float v)"""
        return _IMP_spb.HelixDecorator_set_end(self, v)

    def add_attribute(self, *args):
        r"""
        add_attribute(HelixDecorator self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(HelixDecorator self, FloatKey a0, IMP::Float a1)
        add_attribute(HelixDecorator self, IntKey a0, IMP::Int a1)
        add_attribute(HelixDecorator self, FloatsKey a0, IMP::Floats a1)
        add_attribute(HelixDecorator self, IntsKey a0, IMP::Ints a1)
        add_attribute(HelixDecorator self, StringKey a0, IMP::String a1)
        add_attribute(HelixDecorator self, ParticleIndexKey a0, Particle a1)
        add_attribute(HelixDecorator self, ObjectKey a0, Object a1)
        add_attribute(HelixDecorator self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(HelixDecorator self, SparseIntKey a0, IMP::Int a1)
        add_attribute(HelixDecorator self, SparseStringKey a0, IMP::String a1)
        add_attribute(HelixDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_spb.HelixDecorator_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        get_value(HelixDecorator self, FloatKey a0) -> IMP::Float
        get_value(HelixDecorator self, IntKey a0) -> IMP::Int
        get_value(HelixDecorator self, FloatsKey a0) -> IMP::Floats
        get_value(HelixDecorator self, IntsKey a0) -> IMP::Ints
        get_value(HelixDecorator self, StringKey a0) -> IMP::String
        get_value(HelixDecorator self, ParticleIndexKey a0) -> Particle
        get_value(HelixDecorator self, ObjectKey a0) -> Object
        get_value(HelixDecorator self, SparseFloatKey a0) -> IMP::Float
        get_value(HelixDecorator self, SparseIntKey a0) -> IMP::Int
        get_value(HelixDecorator self, SparseStringKey a0) -> IMP::String
        get_value(HelixDecorator self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_spb.HelixDecorator_get_value(self, *args)

    def set_value(self, *args):
        r"""
        set_value(HelixDecorator self, FloatKey a0, IMP::Float a1)
        set_value(HelixDecorator self, IntKey a0, IMP::Int a1)
        set_value(HelixDecorator self, FloatsKey a0, IMP::Floats a1)
        set_value(HelixDecorator self, IntsKey a0, IMP::Ints a1)
        set_value(HelixDecorator self, StringKey a0, IMP::String a1)
        set_value(HelixDecorator self, ParticleIndexKey a0, Particle a1)
        set_value(HelixDecorator self, ObjectKey a0, Object a1)
        set_value(HelixDecorator self, SparseFloatKey a0, IMP::Float a1)
        set_value(HelixDecorator self, SparseIntKey a0, IMP::Int a1)
        set_value(HelixDecorator self, SparseStringKey a0, IMP::String a1)
        set_value(HelixDecorator self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_spb.HelixDecorator_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        remove_attribute(HelixDecorator self, FloatKey a0)
        remove_attribute(HelixDecorator self, IntKey a0)
        remove_attribute(HelixDecorator self, FloatsKey a0)
        remove_attribute(HelixDecorator self, IntsKey a0)
        remove_attribute(HelixDecorator self, StringKey a0)
        remove_attribute(HelixDecorator self, ParticleIndexKey a0)
        remove_attribute(HelixDecorator self, ObjectKey a0)
        remove_attribute(HelixDecorator self, SparseFloatKey a0)
        remove_attribute(HelixDecorator self, SparseIntKey a0)
        remove_attribute(HelixDecorator self, SparseStringKey a0)
        remove_attribute(HelixDecorator self, SparseParticleIndexKey a0)
        """
        return _IMP_spb.HelixDecorator_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        has_attribute(HelixDecorator self, FloatKey a0) -> bool
        has_attribute(HelixDecorator self, IntKey a0) -> bool
        has_attribute(HelixDecorator self, FloatsKey a0) -> bool
        has_attribute(HelixDecorator self, IntsKey a0) -> bool
        has_attribute(HelixDecorator self, StringKey a0) -> bool
        has_attribute(HelixDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(HelixDecorator self, ObjectKey a0) -> bool
        has_attribute(HelixDecorator self, SparseFloatKey a0) -> bool
        has_attribute(HelixDecorator self, SparseIntKey a0) -> bool
        has_attribute(HelixDecorator self, SparseStringKey a0) -> bool
        has_attribute(HelixDecorator self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_spb.HelixDecorator_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(HelixDecorator self, FloatKey a0) -> double"""
        return _IMP_spb.HelixDecorator_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(HelixDecorator self) -> std::string"""
        return _IMP_spb.HelixDecorator_get_name(self)

    def clear_caches(self):
        r"""clear_caches(HelixDecorator self)"""
        return _IMP_spb.HelixDecorator_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(HelixDecorator self, std::string a0)"""
        return _IMP_spb.HelixDecorator_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(HelixDecorator self, IMP::CheckLevel a0)"""
        return _IMP_spb.HelixDecorator_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(HelixDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_spb.HelixDecorator_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(HelixDecorator self, FloatKey a0, bool a1)"""
        return _IMP_spb.HelixDecorator_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(HelixDecorator self, FloatKey a0) -> bool"""
        return _IMP_spb.HelixDecorator_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(HelixDecorator self) -> IMP::CheckLevel"""
        return _IMP_spb.HelixDecorator_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(HelixDecorator self, HelixDecorator o) -> bool
        __eq__(HelixDecorator self, Particle d) -> bool
        """
        return _IMP_spb.HelixDecorator___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(HelixDecorator self, HelixDecorator o) -> bool
        __ne__(HelixDecorator self, Particle d) -> bool
        """
        return _IMP_spb.HelixDecorator___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(HelixDecorator self, HelixDecorator o) -> bool
        __le__(HelixDecorator self, Particle d) -> bool
        """
        return _IMP_spb.HelixDecorator___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(HelixDecorator self, HelixDecorator o) -> bool
        __lt__(HelixDecorator self, Particle d) -> bool
        """
        return _IMP_spb.HelixDecorator___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(HelixDecorator self, HelixDecorator o) -> bool
        __ge__(HelixDecorator self, Particle d) -> bool
        """
        return _IMP_spb.HelixDecorator___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(HelixDecorator self, HelixDecorator o) -> bool
        __gt__(HelixDecorator self, Particle d) -> bool
        """
        return _IMP_spb.HelixDecorator___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(HelixDecorator self) -> std::size_t"""
        return _IMP_spb.HelixDecorator___hash__(self)

    def __str__(self):
        r"""__str__(HelixDecorator self) -> std::string"""
        return _IMP_spb.HelixDecorator___str__(self)

    def __repr__(self):
        r"""__repr__(HelixDecorator self) -> std::string"""
        return _IMP_spb.HelixDecorator___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(HelixDecorator self) -> PyObject *"""
        return _IMP_spb.HelixDecorator__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(HelixDecorator self, PyObject * p)"""
        return _IMP_spb.HelixDecorator__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_spb.delete_HelixDecorator

# Register HelixDecorator in _IMP_spb:
_IMP_spb.HelixDecorator_swigregister(HelixDecorator)
class ISDRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::spb::ISDRestraint 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_probability(self):
        r"""get_probability(ISDRestraint self) -> double"""
        return _IMP_spb.ISDRestraint_get_probability(self)

    def __str__(self):
        r"""__str__(ISDRestraint self) -> std::string"""
        return _IMP_spb.ISDRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ISDRestraint self) -> std::string"""
        return _IMP_spb.ISDRestraint___repr__(self)

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

    __swig_destroy__ = _IMP_spb.delete_ISDRestraint

# Register ISDRestraint in _IMP_spb:
_IMP_spb.ISDRestraint_swigregister(ISDRestraint)
class KinkPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::spb::KinkPairScore 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__(KinkPairScore self, UnaryFunction f) -> KinkPairScore"""
        _IMP_spb.KinkPairScore_swiginit(self, _IMP_spb.new_KinkPairScore(f))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(KinkPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.KinkPairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(KinkPairScore 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_spb.KinkPairScore_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(KinkPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.KinkPairScore_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(KinkPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.KinkPairScore_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(KinkPairScore 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_spb.KinkPairScore_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(KinkPairScore self) -> VersionInfo"""
        return _IMP_spb.KinkPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_KinkPairScore

    def show(self, *args):
        r"""show(KinkPairScore self, _ostream out=std::cout)"""
        return _IMP_spb.KinkPairScore_show(self, *args)

    def __str__(self):
        r"""__str__(KinkPairScore self) -> std::string"""
        return _IMP_spb.KinkPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(KinkPairScore self) -> std::string"""
        return _IMP_spb.KinkPairScore___repr__(self)

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


# Register KinkPairScore in _IMP_spb:
_IMP_spb.KinkPairScore_swigregister(KinkPairScore)
class MolecularDynamicsWithWte(IMP.atom.Simulator):
    r"""Proxy of C++ IMP::spb::MolecularDynamicsWithWte class."""

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

    def __init__(self, m, emin, emax, sigma, gamma, w0):
        r"""__init__(MolecularDynamicsWithWte self, Model m, double emin, double emax, double sigma, double gamma, double w0) -> MolecularDynamicsWithWte"""
        _IMP_spb.MolecularDynamicsWithWte_swiginit(self, _IMP_spb.new_MolecularDynamicsWithWte(m, emin, emax, sigma, gamma, w0))

    def get_bias(self, score):
        r"""get_bias(MolecularDynamicsWithWte self, double score) -> double"""
        return _IMP_spb.MolecularDynamicsWithWte_get_bias(self, score)

    def get_bias_buffer(self):
        r"""get_bias_buffer(MolecularDynamicsWithWte self) -> IMP::Floats"""
        return _IMP_spb.MolecularDynamicsWithWte_get_bias_buffer(self)

    def get_nbin(self):
        r"""get_nbin(MolecularDynamicsWithWte self) -> int"""
        return _IMP_spb.MolecularDynamicsWithWte_get_nbin(self)

    def set_w0(self, w0):
        r"""set_w0(MolecularDynamicsWithWte self, double w0)"""
        return _IMP_spb.MolecularDynamicsWithWte_set_w0(self, w0)

    def set_bias(self, bias):
        r"""set_bias(MolecularDynamicsWithWte self, IMP::Floats const & bias)"""
        return _IMP_spb.MolecularDynamicsWithWte_set_bias(self, bias)

    def get_kinetic_energy(self):
        r"""get_kinetic_energy(MolecularDynamicsWithWte self) -> IMP::Float"""
        return _IMP_spb.MolecularDynamicsWithWte_get_kinetic_energy(self)

    def get_kinetic_temperature(self, ekinetic):
        r"""get_kinetic_temperature(MolecularDynamicsWithWte self, IMP::Float ekinetic) -> IMP::Float"""
        return _IMP_spb.MolecularDynamicsWithWte_get_kinetic_temperature(self, ekinetic)

    def set_velocity_cap(self, velocity_cap):
        r"""set_velocity_cap(MolecularDynamicsWithWte self, IMP::Float velocity_cap)"""
        return _IMP_spb.MolecularDynamicsWithWte_set_velocity_cap(self, velocity_cap)

    def assign_velocities(self, temperature):
        r"""assign_velocities(MolecularDynamicsWithWte self, IMP::Float temperature)"""
        return _IMP_spb.MolecularDynamicsWithWte_assign_velocities(self, temperature)

    def rescale_velocities(self, rescale):
        r"""rescale_velocities(MolecularDynamicsWithWte self, IMP::Float rescale)"""
        return _IMP_spb.MolecularDynamicsWithWte_rescale_velocities(self, rescale)

    def setup(self, ps):
        r"""setup(MolecularDynamicsWithWte self, IMP::ParticleIndexes const & ps)"""
        return _IMP_spb.MolecularDynamicsWithWte_setup(self, ps)

    def do_step(self, sc, dt):
        r"""do_step(MolecularDynamicsWithWte self, IMP::ParticleIndexes const & sc, double dt) -> double"""
        return _IMP_spb.MolecularDynamicsWithWte_do_step(self, sc, dt)

    def get_is_simulation_particle(self, p):
        r"""get_is_simulation_particle(MolecularDynamicsWithWte self, ParticleIndex p) -> bool"""
        return _IMP_spb.MolecularDynamicsWithWte_get_is_simulation_particle(self, p)

    def __str__(self):
        r"""__str__(MolecularDynamicsWithWte self) -> std::string"""
        return _IMP_spb.MolecularDynamicsWithWte___str__(self)

    def __repr__(self):
        r"""__repr__(MolecularDynamicsWithWte self) -> std::string"""
        return _IMP_spb.MolecularDynamicsWithWte___repr__(self)

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

    __swig_destroy__ = _IMP_spb.delete_MolecularDynamicsWithWte

# Register MolecularDynamicsWithWte in _IMP_spb:
_IMP_spb.MolecularDynamicsWithWte_swigregister(MolecularDynamicsWithWte)
class MonteCarloWithWte(IMP.core.MonteCarlo):
    r"""Proxy of C++ IMP::spb::MonteCarloWithWte 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__(MonteCarloWithWte self, Model m, double emin, double emax, double sigma, double gamma, double w0) -> MonteCarloWithWte
        __init__(MonteCarloWithWte self, Model m, double emin, double emax, double sigma, double gamma, double w0, RestraintSet rset) -> MonteCarloWithWte
        """
        _IMP_spb.MonteCarloWithWte_swiginit(self, _IMP_spb.new_MonteCarloWithWte(*args))

    def get_bias(self, score):
        r"""get_bias(MonteCarloWithWte self, double score) -> double"""
        return _IMP_spb.MonteCarloWithWte_get_bias(self, score)

    def get_bias_asfloats(self):
        r"""get_bias_asfloats(MonteCarloWithWte self) -> IMP::Floats"""
        return _IMP_spb.MonteCarloWithWte_get_bias_asfloats(self)

    def get_nbin(self):
        r"""get_nbin(MonteCarloWithWte self) -> int"""
        return _IMP_spb.MonteCarloWithWte_get_nbin(self)

    def set_w0(self, w0):
        r"""set_w0(MonteCarloWithWte self, double w0)"""
        return _IMP_spb.MonteCarloWithWte_set_w0(self, w0)

    def set_bias(self, bias):
        r"""set_bias(MonteCarloWithWte self, IMP::Floats const & bias)"""
        return _IMP_spb.MonteCarloWithWte_set_bias(self, bias)

    def do_step(self):
        r"""do_step(MonteCarloWithWte self)"""
        return _IMP_spb.MonteCarloWithWte_do_step(self)
    __swig_destroy__ = _IMP_spb.delete_MonteCarloWithWte

    def __str__(self):
        r"""__str__(MonteCarloWithWte self) -> std::string"""
        return _IMP_spb.MonteCarloWithWte___str__(self)

    def __repr__(self):
        r"""__repr__(MonteCarloWithWte self) -> std::string"""
        return _IMP_spb.MonteCarloWithWte___repr__(self)

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


# Register MonteCarloWithWte in _IMP_spb:
_IMP_spb.MonteCarloWithWte_swigregister(MonteCarloWithWte)
class NuisanceRangeModifier(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::spb::NuisanceRangeModifier class."""

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

    def __init__(self):
        r"""__init__(NuisanceRangeModifier self) -> NuisanceRangeModifier"""
        _IMP_spb.NuisanceRangeModifier_swiginit(self, _IMP_spb.new_NuisanceRangeModifier())

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(NuisanceRangeModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.NuisanceRangeModifier_do_get_inputs(self, m, pis)

    def do_get_outputs(self, m, pis):
        r"""do_get_outputs(NuisanceRangeModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.NuisanceRangeModifier_do_get_outputs(self, m, pis)

    def get_version_info(self):
        r"""get_version_info(NuisanceRangeModifier self) -> VersionInfo"""
        return _IMP_spb.NuisanceRangeModifier_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_NuisanceRangeModifier

    def show(self, *args):
        r"""show(NuisanceRangeModifier self, _ostream out=std::cout)"""
        return _IMP_spb.NuisanceRangeModifier_show(self, *args)

    def __str__(self):
        r"""__str__(NuisanceRangeModifier self) -> std::string"""
        return _IMP_spb.NuisanceRangeModifier___str__(self)

    def __repr__(self):
        r"""__repr__(NuisanceRangeModifier self) -> std::string"""
        return _IMP_spb.NuisanceRangeModifier___repr__(self)

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


# Register NuisanceRangeModifier in _IMP_spb:
_IMP_spb.NuisanceRangeModifier_swigregister(NuisanceRangeModifier)
class PbcBoxedMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::spb::PbcBoxedMover class."""

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

    def __init__(self, p, ps, max_tr, centers, transformations, px, py, pz):
        r"""__init__(PbcBoxedMover self, Particle p, IMP::Particles ps, IMP::Float max_tr, IMP::algebra::Vector3Ds centers, IMP::algebra::Transformation3Ds transformations, Particle px, Particle py, Particle pz) -> PbcBoxedMover"""
        _IMP_spb.PbcBoxedMover_swiginit(self, _IMP_spb.new_PbcBoxedMover(p, ps, max_tr, centers, transformations, px, py, pz))

    def get_version_info(self):
        r"""get_version_info(PbcBoxedMover self) -> VersionInfo"""
        return _IMP_spb.PbcBoxedMover_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_PbcBoxedMover

    def show(self, *args):
        r"""show(PbcBoxedMover self, _ostream out=std::cout)"""
        return _IMP_spb.PbcBoxedMover_show(self, *args)

    def __str__(self):
        r"""__str__(PbcBoxedMover self) -> std::string"""
        return _IMP_spb.PbcBoxedMover___str__(self)

    def __repr__(self):
        r"""__repr__(PbcBoxedMover self) -> std::string"""
        return _IMP_spb.PbcBoxedMover___repr__(self)

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


# Register PbcBoxedMover in _IMP_spb:
_IMP_spb.PbcBoxedMover_swigregister(PbcBoxedMover)
class PbcBoxedRigidBodyMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::spb::PbcBoxedRigidBodyMover class."""

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

    def __init__(self, d, ps, max_translation, max_rotation, centers, transformations, px, py, pz):
        r"""__init__(PbcBoxedRigidBodyMover self, RigidBody d, IMP::Particles ps, IMP::Float max_translation, IMP::Float max_rotation, IMP::algebra::Vector3Ds centers, IMP::algebra::Transformation3Ds transformations, Particle px, Particle py, Particle pz) -> PbcBoxedRigidBodyMover"""
        _IMP_spb.PbcBoxedRigidBodyMover_swiginit(self, _IMP_spb.new_PbcBoxedRigidBodyMover(d, ps, max_translation, max_rotation, centers, transformations, px, py, pz))

    def get_version_info(self):
        r"""get_version_info(PbcBoxedRigidBodyMover self) -> VersionInfo"""
        return _IMP_spb.PbcBoxedRigidBodyMover_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_PbcBoxedRigidBodyMover

    def show(self, *args):
        r"""show(PbcBoxedRigidBodyMover self, _ostream out=std::cout)"""
        return _IMP_spb.PbcBoxedRigidBodyMover_show(self, *args)

    def __str__(self):
        r"""__str__(PbcBoxedRigidBodyMover self) -> std::string"""
        return _IMP_spb.PbcBoxedRigidBodyMover___str__(self)

    def __repr__(self):
        r"""__repr__(PbcBoxedRigidBodyMover self) -> std::string"""
        return _IMP_spb.PbcBoxedRigidBodyMover___repr__(self)

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


# Register PbcBoxedRigidBodyMover in _IMP_spb:
_IMP_spb.PbcBoxedRigidBodyMover_swigregister(PbcBoxedRigidBodyMover)
class RigidBodyNewMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::spb::RigidBodyNewMover class."""

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

    def __init__(self, d, max_x_translation, max_y_translation, max_z_translation, max_rot):
        r"""__init__(RigidBodyNewMover self, RigidBody d, IMP::Float max_x_translation, IMP::Float max_y_translation, IMP::Float max_z_translation, IMP::Float max_rot) -> RigidBodyNewMover"""
        _IMP_spb.RigidBodyNewMover_swiginit(self, _IMP_spb.new_RigidBodyNewMover(d, max_x_translation, max_y_translation, max_z_translation, max_rot))

    def get_version_info(self):
        r"""get_version_info(RigidBodyNewMover self) -> VersionInfo"""
        return _IMP_spb.RigidBodyNewMover_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_RigidBodyNewMover

    def show(self, *args):
        r"""show(RigidBodyNewMover self, _ostream out=std::cout)"""
        return _IMP_spb.RigidBodyNewMover_show(self, *args)

    def __str__(self):
        r"""__str__(RigidBodyNewMover self) -> std::string"""
        return _IMP_spb.RigidBodyNewMover___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyNewMover self) -> std::string"""
        return _IMP_spb.RigidBodyNewMover___repr__(self)

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


# Register RigidBodyNewMover in _IMP_spb:
_IMP_spb.RigidBodyNewMover_swigregister(RigidBodyNewMover)
class RigidBodyPackingScore(IMP.PairScore):
    r"""Proxy of C++ IMP::spb::RigidBodyPackingScore class."""

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

    def __init__(self, tbr, omb, ome, ddb, dde, kappa):
        r"""__init__(RigidBodyPackingScore self, TableRefiner tbr, IMP::Floats omb, IMP::Floats ome, IMP::Floats ddb, IMP::Floats dde, double kappa) -> RigidBodyPackingScore"""
        _IMP_spb.RigidBodyPackingScore_swiginit(self, _IMP_spb.new_RigidBodyPackingScore(tbr, omb, ome, ddb, dde, kappa))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(RigidBodyPackingScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.RigidBodyPackingScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(RigidBodyPackingScore 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_spb.RigidBodyPackingScore_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(RigidBodyPackingScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.RigidBodyPackingScore_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(RigidBodyPackingScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.RigidBodyPackingScore_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(RigidBodyPackingScore 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_spb.RigidBodyPackingScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def show(self, *args):
        r"""show(RigidBodyPackingScore self, _ostream out=std::cout)"""
        return _IMP_spb.RigidBodyPackingScore_show(self, *args)

    def __str__(self):
        r"""__str__(RigidBodyPackingScore self) -> std::string"""
        return _IMP_spb.RigidBodyPackingScore___str__(self)

    def __repr__(self):
        r"""__repr__(RigidBodyPackingScore self) -> std::string"""
        return _IMP_spb.RigidBodyPackingScore___repr__(self)

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

    __swig_destroy__ = _IMP_spb.delete_RigidBodyPackingScore

# Register RigidBodyPackingScore in _IMP_spb:
_IMP_spb.RigidBodyPackingScore_swigregister(RigidBodyPackingScore)
class RMSDMetric(IMP.statistics.Metric):
    r"""Proxy of C++ IMP::spb::RMSDMetric 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__(RMSDMetric self, IMP::Particles ps) -> RMSDMetric"""
        _IMP_spb.RMSDMetric_swiginit(self, _IMP_spb.new_RMSDMetric(ps))

    def add_configuration(self, weight=1.0):
        r"""add_configuration(RMSDMetric self, double weight=1.0)"""
        return _IMP_spb.RMSDMetric_add_configuration(self, weight)

    def get_weight(self, i):
        r"""get_weight(RMSDMetric self, unsigned int i) -> IMP::Float"""
        return _IMP_spb.RMSDMetric_get_weight(self, i)

    def get_version_info(self):
        r"""get_version_info(RMSDMetric self) -> VersionInfo"""
        return _IMP_spb.RMSDMetric_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_RMSDMetric

    def __str__(self):
        r"""__str__(RMSDMetric self) -> std::string"""
        return _IMP_spb.RMSDMetric___str__(self)

    def __repr__(self):
        r"""__repr__(RMSDMetric self) -> std::string"""
        return _IMP_spb.RMSDMetric___repr__(self)

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


# Register RMSDMetric in _IMP_spb:
_IMP_spb.RMSDMetric_swigregister(RMSDMetric)
class SameParticlePairFilter(IMP.PairPredicate):
    r"""Proxy of C++ IMP::spb::SameParticlePairFilter class."""

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

    def __init__(self):
        r"""__init__(SameParticlePairFilter self) -> SameParticlePairFilter"""
        _IMP_spb.SameParticlePairFilter_swiginit(self, _IMP_spb.new_SameParticlePairFilter())

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(SameParticlePairFilter self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.SameParticlePairFilter_do_get_inputs(self, m, pis)

    def get_value(self, *args):
        r"""
        get_value(SameParticlePairFilter self, IMP::ParticlePair const & a) -> int
        get_value(SameParticlePairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_spb.SameParticlePairFilter_get_value(self, *args)

    def get_value_index(self, *args):
        r"""
        get_value_index(SameParticlePairFilter self, Model m, IMP::ParticleIndexPair const & p) -> int
        get_value_index(SameParticlePairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_spb.SameParticlePairFilter_get_value_index(self, *args)

    def get_version_info(self):
        r"""get_version_info(SameParticlePairFilter self) -> VersionInfo"""
        return _IMP_spb.SameParticlePairFilter_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_SameParticlePairFilter

    def __str__(self):
        r"""__str__(SameParticlePairFilter self) -> std::string"""
        return _IMP_spb.SameParticlePairFilter___str__(self)

    def __repr__(self):
        r"""__repr__(SameParticlePairFilter self) -> std::string"""
        return _IMP_spb.SameParticlePairFilter___repr__(self)

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


# Register SameParticlePairFilter in _IMP_spb:
_IMP_spb.SameParticlePairFilter_swigregister(SameParticlePairFilter)
class SameRigidBodyPairFilter(IMP.PairPredicate):
    r"""Proxy of C++ IMP::spb::SameRigidBodyPairFilter class."""

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

    def __init__(self):
        r"""__init__(SameRigidBodyPairFilter self) -> SameRigidBodyPairFilter"""
        _IMP_spb.SameRigidBodyPairFilter_swiginit(self, _IMP_spb.new_SameRigidBodyPairFilter())

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(SameRigidBodyPairFilter self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.SameRigidBodyPairFilter_do_get_inputs(self, m, pis)

    def get_value(self, *args):
        r"""
        get_value(SameRigidBodyPairFilter self, IMP::ParticlePair const & a) -> int
        get_value(SameRigidBodyPairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_spb.SameRigidBodyPairFilter_get_value(self, *args)

    def get_value_index(self, *args):
        r"""
        get_value_index(SameRigidBodyPairFilter self, Model m, IMP::ParticleIndexPair const & p) -> int
        get_value_index(SameRigidBodyPairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_spb.SameRigidBodyPairFilter_get_value_index(self, *args)

    def get_version_info(self):
        r"""get_version_info(SameRigidBodyPairFilter self) -> VersionInfo"""
        return _IMP_spb.SameRigidBodyPairFilter_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_SameRigidBodyPairFilter

    def __str__(self):
        r"""__str__(SameRigidBodyPairFilter self) -> std::string"""
        return _IMP_spb.SameRigidBodyPairFilter___str__(self)

    def __repr__(self):
        r"""__repr__(SameRigidBodyPairFilter self) -> std::string"""
        return _IMP_spb.SameRigidBodyPairFilter___repr__(self)

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


# Register SameRigidBodyPairFilter in _IMP_spb:
_IMP_spb.SameRigidBodyPairFilter_swigregister(SameRigidBodyPairFilter)
class TiltSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::spb::TiltSingletonScore 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 evaluate_index(self, m, p, da):
        r"""evaluate_index(TiltSingletonScore self, Model m, ParticleIndex p, DerivativeAccumulator da) -> double"""
        return _IMP_spb.TiltSingletonScore_evaluate_index(self, m, p, da)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(TiltSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.TiltSingletonScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(TiltSingletonScore 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_spb.TiltSingletonScore_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(TiltSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.TiltSingletonScore_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(TiltSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_spb.TiltSingletonScore_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(TiltSingletonScore 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_spb.TiltSingletonScore_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(TiltSingletonScore self) -> VersionInfo"""
        return _IMP_spb.TiltSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_TiltSingletonScore

    def show(self, *args):
        r"""show(TiltSingletonScore self, _ostream out=std::cout)"""
        return _IMP_spb.TiltSingletonScore_show(self, *args)

    def __str__(self):
        r"""__str__(TiltSingletonScore self) -> std::string"""
        return _IMP_spb.TiltSingletonScore___str__(self)

    def __repr__(self):
        r"""__repr__(TiltSingletonScore self) -> std::string"""
        return _IMP_spb.TiltSingletonScore___repr__(self)

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


# Register TiltSingletonScore in _IMP_spb:
_IMP_spb.TiltSingletonScore_swigregister(TiltSingletonScore)
class TransformationSymmetry(IMP.SingletonModifier):
    r"""Proxy of C++ IMP::spb::TransformationSymmetry class."""

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

    def __init__(self, t, px, py, pz):
        r"""__init__(TransformationSymmetry self, Transformation3D t, Particle px, Particle py, Particle pz) -> TransformationSymmetry"""
        _IMP_spb.TransformationSymmetry_swiginit(self, _IMP_spb.new_TransformationSymmetry(t, px, py, pz))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(TransformationSymmetry self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.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_spb.TransformationSymmetry_do_get_outputs(self, m, pis)

    def get_version_info(self):
        r"""get_version_info(TransformationSymmetry self) -> VersionInfo"""
        return _IMP_spb.TransformationSymmetry_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_TransformationSymmetry

    def show(self, *args):
        r"""show(TransformationSymmetry self, _ostream out=std::cout)"""
        return _IMP_spb.TransformationSymmetry_show(self, *args)

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

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

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


# Register TransformationSymmetry in _IMP_spb:
_IMP_spb.TransformationSymmetry_swigregister(TransformationSymmetry)
class TwoStateGoModelRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::spb::TwoStateGoModelRestraint class."""

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

    def __init__(self, ps, psA, psB, Beta, Delta, Cutoff):
        r"""__init__(TwoStateGoModelRestraint self, IMP::Particles ps, IMP::Particles psA, IMP::Particles psB, IMP::Float Beta, IMP::Float Delta, IMP::Float Cutoff) -> TwoStateGoModelRestraint"""
        _IMP_spb.TwoStateGoModelRestraint_swiginit(self, _IMP_spb.new_TwoStateGoModelRestraint(ps, psA, psB, Beta, Delta, Cutoff))

    def do_get_inputs(self):
        r"""do_get_inputs(TwoStateGoModelRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.TwoStateGoModelRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(TwoStateGoModelRestraint self) -> VersionInfo"""
        return _IMP_spb.TwoStateGoModelRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_TwoStateGoModelRestraint

    def __str__(self):
        r"""__str__(TwoStateGoModelRestraint self) -> std::string"""
        return _IMP_spb.TwoStateGoModelRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(TwoStateGoModelRestraint self) -> std::string"""
        return _IMP_spb.TwoStateGoModelRestraint___repr__(self)

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


# Register TwoStateGoModelRestraint in _IMP_spb:
_IMP_spb.TwoStateGoModelRestraint_swigregister(TwoStateGoModelRestraint)
class UniformBoundedRestraint(ISDRestraint):
    r"""Proxy of C++ IMP::spb::UniformBoundedRestraint class."""

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

    def __init__(self, p, fk, a, b):
        r"""__init__(UniformBoundedRestraint self, Particle p, FloatKey fk, Particle a, Particle b) -> UniformBoundedRestraint"""
        _IMP_spb.UniformBoundedRestraint_swiginit(self, _IMP_spb.new_UniformBoundedRestraint(p, fk, a, b))

    def do_get_inputs(self):
        r"""do_get_inputs(UniformBoundedRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_spb.UniformBoundedRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(UniformBoundedRestraint self) -> VersionInfo"""
        return _IMP_spb.UniformBoundedRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_spb.delete_UniformBoundedRestraint

    def __str__(self):
        r"""__str__(UniformBoundedRestraint self) -> std::string"""
        return _IMP_spb.UniformBoundedRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(UniformBoundedRestraint self) -> std::string"""
        return _IMP_spb.UniformBoundedRestraint___repr__(self)

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


# Register UniformBoundedRestraint in _IMP_spb:
_IMP_spb.UniformBoundedRestraint_swigregister(UniformBoundedRestraint)

def get_module_version():
    r"""get_module_version() -> std::string const"""
    return _IMP_spb.get_module_version()

def get_example_path(fname):
    r"""get_example_path(std::string fname) -> std::string"""
    return _IMP_spb.get_example_path(fname)

def get_data_path(fname):
    r"""get_data_path(std::string fname) -> std::string"""
    return _IMP_spb.get_data_path(fname)

from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()