pmi/__init__.py

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

from __future__ import print_function, division, absolute_import



from sys import version_info as _swig_python_version_info
import _IMP_pmi

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_PMI_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_PMI_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_pmi.delete_IMP_PMI_SwigPyIterator

    def value(self):
        r"""value(IMP_PMI_SwigPyIterator self) -> PyObject *"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(IMP_PMI_SwigPyIterator self, size_t n=1) -> IMP_PMI_SwigPyIterator"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(IMP_PMI_SwigPyIterator self, size_t n=1) -> IMP_PMI_SwigPyIterator"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(IMP_PMI_SwigPyIterator self, IMP_PMI_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(IMP_PMI_SwigPyIterator self, IMP_PMI_SwigPyIterator x) -> bool"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(IMP_PMI_SwigPyIterator self) -> IMP_PMI_SwigPyIterator"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_copy(self)

    def next(self):
        r"""next(IMP_PMI_SwigPyIterator self) -> PyObject *"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(IMP_PMI_SwigPyIterator self) -> PyObject *"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(IMP_PMI_SwigPyIterator self) -> PyObject *"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(IMP_PMI_SwigPyIterator self, ptrdiff_t n) -> IMP_PMI_SwigPyIterator"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(IMP_PMI_SwigPyIterator self, IMP_PMI_SwigPyIterator x) -> bool"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(IMP_PMI_SwigPyIterator self, IMP_PMI_SwigPyIterator x) -> bool"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(IMP_PMI_SwigPyIterator self, ptrdiff_t n) -> IMP_PMI_SwigPyIterator"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(IMP_PMI_SwigPyIterator self, ptrdiff_t n) -> IMP_PMI_SwigPyIterator"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(IMP_PMI_SwigPyIterator self, ptrdiff_t n) -> IMP_PMI_SwigPyIterator"""
        return _IMP_pmi.IMP_PMI_SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(IMP_PMI_SwigPyIterator self, ptrdiff_t n) -> IMP_PMI_SwigPyIterator
        __sub__(IMP_PMI_SwigPyIterator self, IMP_PMI_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_pmi.IMP_PMI_SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register IMP_PMI_SwigPyIterator in _IMP_pmi:
_IMP_pmi.IMP_PMI_SwigPyIterator_swigregister(IMP_PMI_SwigPyIterator)

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

IMP_DEBUG = _IMP_pmi.IMP_DEBUG

IMP_RELEASE = _IMP_pmi.IMP_RELEASE

IMP_SILENT = _IMP_pmi.IMP_SILENT

IMP_PROGRESS = _IMP_pmi.IMP_PROGRESS

IMP_TERSE = _IMP_pmi.IMP_TERSE

IMP_VERBOSE = _IMP_pmi.IMP_VERBOSE

IMP_MEMORY = _IMP_pmi.IMP_MEMORY

IMP_NONE = _IMP_pmi.IMP_NONE

IMP_USAGE = _IMP_pmi.IMP_USAGE

IMP_INTERNAL = _IMP_pmi.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_pmi.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_pmi.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_pmi.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_pmi.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_pmi.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_pmi.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_pmi.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_pmi.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_pmi.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_pmi.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_pmi.IMPKERNEL_SHOW_WARNINGS


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

class _ostream(object):
    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_pmi._ostream_write(self, osa_buf)

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

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_pmi.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_CGAL_HAS_BOOST_SYSTEM

IMP_CGAL_HAS_NUMPY = _IMP_pmi.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_pmi.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_pmi.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_pmi.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_ALGEBRA_HAS_BOOST_SYSTEM

IMP_ALGEBRA_HAS_CGAL = _IMP_pmi.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_pmi.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_pmi.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_pmi.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_pmi.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_pmi.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_DISPLAY_HAS_BOOST_SYSTEM

IMP_DISPLAY_HAS_CGAL = _IMP_pmi.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_pmi.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_pmi.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_pmi.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_pmi.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_pmi.IMP_STATISTICS_HAS_IMP_CGAL

IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_pmi.IMP_STATISTICS_HAS_BOOST_RANDOM

IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_STATISTICS_HAS_BOOST_SYSTEM

IMP_STATISTICS_HAS_CGAL = _IMP_pmi.IMP_STATISTICS_HAS_CGAL

IMP_STATISTICS_HAS_NUMPY = _IMP_pmi.IMP_STATISTICS_HAS_NUMPY

IMPSTATISTICS_SHOW_WARNINGS = _IMP_pmi.IMPSTATISTICS_SHOW_WARNINGS

import IMP.statistics
IMP_CORE_HAS_IMP_CGAL = _IMP_pmi.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_pmi.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_pmi.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_CORE_HAS_BOOST_SYSTEM

IMP_CORE_HAS_CGAL = _IMP_pmi.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_pmi.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_pmi.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_pmi.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_pmi.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_pmi.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_pmi.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_pmi.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_pmi.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_pmi.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_CONTAINER_HAS_BOOST_SYSTEM

IMP_CONTAINER_HAS_CGAL = _IMP_pmi.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_pmi.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_pmi.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_pmi.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_pmi.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_pmi.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_pmi.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
IMP_ATOM_HAS_IMP_CGAL = _IMP_pmi.IMP_ATOM_HAS_IMP_CGAL

IMP_ATOM_HAS_IMP_KERNEL = _IMP_pmi.IMP_ATOM_HAS_IMP_KERNEL

IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_pmi.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

IMP_ATOM_HAS_BOOST_RANDOM = _IMP_pmi.IMP_ATOM_HAS_BOOST_RANDOM

IMP_ATOM_HAS_BOOST_REGEX = _IMP_pmi.IMP_ATOM_HAS_BOOST_REGEX

IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_ATOM_HAS_BOOST_SYSTEM

IMP_ATOM_HAS_CGAL = _IMP_pmi.IMP_ATOM_HAS_CGAL

IMP_ATOM_HAS_HDF5 = _IMP_pmi.IMP_ATOM_HAS_HDF5

IMP_ATOM_HAS_NUMPY = _IMP_pmi.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_pmi.IMP_ATOM_HAS_PYTHON_IHM

IMPATOM_SHOW_WARNINGS = _IMP_pmi.IMPATOM_SHOW_WARNINGS

IMP_ATOM_TYPE_INDEX = _IMP_pmi.IMP_ATOM_TYPE_INDEX

IMP_RESIDUE_TYPE_INDEX = _IMP_pmi.IMP_RESIDUE_TYPE_INDEX

IMP_HIERARCHY_TYPE_INDEX = _IMP_pmi.IMP_HIERARCHY_TYPE_INDEX

IMP_CHAIN_TYPE_INDEX = _IMP_pmi.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_pmi.IMP_EM_HAS_IMP_CGAL

IMP_EM_HAS_IMP_CONTAINER = _IMP_pmi.IMP_EM_HAS_IMP_CONTAINER

IMP_EM_HAS_IMP_DISPLAY = _IMP_pmi.IMP_EM_HAS_IMP_DISPLAY

IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_pmi.IMP_EM_HAS_IMP_SCORE_FUNCTOR

IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_EM_HAS_BOOST_FILESYSTEM

IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_EM_HAS_BOOST_PROGRAMOPTIONS

IMP_EM_HAS_BOOST_RANDOM = _IMP_pmi.IMP_EM_HAS_BOOST_RANDOM

IMP_EM_HAS_BOOST_REGEX = _IMP_pmi.IMP_EM_HAS_BOOST_REGEX

IMP_EM_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_EM_HAS_BOOST_SYSTEM

IMP_EM_HAS_CGAL = _IMP_pmi.IMP_EM_HAS_CGAL

IMP_EM_HAS_HDF5 = _IMP_pmi.IMP_EM_HAS_HDF5

IMP_EM_HAS_NUMPY = _IMP_pmi.IMP_EM_HAS_NUMPY

IMP_EM_HAS_PYTHON_IHM = _IMP_pmi.IMP_EM_HAS_PYTHON_IHM

IMPEM_SHOW_WARNINGS = _IMP_pmi.IMPEM_SHOW_WARNINGS

import IMP.em
IMP_SAXS_HAS_IMP_CGAL = _IMP_pmi.IMP_SAXS_HAS_IMP_CGAL

IMP_SAXS_HAS_IMP_CONTAINER = _IMP_pmi.IMP_SAXS_HAS_IMP_CONTAINER

IMP_SAXS_HAS_IMP_DISPLAY = _IMP_pmi.IMP_SAXS_HAS_IMP_DISPLAY

IMP_SAXS_HAS_IMP_KERNEL = _IMP_pmi.IMP_SAXS_HAS_IMP_KERNEL

IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_pmi.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_SAXS_HAS_BOOST_FILESYSTEM

IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

IMP_SAXS_HAS_BOOST_RANDOM = _IMP_pmi.IMP_SAXS_HAS_BOOST_RANDOM

IMP_SAXS_HAS_BOOST_REGEX = _IMP_pmi.IMP_SAXS_HAS_BOOST_REGEX

IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_SAXS_HAS_BOOST_SYSTEM

IMP_SAXS_HAS_CGAL = _IMP_pmi.IMP_SAXS_HAS_CGAL

IMP_SAXS_HAS_HDF5 = _IMP_pmi.IMP_SAXS_HAS_HDF5

IMP_SAXS_HAS_NUMPY = _IMP_pmi.IMP_SAXS_HAS_NUMPY

IMP_SAXS_HAS_PYTHON_IHM = _IMP_pmi.IMP_SAXS_HAS_PYTHON_IHM

IMPSAXS_SHOW_WARNINGS = _IMP_pmi.IMPSAXS_SHOW_WARNINGS

import IMP.saxs
IMP_ISD_HAS_IMP_CGAL = _IMP_pmi.IMP_ISD_HAS_IMP_CGAL

IMP_ISD_HAS_IMP_DISPLAY = _IMP_pmi.IMP_ISD_HAS_IMP_DISPLAY

IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_pmi.IMP_ISD_HAS_IMP_SCORE_FUNCTOR

IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_ISD_HAS_BOOST_FILESYSTEM

IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS

IMP_ISD_HAS_BOOST_RANDOM = _IMP_pmi.IMP_ISD_HAS_BOOST_RANDOM

IMP_ISD_HAS_BOOST_REGEX = _IMP_pmi.IMP_ISD_HAS_BOOST_REGEX

IMP_ISD_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_ISD_HAS_BOOST_SYSTEM

IMP_ISD_HAS_CGAL = _IMP_pmi.IMP_ISD_HAS_CGAL

IMP_ISD_HAS_HDF5 = _IMP_pmi.IMP_ISD_HAS_HDF5

IMP_ISD_HAS_NUMPY = _IMP_pmi.IMP_ISD_HAS_NUMPY

IMP_ISD_HAS_PYTHON_IHM = _IMP_pmi.IMP_ISD_HAS_PYTHON_IHM

IMPISD_SHOW_WARNINGS = _IMP_pmi.IMPISD_SHOW_WARNINGS

import IMP.isd
IMP_PMI_HAS_IMP_ALGEBRA = _IMP_pmi.IMP_PMI_HAS_IMP_ALGEBRA

IMP_PMI_HAS_IMP_ATOM = _IMP_pmi.IMP_PMI_HAS_IMP_ATOM

IMP_PMI_HAS_IMP_CGAL = _IMP_pmi.IMP_PMI_HAS_IMP_CGAL

IMP_PMI_HAS_IMP_DISPLAY = _IMP_pmi.IMP_PMI_HAS_IMP_DISPLAY

IMP_PMI_HAS_IMP_EM = _IMP_pmi.IMP_PMI_HAS_IMP_EM

IMP_PMI_HAS_IMP_KERNEL = _IMP_pmi.IMP_PMI_HAS_IMP_KERNEL

IMP_PMI_HAS_IMP_SAXS = _IMP_pmi.IMP_PMI_HAS_IMP_SAXS

IMP_PMI_HAS_IMP_SCORE_FUNCTOR = _IMP_pmi.IMP_PMI_HAS_IMP_SCORE_FUNCTOR

IMP_PMI_HAS_IMP_STATISTICS = _IMP_pmi.IMP_PMI_HAS_IMP_STATISTICS

IMP_PMI_HAS_BOOST_FILESYSTEM = _IMP_pmi.IMP_PMI_HAS_BOOST_FILESYSTEM

IMP_PMI_HAS_BOOST_PROGRAMOPTIONS = _IMP_pmi.IMP_PMI_HAS_BOOST_PROGRAMOPTIONS

IMP_PMI_HAS_BOOST_RANDOM = _IMP_pmi.IMP_PMI_HAS_BOOST_RANDOM

IMP_PMI_HAS_BOOST_REGEX = _IMP_pmi.IMP_PMI_HAS_BOOST_REGEX

IMP_PMI_HAS_BOOST_SYSTEM = _IMP_pmi.IMP_PMI_HAS_BOOST_SYSTEM

IMP_PMI_HAS_CGAL = _IMP_pmi.IMP_PMI_HAS_CGAL

IMP_PMI_HAS_HDF5 = _IMP_pmi.IMP_PMI_HAS_HDF5

IMP_PMI_HAS_NUMPY = _IMP_pmi.IMP_PMI_HAS_NUMPY

IMP_PMI_HAS_PYTHON_IHM = _IMP_pmi.IMP_PMI_HAS_PYTHON_IHM

IMPPMI_SHOW_WARNINGS = _IMP_pmi.IMPPMI_SHOW_WARNINGS


_object_types.append("CompositeRestraint")


def _object_cast_to_CompositeRestraint(o):
    r"""_object_cast_to_CompositeRestraint(Object o) -> CompositeRestraint"""
    return _IMP_pmi._object_cast_to_CompositeRestraint(o)

_object_types.append("CrossLinkRestraintSet")


def _object_cast_to_CrossLinkRestraintSet(o):
    r"""_object_cast_to_CrossLinkRestraintSet(Object o) -> CrossLinkRestraintSet"""
    return _IMP_pmi._object_cast_to_CrossLinkRestraintSet(o)

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


_value_types.append("Uncertainty")


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


_value_types.append("Resolution")


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


_value_types.append("Symmetric")


_object_types.append("TransformMover")


def _object_cast_to_TransformMover(o):
    r"""_object_cast_to_TransformMover(Object o) -> TransformMover"""
    return _IMP_pmi._object_cast_to_TransformMover(o)

_object_types.append("MembraneRestraint")


def _object_cast_to_MembraneRestraint(o):
    r"""_object_cast_to_MembraneRestraint(Object o) -> MembraneRestraint"""
    return _IMP_pmi._object_cast_to_MembraneRestraint(o)

class StructureWarning(UserWarning):
    """Warning related to handling of structures"""
    pass


class ParameterWarning(UserWarning):
    """Warning for probably incorrect input parameters"""
    pass


class MissingFileWarning(UserWarning):
    """Warning for an expected, but missing, file"""
    pass

class MembraneRestraint(IMP.isd.ISDRestraint):
    r"""Proxy of C++ IMP::pmi::MembraneRestraint class."""

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

    def __init__(self, m, z_nuisance, thickness, softness, plateau, linear):
        r"""__init__(MembraneRestraint self, Model m, ParticleIndex z_nuisance, double thickness, double softness, double plateau, double linear) -> MembraneRestraint"""
        _IMP_pmi.MembraneRestraint_swiginit(self, _IMP_pmi.new_MembraneRestraint(m, z_nuisance, thickness, softness, plateau, linear))

    def add_particles_below(self, particles):
        r"""add_particles_below(MembraneRestraint self, IMP::ParticleIndexes const & particles)"""
        return _IMP_pmi.MembraneRestraint_add_particles_below(self, particles)

    def add_particles_above(self, particles):
        r"""add_particles_above(MembraneRestraint self, IMP::ParticleIndexes const & particles)"""
        return _IMP_pmi.MembraneRestraint_add_particles_above(self, particles)

    def add_particles_inside(self, particles):
        r"""add_particles_inside(MembraneRestraint self, IMP::ParticleIndexes const & particles)"""
        return _IMP_pmi.MembraneRestraint_add_particles_inside(self, particles)

    def get_score(self, prob):
        r"""get_score(MembraneRestraint self, double prob) -> double"""
        return _IMP_pmi.MembraneRestraint_get_score(self, prob)

    def get_probability_above(self, z, z_slope_center_upper):
        r"""get_probability_above(MembraneRestraint self, double z, double z_slope_center_upper) -> double"""
        return _IMP_pmi.MembraneRestraint_get_probability_above(self, z, z_slope_center_upper)

    def get_score_above(self, z, z_slope_center_upper):
        r"""get_score_above(MembraneRestraint self, double z, double z_slope_center_upper) -> double"""
        return _IMP_pmi.MembraneRestraint_get_score_above(self, z, z_slope_center_upper)

    def get_probability_below(self, z, z_slope_center_lower):
        r"""get_probability_below(MembraneRestraint self, double z, double z_slope_center_lower) -> double"""
        return _IMP_pmi.MembraneRestraint_get_probability_below(self, z, z_slope_center_lower)

    def get_score_below(self, z, z_slope_center_lower):
        r"""get_score_below(MembraneRestraint self, double z, double z_slope_center_lower) -> double"""
        return _IMP_pmi.MembraneRestraint_get_score_below(self, z, z_slope_center_lower)

    def get_score_inside(self, z, z_slope_center_lower, z_slope_center_upper):
        r"""get_score_inside(MembraneRestraint self, double z, double z_slope_center_lower, double z_slope_center_upper) -> double"""
        return _IMP_pmi.MembraneRestraint_get_score_inside(self, z, z_slope_center_lower, z_slope_center_upper)
    __swig_destroy__ = _IMP_pmi.delete_MembraneRestraint

    def __str__(self):
        r"""__str__(MembraneRestraint self) -> std::string"""
        return _IMP_pmi.MembraneRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(MembraneRestraint self) -> std::string"""
        return _IMP_pmi.MembraneRestraint___repr__(self)

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


# Register MembraneRestraint in _IMP_pmi:
_IMP_pmi.MembraneRestraint_swigregister(MembraneRestraint)
class CompositeRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::pmi::CompositeRestraint 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__(CompositeRestraint self, Model m, _ParticleIndexesAdaptor handle_particle_indexes, double coffd, double l, bool tabprob, double plateau, std::string name="CompositeRestraint%1%") -> CompositeRestraint"""
        _IMP_pmi.CompositeRestraint_swiginit(self, _IMP_pmi.new_CompositeRestraint(*args))

    def add_composite_particle(self, pi):
        r"""add_composite_particle(CompositeRestraint self, _ParticleIndexesAdaptor pi)"""
        return _IMP_pmi.CompositeRestraint_add_composite_particle(self, pi)

    def get_number_of_elements(self):
        r"""get_number_of_elements(CompositeRestraint self) -> unsigned int"""
        return _IMP_pmi.CompositeRestraint_get_number_of_elements(self)

    def do_get_inputs(self):
        r"""do_get_inputs(CompositeRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_pmi.CompositeRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(CompositeRestraint self) -> VersionInfo"""
        return _IMP_pmi.CompositeRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_pmi.delete_CompositeRestraint

    def get_probability(self):
        r"""get_probability(CompositeRestraint self) -> double"""
        return _IMP_pmi.CompositeRestraint_get_probability(self)

    def __str__(self):
        r"""__str__(CompositeRestraint self) -> std::string"""
        return _IMP_pmi.CompositeRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(CompositeRestraint self) -> std::string"""
        return _IMP_pmi.CompositeRestraint___repr__(self)

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


# Register CompositeRestraint in _IMP_pmi:
_IMP_pmi.CompositeRestraint_swigregister(CompositeRestraint)
class CrossLinkRestraintSet(IMP.RestraintSet):
    r"""Proxy of C++ IMP::pmi::CrossLinkRestraintSet 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__(CrossLinkRestraintSet self, Model m, std::string const & name="CrossLinkRestraintSet %1%") -> CrossLinkRestraintSet
        __init__(CrossLinkRestraintSet self) -> CrossLinkRestraintSet
        """
        _IMP_pmi.CrossLinkRestraintSet_swiginit(self, _IMP_pmi.new_CrossLinkRestraintSet(*args))

    def set_metadata(self, filename, length, slope):
        r"""set_metadata(CrossLinkRestraintSet self, std::string filename, double length, double slope)"""
        return _IMP_pmi.CrossLinkRestraintSet_set_metadata(self, filename, length, slope)

    def set_linker_auth_name(self, name):
        r"""set_linker_auth_name(CrossLinkRestraintSet self, std::string name)"""
        return _IMP_pmi.CrossLinkRestraintSet_set_linker_auth_name(self, name)

    def set_linker_chemical_name(self, name):
        r"""set_linker_chemical_name(CrossLinkRestraintSet self, std::string name)"""
        return _IMP_pmi.CrossLinkRestraintSet_set_linker_chemical_name(self, name)

    def set_linker_smiles(self, name):
        r"""set_linker_smiles(CrossLinkRestraintSet self, std::string name)"""
        return _IMP_pmi.CrossLinkRestraintSet_set_linker_smiles(self, name)

    def set_linker_smiles_canonical(self, name):
        r"""set_linker_smiles_canonical(CrossLinkRestraintSet self, std::string name)"""
        return _IMP_pmi.CrossLinkRestraintSet_set_linker_smiles_canonical(self, name)

    def set_linker_inchi(self, name):
        r"""set_linker_inchi(CrossLinkRestraintSet self, std::string name)"""
        return _IMP_pmi.CrossLinkRestraintSet_set_linker_inchi(self, name)

    def set_linker_inchi_key(self, name):
        r"""set_linker_inchi_key(CrossLinkRestraintSet self, std::string name)"""
        return _IMP_pmi.CrossLinkRestraintSet_set_linker_inchi_key(self, name)
    __swig_destroy__ = _IMP_pmi.delete_CrossLinkRestraintSet

    def __str__(self):
        r"""__str__(CrossLinkRestraintSet self) -> std::string"""
        return _IMP_pmi.CrossLinkRestraintSet___str__(self)

    def __repr__(self):
        r"""__repr__(CrossLinkRestraintSet self) -> std::string"""
        return _IMP_pmi.CrossLinkRestraintSet___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(CrossLinkRestraintSet self) -> PyObject *"""
        return _IMP_pmi.CrossLinkRestraintSet__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(CrossLinkRestraintSet self, PyObject * p)"""
        return _IMP_pmi.CrossLinkRestraintSet__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 CrossLinkRestraintSet in _IMP_pmi:
_IMP_pmi.CrossLinkRestraintSet_swigregister(CrossLinkRestraintSet)
class Uncertainty(IMP.Decorator):
    r"""Proxy of C++ IMP::pmi::Uncertainty class."""

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

    def get_uncertainty(self):
        r"""get_uncertainty(Uncertainty self) -> IMP::Float"""
        return _IMP_pmi.Uncertainty_get_uncertainty(self)

    def set_uncertainty(self, d):
        r"""set_uncertainty(Uncertainty self, IMP::Float d)"""
        return _IMP_pmi.Uncertainty_set_uncertainty(self, d)

    def __init__(self, *args):
        r"""
        __init__(Uncertainty self) -> Uncertainty
        __init__(Uncertainty self, Model m, ParticleIndex id) -> Uncertainty
        __init__(Uncertainty self, _ParticleAdaptor d) -> Uncertainty
        """
        _IMP_pmi.Uncertainty_swiginit(self, _IMP_pmi.new_Uncertainty(*args))

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

    def show(self, *args):
        r"""show(Uncertainty self, _ostream out=std::cout)"""
        return _IMP_pmi.Uncertainty_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, IMP::Float uncertainty) -> Uncertainty
        setup_particle(_ParticleAdaptor pa, IMP::Float uncertainty) -> Uncertainty
        """
        return _IMP_pmi.Uncertainty_setup_particle(*args)

    @staticmethod
    def get_uncertainty_key():
        r"""get_uncertainty_key() -> FloatKey"""
        return _IMP_pmi.Uncertainty_get_uncertainty_key()

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

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

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

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

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

    def get_derivative(self, a0):
        r"""get_derivative(Uncertainty self, FloatKey a0) -> double"""
        return _IMP_pmi.Uncertainty_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(Uncertainty self) -> std::string"""
        return _IMP_pmi.Uncertainty_get_name(self)

    def clear_caches(self):
        r"""clear_caches(Uncertainty self)"""
        return _IMP_pmi.Uncertainty_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(Uncertainty self, std::string a0)"""
        return _IMP_pmi.Uncertainty_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(Uncertainty self, IMP::CheckLevel a0)"""
        return _IMP_pmi.Uncertainty_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(Uncertainty self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_pmi.Uncertainty_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(Uncertainty self, FloatKey a0, bool a1)"""
        return _IMP_pmi.Uncertainty_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(Uncertainty self, FloatKey a0) -> bool"""
        return _IMP_pmi.Uncertainty_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(Uncertainty self) -> IMP::CheckLevel"""
        return _IMP_pmi.Uncertainty_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(Uncertainty self, Uncertainty o) -> bool
        __eq__(Uncertainty self, Particle d) -> bool
        """
        return _IMP_pmi.Uncertainty___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(Uncertainty self, Uncertainty o) -> bool
        __ne__(Uncertainty self, Particle d) -> bool
        """
        return _IMP_pmi.Uncertainty___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(Uncertainty self, Uncertainty o) -> bool
        __le__(Uncertainty self, Particle d) -> bool
        """
        return _IMP_pmi.Uncertainty___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(Uncertainty self, Uncertainty o) -> bool
        __lt__(Uncertainty self, Particle d) -> bool
        """
        return _IMP_pmi.Uncertainty___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(Uncertainty self, Uncertainty o) -> bool
        __ge__(Uncertainty self, Particle d) -> bool
        """
        return _IMP_pmi.Uncertainty___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(Uncertainty self, Uncertainty o) -> bool
        __gt__(Uncertainty self, Particle d) -> bool
        """
        return _IMP_pmi.Uncertainty___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(Uncertainty self) -> std::size_t"""
        return _IMP_pmi.Uncertainty___hash__(self)

    def __str__(self):
        r"""__str__(Uncertainty self) -> std::string"""
        return _IMP_pmi.Uncertainty___str__(self)

    def __repr__(self):
        r"""__repr__(Uncertainty self) -> std::string"""
        return _IMP_pmi.Uncertainty___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Uncertainty self) -> PyObject *"""
        return _IMP_pmi.Uncertainty__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Uncertainty self, PyObject * p)"""
        return _IMP_pmi.Uncertainty__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_pmi.delete_Uncertainty

# Register Uncertainty in _IMP_pmi:
_IMP_pmi.Uncertainty_swigregister(Uncertainty)
class Resolution(IMP.Decorator):
    r"""Proxy of C++ IMP::pmi::Resolution class."""

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

    def get_resolution(self):
        r"""get_resolution(Resolution self) -> IMP::Float"""
        return _IMP_pmi.Resolution_get_resolution(self)

    def set_resolution(self, d):
        r"""set_resolution(Resolution self, IMP::Float d)"""
        return _IMP_pmi.Resolution_set_resolution(self, d)

    def __init__(self, *args):
        r"""
        __init__(Resolution self) -> Resolution
        __init__(Resolution self, Model m, ParticleIndex id) -> Resolution
        __init__(Resolution self, _ParticleAdaptor d) -> Resolution
        """
        _IMP_pmi.Resolution_swiginit(self, _IMP_pmi.new_Resolution(*args))

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

    def show(self, *args):
        r"""show(Resolution self, _ostream out=std::cout)"""
        return _IMP_pmi.Resolution_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, IMP::Float resolution) -> Resolution
        setup_particle(_ParticleAdaptor pa, IMP::Float resolution) -> Resolution
        """
        return _IMP_pmi.Resolution_setup_particle(*args)

    @staticmethod
    def get_resolution_key():
        r"""get_resolution_key() -> FloatKey"""
        return _IMP_pmi.Resolution_get_resolution_key()

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

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

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

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

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

    def get_derivative(self, a0):
        r"""get_derivative(Resolution self, FloatKey a0) -> double"""
        return _IMP_pmi.Resolution_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(Resolution self) -> std::string"""
        return _IMP_pmi.Resolution_get_name(self)

    def clear_caches(self):
        r"""clear_caches(Resolution self)"""
        return _IMP_pmi.Resolution_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(Resolution self, std::string a0)"""
        return _IMP_pmi.Resolution_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(Resolution self, IMP::CheckLevel a0)"""
        return _IMP_pmi.Resolution_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(Resolution self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_pmi.Resolution_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(Resolution self, FloatKey a0, bool a1)"""
        return _IMP_pmi.Resolution_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(Resolution self, FloatKey a0) -> bool"""
        return _IMP_pmi.Resolution_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(Resolution self) -> IMP::CheckLevel"""
        return _IMP_pmi.Resolution_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(Resolution self, Resolution o) -> bool
        __eq__(Resolution self, Particle d) -> bool
        """
        return _IMP_pmi.Resolution___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(Resolution self, Resolution o) -> bool
        __ne__(Resolution self, Particle d) -> bool
        """
        return _IMP_pmi.Resolution___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(Resolution self, Resolution o) -> bool
        __le__(Resolution self, Particle d) -> bool
        """
        return _IMP_pmi.Resolution___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(Resolution self, Resolution o) -> bool
        __lt__(Resolution self, Particle d) -> bool
        """
        return _IMP_pmi.Resolution___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(Resolution self, Resolution o) -> bool
        __ge__(Resolution self, Particle d) -> bool
        """
        return _IMP_pmi.Resolution___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(Resolution self, Resolution o) -> bool
        __gt__(Resolution self, Particle d) -> bool
        """
        return _IMP_pmi.Resolution___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(Resolution self) -> std::size_t"""
        return _IMP_pmi.Resolution___hash__(self)

    def __str__(self):
        r"""__str__(Resolution self) -> std::string"""
        return _IMP_pmi.Resolution___str__(self)

    def __repr__(self):
        r"""__repr__(Resolution self) -> std::string"""
        return _IMP_pmi.Resolution___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Resolution self) -> PyObject *"""
        return _IMP_pmi.Resolution__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Resolution self, PyObject * p)"""
        return _IMP_pmi.Resolution__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_pmi.delete_Resolution

# Register Resolution in _IMP_pmi:
_IMP_pmi.Resolution_swigregister(Resolution)
class Symmetric(IMP.Decorator):
    r"""Proxy of C++ IMP::pmi::Symmetric class."""

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

    def get_symmetric(self):
        r"""get_symmetric(Symmetric self) -> IMP::Float"""
        return _IMP_pmi.Symmetric_get_symmetric(self)

    def set_symmetric(self, d):
        r"""set_symmetric(Symmetric self, IMP::Float d)"""
        return _IMP_pmi.Symmetric_set_symmetric(self, d)

    def __init__(self, *args):
        r"""
        __init__(Symmetric self) -> Symmetric
        __init__(Symmetric self, Model m, ParticleIndex id) -> Symmetric
        __init__(Symmetric self, _ParticleAdaptor d) -> Symmetric
        """
        _IMP_pmi.Symmetric_swiginit(self, _IMP_pmi.new_Symmetric(*args))

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

    def show(self, *args):
        r"""show(Symmetric self, _ostream out=std::cout)"""
        return _IMP_pmi.Symmetric_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, IMP::Float symmetric) -> Symmetric
        setup_particle(_ParticleAdaptor pa, IMP::Float symmetric) -> Symmetric
        """
        return _IMP_pmi.Symmetric_setup_particle(*args)

    @staticmethod
    def get_symmetric_key():
        r"""get_symmetric_key() -> FloatKey"""
        return _IMP_pmi.Symmetric_get_symmetric_key()

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

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

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

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

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

    def get_derivative(self, a0):
        r"""get_derivative(Symmetric self, FloatKey a0) -> double"""
        return _IMP_pmi.Symmetric_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(Symmetric self) -> std::string"""
        return _IMP_pmi.Symmetric_get_name(self)

    def clear_caches(self):
        r"""clear_caches(Symmetric self)"""
        return _IMP_pmi.Symmetric_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(Symmetric self, std::string a0)"""
        return _IMP_pmi.Symmetric_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(Symmetric self, IMP::CheckLevel a0)"""
        return _IMP_pmi.Symmetric_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(Symmetric self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_pmi.Symmetric_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(Symmetric self, FloatKey a0, bool a1)"""
        return _IMP_pmi.Symmetric_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(Symmetric self, FloatKey a0) -> bool"""
        return _IMP_pmi.Symmetric_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(Symmetric self) -> IMP::CheckLevel"""
        return _IMP_pmi.Symmetric_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(Symmetric self, Symmetric o) -> bool
        __eq__(Symmetric self, Particle d) -> bool
        """
        return _IMP_pmi.Symmetric___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(Symmetric self, Symmetric o) -> bool
        __ne__(Symmetric self, Particle d) -> bool
        """
        return _IMP_pmi.Symmetric___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(Symmetric self, Symmetric o) -> bool
        __le__(Symmetric self, Particle d) -> bool
        """
        return _IMP_pmi.Symmetric___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(Symmetric self, Symmetric o) -> bool
        __lt__(Symmetric self, Particle d) -> bool
        """
        return _IMP_pmi.Symmetric___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(Symmetric self, Symmetric o) -> bool
        __ge__(Symmetric self, Particle d) -> bool
        """
        return _IMP_pmi.Symmetric___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(Symmetric self, Symmetric o) -> bool
        __gt__(Symmetric self, Particle d) -> bool
        """
        return _IMP_pmi.Symmetric___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(Symmetric self) -> std::size_t"""
        return _IMP_pmi.Symmetric___hash__(self)

    def __str__(self):
        r"""__str__(Symmetric self) -> std::string"""
        return _IMP_pmi.Symmetric___str__(self)

    def __repr__(self):
        r"""__repr__(Symmetric self) -> std::string"""
        return _IMP_pmi.Symmetric___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Symmetric self) -> PyObject *"""
        return _IMP_pmi.Symmetric__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Symmetric self, PyObject * p)"""
        return _IMP_pmi.Symmetric__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_pmi.delete_Symmetric

# Register Symmetric in _IMP_pmi:
_IMP_pmi.Symmetric_swigregister(Symmetric)
class TransformMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::pmi::TransformMover 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__(TransformMover self, Model m, IMP::Float max_translation, IMP::Float max_rotation) -> TransformMover
        __init__(TransformMover self, Model m, Vector3D axis, IMP::Float max_translation, IMP::Float max_rotation) -> TransformMover
        __init__(TransformMover self, Model m, _ParticleIndexAdaptor p1i, _ParticleIndexAdaptor p2i, IMP::Float max_translation, IMP::Float max_rotation) -> TransformMover
        __init__(TransformMover self) -> TransformMover
        """
        _IMP_pmi.TransformMover_swiginit(self, _IMP_pmi.new_TransformMover(*args))

    def add_xyz_particle(self, pi):
        r"""add_xyz_particle(TransformMover self, _ParticleIndexAdaptor pi)"""
        return _IMP_pmi.TransformMover_add_xyz_particle(self, pi)

    def add_rigid_body_particle(self, pi):
        r"""add_rigid_body_particle(TransformMover self, _ParticleIndexAdaptor pi)"""
        return _IMP_pmi.TransformMover_add_rigid_body_particle(self, pi)

    def set_maximum_translation(self, mt):
        r"""set_maximum_translation(TransformMover self, IMP::Float mt)"""
        return _IMP_pmi.TransformMover_set_maximum_translation(self, mt)

    def set_maximum_rotation(self, mr):
        r"""set_maximum_rotation(TransformMover self, IMP::Float mr)"""
        return _IMP_pmi.TransformMover_set_maximum_rotation(self, mr)

    def get_maximum_translation(self):
        r"""get_maximum_translation(TransformMover self) -> IMP::Float"""
        return _IMP_pmi.TransformMover_get_maximum_translation(self)

    def get_maximum_rotation(self):
        r"""get_maximum_rotation(TransformMover self) -> IMP::Float"""
        return _IMP_pmi.TransformMover_get_maximum_rotation(self)

    def get_last_transformation(self):
        r"""get_last_transformation(TransformMover self) -> Transformation3D"""
        return _IMP_pmi.TransformMover_get_last_transformation(self)

    def get_version_info(self):
        r"""get_version_info(TransformMover self) -> VersionInfo"""
        return _IMP_pmi.TransformMover_get_version_info(self)
    __swig_destroy__ = _IMP_pmi.delete_TransformMover

    def __str__(self):
        r"""__str__(TransformMover self) -> std::string"""
        return _IMP_pmi.TransformMover___str__(self)

    def __repr__(self):
        r"""__repr__(TransformMover self) -> std::string"""
        return _IMP_pmi.TransformMover___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(TransformMover self) -> PyObject *"""
        return _IMP_pmi.TransformMover__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(TransformMover self, PyObject * p)"""
        return _IMP_pmi.TransformMover__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 TransformMover in _IMP_pmi:
_IMP_pmi.TransformMover_swigregister(TransformMover)

def create_elastic_network(ps, dist_cutoff, strength):
    r"""create_elastic_network(IMP::Particles const & ps, IMP::Float dist_cutoff, IMP::Float strength) -> RestraintSet"""
    return _IMP_pmi.create_elastic_network(ps, dist_cutoff, strength)

def get_dihedral_angle(p1, p2, p3, p4):
    r"""get_dihedral_angle(Atom p1, Atom p2, Atom p3, Atom p4) -> IMP::Float"""
    return _IMP_pmi.get_dihedral_angle(p1, p2, p3, p4)

def get_bipartite_minimum_sphere_distance(m1, m2):
    r"""get_bipartite_minimum_sphere_distance(IMP::core::XYZRs const & m1, IMP::core::XYZRs const & m2) -> IMP::Float"""
    return _IMP_pmi.get_bipartite_minimum_sphere_distance(m1, m2)

def get_list_of_bipartite_minimum_sphere_distance(pss):
    r"""get_list_of_bipartite_minimum_sphere_distance(IMP::ParticlesTemps const & pss) -> IMP::Floats"""
    return _IMP_pmi.get_list_of_bipartite_minimum_sphere_distance(pss)

def get_molecule_name_and_copy(h):
    r"""get_molecule_name_and_copy(Hierarchy h) -> std::string"""
    return _IMP_pmi.get_molecule_name_and_copy(h)

def get_is_canonical(h):
    r"""get_is_canonical(Hierarchy h) -> bool"""
    return _IMP_pmi.get_is_canonical(h)

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

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

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

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