multifit/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.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-2024 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_multifit

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_MULTIFIT_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_MULTIFIT_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_multifit.delete_IMP_MULTIFIT_SwigPyIterator

    def value(self):
        r"""value(IMP_MULTIFIT_SwigPyIterator self) -> PyObject *"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(IMP_MULTIFIT_SwigPyIterator self, size_t n=1) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(IMP_MULTIFIT_SwigPyIterator self, size_t n=1) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(IMP_MULTIFIT_SwigPyIterator self, IMP_MULTIFIT_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(IMP_MULTIFIT_SwigPyIterator self, IMP_MULTIFIT_SwigPyIterator x) -> bool"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(IMP_MULTIFIT_SwigPyIterator self) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_copy(self)

    def next(self):
        r"""next(IMP_MULTIFIT_SwigPyIterator self) -> PyObject *"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(IMP_MULTIFIT_SwigPyIterator self) -> PyObject *"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(IMP_MULTIFIT_SwigPyIterator self) -> PyObject *"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(IMP_MULTIFIT_SwigPyIterator self, ptrdiff_t n) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(IMP_MULTIFIT_SwigPyIterator self, IMP_MULTIFIT_SwigPyIterator x) -> bool"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(IMP_MULTIFIT_SwigPyIterator self, IMP_MULTIFIT_SwigPyIterator x) -> bool"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(IMP_MULTIFIT_SwigPyIterator self, ptrdiff_t n) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(IMP_MULTIFIT_SwigPyIterator self, ptrdiff_t n) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(IMP_MULTIFIT_SwigPyIterator self, ptrdiff_t n) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(IMP_MULTIFIT_SwigPyIterator self, ptrdiff_t n) -> IMP_MULTIFIT_SwigPyIterator
        __sub__(IMP_MULTIFIT_SwigPyIterator self, IMP_MULTIFIT_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register IMP_MULTIFIT_SwigPyIterator in _IMP_multifit:
_IMP_multifit.IMP_MULTIFIT_SwigPyIterator_swigregister(IMP_MULTIFIT_SwigPyIterator)

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

IMP_DEBUG = _IMP_multifit.IMP_DEBUG

IMP_RELEASE = _IMP_multifit.IMP_RELEASE

IMP_SILENT = _IMP_multifit.IMP_SILENT

IMP_PROGRESS = _IMP_multifit.IMP_PROGRESS

IMP_TERSE = _IMP_multifit.IMP_TERSE

IMP_VERBOSE = _IMP_multifit.IMP_VERBOSE

IMP_MEMORY = _IMP_multifit.IMP_MEMORY

IMP_NONE = _IMP_multifit.IMP_NONE

IMP_USAGE = _IMP_multifit.IMP_USAGE

IMP_INTERNAL = _IMP_multifit.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_multifit.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_multifit.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_multifit.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_multifit.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_multifit.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_multifit.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_multifit.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_multifit.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_multifit.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_multifit.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

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

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

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_multifit.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_CGAL_HAS_BOOST_SYSTEM

IMP_CGAL_HAS_NUMPY = _IMP_multifit.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_multifit.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_multifit.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_multifit.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_ALGEBRA_HAS_BOOST_SYSTEM

IMP_ALGEBRA_HAS_CGAL = _IMP_multifit.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_multifit.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_multifit.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_multifit.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_multifit.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_multifit.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_DISPLAY_HAS_BOOST_SYSTEM

IMP_DISPLAY_HAS_CGAL = _IMP_multifit.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_multifit.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_multifit.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_multifit.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_multifit.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_multifit.IMP_STATISTICS_HAS_IMP_CGAL

IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_multifit.IMP_STATISTICS_HAS_BOOST_RANDOM

IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_STATISTICS_HAS_BOOST_SYSTEM

IMP_STATISTICS_HAS_CGAL = _IMP_multifit.IMP_STATISTICS_HAS_CGAL

IMP_STATISTICS_HAS_NUMPY = _IMP_multifit.IMP_STATISTICS_HAS_NUMPY

IMPSTATISTICS_SHOW_WARNINGS = _IMP_multifit.IMPSTATISTICS_SHOW_WARNINGS

import IMP.statistics
IMP_CORE_HAS_IMP_CGAL = _IMP_multifit.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_multifit.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_multifit.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_CORE_HAS_BOOST_SYSTEM

IMP_CORE_HAS_CGAL = _IMP_multifit.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_multifit.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_multifit.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_multifit.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_multifit.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_multifit.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_multifit.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_multifit.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_multifit.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_CONTAINER_HAS_BOOST_SYSTEM

IMP_CONTAINER_HAS_CGAL = _IMP_multifit.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_multifit.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_multifit.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_multifit.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_multifit.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_multifit.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_multifit.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
IMP_ATOM_HAS_IMP_CGAL = _IMP_multifit.IMP_ATOM_HAS_IMP_CGAL

IMP_ATOM_HAS_IMP_KERNEL = _IMP_multifit.IMP_ATOM_HAS_IMP_KERNEL

IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

IMP_ATOM_HAS_BOOST_RANDOM = _IMP_multifit.IMP_ATOM_HAS_BOOST_RANDOM

IMP_ATOM_HAS_BOOST_REGEX = _IMP_multifit.IMP_ATOM_HAS_BOOST_REGEX

IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_ATOM_HAS_BOOST_SYSTEM

IMP_ATOM_HAS_CGAL = _IMP_multifit.IMP_ATOM_HAS_CGAL

IMP_ATOM_HAS_HDF5 = _IMP_multifit.IMP_ATOM_HAS_HDF5

IMP_ATOM_HAS_NUMPY = _IMP_multifit.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_multifit.IMP_ATOM_HAS_PYTHON_IHM

IMPATOM_SHOW_WARNINGS = _IMP_multifit.IMPATOM_SHOW_WARNINGS

IMP_ATOM_TYPE_INDEX = _IMP_multifit.IMP_ATOM_TYPE_INDEX

IMP_RESIDUE_TYPE_INDEX = _IMP_multifit.IMP_RESIDUE_TYPE_INDEX

IMP_HIERARCHY_TYPE_INDEX = _IMP_multifit.IMP_HIERARCHY_TYPE_INDEX

IMP_CHAIN_TYPE_INDEX = _IMP_multifit.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_multifit.IMP_EM_HAS_IMP_CGAL

IMP_EM_HAS_IMP_CONTAINER = _IMP_multifit.IMP_EM_HAS_IMP_CONTAINER

IMP_EM_HAS_IMP_DISPLAY = _IMP_multifit.IMP_EM_HAS_IMP_DISPLAY

IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_EM_HAS_IMP_SCORE_FUNCTOR

IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_EM_HAS_BOOST_FILESYSTEM

IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_EM_HAS_BOOST_PROGRAMOPTIONS

IMP_EM_HAS_BOOST_RANDOM = _IMP_multifit.IMP_EM_HAS_BOOST_RANDOM

IMP_EM_HAS_BOOST_REGEX = _IMP_multifit.IMP_EM_HAS_BOOST_REGEX

IMP_EM_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_EM_HAS_BOOST_SYSTEM

IMP_EM_HAS_CGAL = _IMP_multifit.IMP_EM_HAS_CGAL

IMP_EM_HAS_HDF5 = _IMP_multifit.IMP_EM_HAS_HDF5

IMP_EM_HAS_NUMPY = _IMP_multifit.IMP_EM_HAS_NUMPY

IMP_EM_HAS_PYTHON_IHM = _IMP_multifit.IMP_EM_HAS_PYTHON_IHM

IMPEM_SHOW_WARNINGS = _IMP_multifit.IMPEM_SHOW_WARNINGS

import IMP.em
IMP_SAXS_HAS_IMP_CGAL = _IMP_multifit.IMP_SAXS_HAS_IMP_CGAL

IMP_SAXS_HAS_IMP_CONTAINER = _IMP_multifit.IMP_SAXS_HAS_IMP_CONTAINER

IMP_SAXS_HAS_IMP_DISPLAY = _IMP_multifit.IMP_SAXS_HAS_IMP_DISPLAY

IMP_SAXS_HAS_IMP_KERNEL = _IMP_multifit.IMP_SAXS_HAS_IMP_KERNEL

IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_SAXS_HAS_BOOST_FILESYSTEM

IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

IMP_SAXS_HAS_BOOST_RANDOM = _IMP_multifit.IMP_SAXS_HAS_BOOST_RANDOM

IMP_SAXS_HAS_BOOST_REGEX = _IMP_multifit.IMP_SAXS_HAS_BOOST_REGEX

IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_SAXS_HAS_BOOST_SYSTEM

IMP_SAXS_HAS_CGAL = _IMP_multifit.IMP_SAXS_HAS_CGAL

IMP_SAXS_HAS_HDF5 = _IMP_multifit.IMP_SAXS_HAS_HDF5

IMP_SAXS_HAS_NUMPY = _IMP_multifit.IMP_SAXS_HAS_NUMPY

IMP_SAXS_HAS_PYTHON_IHM = _IMP_multifit.IMP_SAXS_HAS_PYTHON_IHM

IMPSAXS_SHOW_WARNINGS = _IMP_multifit.IMPSAXS_SHOW_WARNINGS

import IMP.saxs
IMP_ISD_HAS_IMP_CGAL = _IMP_multifit.IMP_ISD_HAS_IMP_CGAL

IMP_ISD_HAS_IMP_DISPLAY = _IMP_multifit.IMP_ISD_HAS_IMP_DISPLAY

IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_ISD_HAS_IMP_SCORE_FUNCTOR

IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_ISD_HAS_BOOST_FILESYSTEM

IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS

IMP_ISD_HAS_BOOST_RANDOM = _IMP_multifit.IMP_ISD_HAS_BOOST_RANDOM

IMP_ISD_HAS_BOOST_REGEX = _IMP_multifit.IMP_ISD_HAS_BOOST_REGEX

IMP_ISD_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_ISD_HAS_BOOST_SYSTEM

IMP_ISD_HAS_CGAL = _IMP_multifit.IMP_ISD_HAS_CGAL

IMP_ISD_HAS_HDF5 = _IMP_multifit.IMP_ISD_HAS_HDF5

IMP_ISD_HAS_NUMPY = _IMP_multifit.IMP_ISD_HAS_NUMPY

IMP_ISD_HAS_PYTHON_IHM = _IMP_multifit.IMP_ISD_HAS_PYTHON_IHM

IMPISD_SHOW_WARNINGS = _IMP_multifit.IMPISD_SHOW_WARNINGS

import IMP.isd
IMP_RMF_HAS_IMP_CGAL = _IMP_multifit.IMP_RMF_HAS_IMP_CGAL

IMP_RMF_HAS_IMP_EM = _IMP_multifit.IMP_RMF_HAS_IMP_EM

IMP_RMF_HAS_IMP_SAXS = _IMP_multifit.IMP_RMF_HAS_IMP_SAXS

IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_RMF_HAS_IMP_SCORE_FUNCTOR

IMP_RMF_HAS_IMP_STATISTICS = _IMP_multifit.IMP_RMF_HAS_IMP_STATISTICS

IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_RMF_HAS_BOOST_FILESYSTEM

IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS

IMP_RMF_HAS_BOOST_RANDOM = _IMP_multifit.IMP_RMF_HAS_BOOST_RANDOM

IMP_RMF_HAS_BOOST_REGEX = _IMP_multifit.IMP_RMF_HAS_BOOST_REGEX

IMP_RMF_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_RMF_HAS_BOOST_SYSTEM

IMP_RMF_HAS_CGAL = _IMP_multifit.IMP_RMF_HAS_CGAL

IMP_RMF_HAS_HDF5 = _IMP_multifit.IMP_RMF_HAS_HDF5

IMP_RMF_HAS_NUMPY = _IMP_multifit.IMP_RMF_HAS_NUMPY

IMP_RMF_HAS_PYTHON_IHM = _IMP_multifit.IMP_RMF_HAS_PYTHON_IHM

IMPRMF_SHOW_WARNINGS = _IMP_multifit.IMPRMF_SHOW_WARNINGS

import IMP.rmf
import RMF
IMP_DOMINO_HAS_IMP_ATOM = _IMP_multifit.IMP_DOMINO_HAS_IMP_ATOM

IMP_DOMINO_HAS_IMP_CGAL = _IMP_multifit.IMP_DOMINO_HAS_IMP_CGAL

IMP_DOMINO_HAS_IMP_EM = _IMP_multifit.IMP_DOMINO_HAS_IMP_EM

IMP_DOMINO_HAS_IMP_ISD = _IMP_multifit.IMP_DOMINO_HAS_IMP_ISD

IMP_DOMINO_HAS_IMP_KERNEL = _IMP_multifit.IMP_DOMINO_HAS_IMP_KERNEL

IMP_DOMINO_HAS_IMP_RMF = _IMP_multifit.IMP_DOMINO_HAS_IMP_RMF

IMP_DOMINO_HAS_IMP_SAXS = _IMP_multifit.IMP_DOMINO_HAS_IMP_SAXS

IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR

IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_multifit.IMP_DOMINO_HAS_BOOST_FILESYSTEM

IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS

IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_multifit.IMP_DOMINO_HAS_BOOST_RANDOM

IMP_DOMINO_HAS_BOOST_REGEX = _IMP_multifit.IMP_DOMINO_HAS_BOOST_REGEX

IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_DOMINO_HAS_BOOST_SYSTEM

IMP_DOMINO_HAS_CGAL = _IMP_multifit.IMP_DOMINO_HAS_CGAL

IMP_DOMINO_HAS_HDF5 = _IMP_multifit.IMP_DOMINO_HAS_HDF5

IMP_DOMINO_HAS_NUMPY = _IMP_multifit.IMP_DOMINO_HAS_NUMPY

IMP_DOMINO_HAS_RMF = _IMP_multifit.IMP_DOMINO_HAS_RMF

IMP_DOMINO_HAS_PYTHON_IHM = _IMP_multifit.IMP_DOMINO_HAS_PYTHON_IHM

IMPDOMINO_SHOW_WARNINGS = _IMP_multifit.IMPDOMINO_SHOW_WARNINGS

import RMF_HDF5
import IMP.domino
IMP_MULTIFIT_HAS_IMP_CGAL = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_CGAL

IMP_MULTIFIT_HAS_IMP_CONTAINER = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_CONTAINER

IMP_MULTIFIT_HAS_IMP_DISPLAY = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_DISPLAY

IMP_MULTIFIT_HAS_IMP_ISD = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_ISD

IMP_MULTIFIT_HAS_IMP_KERNEL = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_KERNEL

IMP_MULTIFIT_HAS_IMP_RMF = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_RMF

IMP_MULTIFIT_HAS_IMP_SAXS = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_SAXS

IMP_MULTIFIT_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_SCORE_FUNCTOR

IMP_MULTIFIT_HAS_BOOST_GRAPH = _IMP_multifit.IMP_MULTIFIT_HAS_BOOST_GRAPH

IMP_MULTIFIT_HAS_BOOST_RANDOM = _IMP_multifit.IMP_MULTIFIT_HAS_BOOST_RANDOM

IMP_MULTIFIT_HAS_BOOST_REGEX = _IMP_multifit.IMP_MULTIFIT_HAS_BOOST_REGEX

IMP_MULTIFIT_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_MULTIFIT_HAS_BOOST_SYSTEM

IMP_MULTIFIT_HAS_CGAL = _IMP_multifit.IMP_MULTIFIT_HAS_CGAL

IMP_MULTIFIT_HAS_HDF5 = _IMP_multifit.IMP_MULTIFIT_HAS_HDF5

IMP_MULTIFIT_HAS_NUMPY = _IMP_multifit.IMP_MULTIFIT_HAS_NUMPY

IMP_MULTIFIT_HAS_RMF = _IMP_multifit.IMP_MULTIFIT_HAS_RMF

IMP_MULTIFIT_HAS_PYTHON_IHM = _IMP_multifit.IMP_MULTIFIT_HAS_PYTHON_IHM

IMPMULTIFIT_SHOW_WARNINGS = _IMP_multifit.IMPMULTIFIT_SHOW_WARNINGS


_object_types.append("RadiusOfGyrationRestraint")


def _object_cast_to_RadiusOfGyrationRestraint(o):
    r"""_object_cast_to_RadiusOfGyrationRestraint(Object o) -> RadiusOfGyrationRestraint"""
    return _IMP_multifit._object_cast_to_RadiusOfGyrationRestraint(o)

_object_types.append("ComponentHeader")


def _object_cast_to_ComponentHeader(o):
    r"""_object_cast_to_ComponentHeader(Object o) -> ComponentHeader"""
    return _IMP_multifit._object_cast_to_ComponentHeader(o)

_object_types.append("AssemblyHeader")


def _object_cast_to_AssemblyHeader(o):
    r"""_object_cast_to_AssemblyHeader(Object o) -> AssemblyHeader"""
    return _IMP_multifit._object_cast_to_AssemblyHeader(o)

_object_types.append("SettingsData")


def _object_cast_to_SettingsData(o):
    r"""_object_cast_to_SettingsData(Object o) -> SettingsData"""
    return _IMP_multifit._object_cast_to_SettingsData(o)

_object_types.append("WeightedExcludedVolumeRestraint")


def _object_cast_to_WeightedExcludedVolumeRestraint(o):
    r"""_object_cast_to_WeightedExcludedVolumeRestraint(Object o) -> WeightedExcludedVolumeRestraint"""
    return _IMP_multifit._object_cast_to_WeightedExcludedVolumeRestraint(o)

_object_types.append("ComplementarityRestraint")


def _object_cast_to_ComplementarityRestraint(o):
    r"""_object_cast_to_ComplementarityRestraint(Object o) -> ComplementarityRestraint"""
    return _IMP_multifit._object_cast_to_ComplementarityRestraint(o)

ProteinRecordDataList=list
_plural_types.append("ProteinRecordDataList")
_value_types.append("ProteinRecordData")


FittingSolutionRecords=list
_plural_types.append("FittingSolutionRecords")
_value_types.append("FittingSolutionRecord")


AnchorsDataList=list
_plural_types.append("AnchorsDataList")
_value_types.append("AnchorsData")


DominoParamsList=list
_plural_types.append("DominoParamsList")
_value_types.append("DominoParams")


ComplementarityParamsList=list
_plural_types.append("ComplementarityParamsList")
_value_types.append("ComplementarityParams")


XlinkParamsList=list
_plural_types.append("XlinkParamsList")
_value_types.append("XlinkParams")


ConnectivityParamsList=list
_plural_types.append("ConnectivityParamsList")
_value_types.append("ConnectivityParams")


FragmentsParamsList=list
_plural_types.append("FragmentsParamsList")
_value_types.append("FragmentsParams")


RogParamsList=list
_plural_types.append("RogParamsList")
_value_types.append("RogParams")


EVParamsList=list
_plural_types.append("EVParamsList")
_value_types.append("EVParams")


FiltersParamsList=list
_plural_types.append("FiltersParamsList")
_value_types.append("FiltersParams")


AlignmentParamsList=list
_plural_types.append("AlignmentParamsList")
_value_types.append("AlignmentParams")


FittingParamsList=list
_plural_types.append("FittingParamsList")
_value_types.append("FittingParams")


ProteinsAnchorsSamplingSpaces=list
_plural_types.append("ProteinsAnchorsSamplingSpaces")
_value_types.append("ProteinsAnchorsSamplingSpace")


_object_types.append("ProteomicsData")


def _object_cast_to_ProteomicsData(o):
    r"""_object_cast_to_ProteomicsData(Object o) -> ProteomicsData"""
    return _IMP_multifit._object_cast_to_ProteomicsData(o)

_object_types.append("FFTFitting")


def _object_cast_to_FFTFitting(o):
    r"""_object_cast_to_FFTFitting(Object o) -> FFTFitting"""
    return _IMP_multifit._object_cast_to_FFTFitting(o)

_object_types.append("FFTFittingOutput")


def _object_cast_to_FFTFittingOutput(o):
    r"""_object_cast_to_FFTFittingOutput(Object o) -> FFTFittingOutput"""
    return _IMP_multifit._object_cast_to_FFTFittingOutput(o)

_object_types.append("ProbabilisticAnchorGraph")


def _object_cast_to_ProbabilisticAnchorGraph(o):
    r"""_object_cast_to_ProbabilisticAnchorGraph(Object o) -> ProbabilisticAnchorGraph"""
    return _IMP_multifit._object_cast_to_ProbabilisticAnchorGraph(o)

_object_types.append("Ensemble")


def _object_cast_to_Ensemble(o):
    r"""_object_cast_to_Ensemble(Object o) -> Ensemble"""
    return _IMP_multifit._object_cast_to_Ensemble(o)

_object_types.append("ProteomicsEMAlignmentAtomic")


def _object_cast_to_ProteomicsEMAlignmentAtomic(o):
    r"""_object_cast_to_ProteomicsEMAlignmentAtomic(Object o) -> ProteomicsEMAlignmentAtomic"""
    return _IMP_multifit._object_cast_to_ProteomicsEMAlignmentAtomic(o)

_object_types.append("RigidLeavesRefiner")


def _object_cast_to_RigidLeavesRefiner(o):
    r"""_object_cast_to_RigidLeavesRefiner(Object o) -> RigidLeavesRefiner"""
    return _IMP_multifit._object_cast_to_RigidLeavesRefiner(o)

def add_surface_index(*args):
    r"""add_surface_index(Hierarchy mhd, IMP::Float apix, FloatKey shell_key=IMP::FloatKey("surf_ind"), FloatKey radius_key=IMP::core::XYZR::get_radius_key(), FloatKey weight_key=IMP::atom::Mass::get_mass_key())"""
    return _IMP_multifit.add_surface_index(*args)

def create_weighted_excluded_volume_restraint(*args):
    r"""create_weighted_excluded_volume_restraint(RigidBody rb1, RigidBody rb2, FloatKey shell_key=IMP::FloatKey("surf_ind")) -> Restraint"""
    return _IMP_multifit.create_weighted_excluded_volume_restraint(*args)
class FittingSolutionRecord(object):
    r"""Proxy of C++ IMP::multifit::FittingSolutionRecord class."""

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

    def __init__(self):
        r"""__init__(FittingSolutionRecord self) -> FittingSolutionRecord"""
        _IMP_multifit.FittingSolutionRecord_swiginit(self, _IMP_multifit.new_FittingSolutionRecord())

    def get_index(self):
        r"""get_index(FittingSolutionRecord self) -> unsigned int"""
        return _IMP_multifit.FittingSolutionRecord_get_index(self)

    def set_index(self, new_ind):
        r"""set_index(FittingSolutionRecord self, unsigned int new_ind)"""
        return _IMP_multifit.FittingSolutionRecord_set_index(self, new_ind)

    def get_solution_filename(self):
        r"""get_solution_filename(FittingSolutionRecord self) -> std::string"""
        return _IMP_multifit.FittingSolutionRecord_get_solution_filename(self)

    def set_solution_filename(self, sol_fn):
        r"""set_solution_filename(FittingSolutionRecord self, std::string sol_fn)"""
        return _IMP_multifit.FittingSolutionRecord_set_solution_filename(self, sol_fn)

    def get_fit_transformation(self):
        r"""get_fit_transformation(FittingSolutionRecord self) -> Transformation3D"""
        return _IMP_multifit.FittingSolutionRecord_get_fit_transformation(self)

    def set_fit_transformation(self, t):
        r"""set_fit_transformation(FittingSolutionRecord self, Transformation3D t)"""
        return _IMP_multifit.FittingSolutionRecord_set_fit_transformation(self, t)

    def get_match_size(self):
        r"""get_match_size(FittingSolutionRecord self) -> unsigned int"""
        return _IMP_multifit.FittingSolutionRecord_get_match_size(self)

    def set_match_size(self, match_size):
        r"""set_match_size(FittingSolutionRecord self, unsigned int match_size)"""
        return _IMP_multifit.FittingSolutionRecord_set_match_size(self, match_size)

    def get_match_average_distance(self):
        r"""get_match_average_distance(FittingSolutionRecord self) -> IMP::Float"""
        return _IMP_multifit.FittingSolutionRecord_get_match_average_distance(self)

    def set_match_average_distance(self, match_avg_dist):
        r"""set_match_average_distance(FittingSolutionRecord self, IMP::Float match_avg_dist)"""
        return _IMP_multifit.FittingSolutionRecord_set_match_average_distance(self, match_avg_dist)

    def get_fitting_score(self):
        r"""get_fitting_score(FittingSolutionRecord self) -> IMP::Float"""
        return _IMP_multifit.FittingSolutionRecord_get_fitting_score(self)

    def set_fitting_score(self, fit_score):
        r"""set_fitting_score(FittingSolutionRecord self, IMP::Float fit_score)"""
        return _IMP_multifit.FittingSolutionRecord_set_fitting_score(self, fit_score)

    def get_rmsd_to_reference(self):
        r"""get_rmsd_to_reference(FittingSolutionRecord self) -> IMP::Float"""
        return _IMP_multifit.FittingSolutionRecord_get_rmsd_to_reference(self)

    def set_rmsd_to_reference(self, rmsd_to_ref):
        r"""set_rmsd_to_reference(FittingSolutionRecord self, IMP::Float rmsd_to_ref)"""
        return _IMP_multifit.FittingSolutionRecord_set_rmsd_to_reference(self, rmsd_to_ref)

    def get_dock_transformation(self):
        r"""get_dock_transformation(FittingSolutionRecord self) -> Transformation3D"""
        return _IMP_multifit.FittingSolutionRecord_get_dock_transformation(self)

    def set_dock_transformation(self, t):
        r"""set_dock_transformation(FittingSolutionRecord self, Transformation3D t)"""
        return _IMP_multifit.FittingSolutionRecord_set_dock_transformation(self, t)

    def get_envelope_penetration_score(self):
        r"""get_envelope_penetration_score(FittingSolutionRecord self) -> IMP::Float"""
        return _IMP_multifit.FittingSolutionRecord_get_envelope_penetration_score(self)

    def set_envelope_penetration_score(self, s):
        r"""set_envelope_penetration_score(FittingSolutionRecord self, IMP::Float s)"""
        return _IMP_multifit.FittingSolutionRecord_set_envelope_penetration_score(self, s)

    def show(self, *args):
        r"""show(FittingSolutionRecord self, _ostream out=std::cout)"""
        return _IMP_multifit.FittingSolutionRecord_show(self, *args)

    @staticmethod
    def get_record_header():
        r"""get_record_header() -> std::string"""
        return _IMP_multifit.FittingSolutionRecord_get_record_header()

    def __str__(self):
        r"""__str__(FittingSolutionRecord self) -> std::string"""
        return _IMP_multifit.FittingSolutionRecord___str__(self)

    def __repr__(self):
        r"""__repr__(FittingSolutionRecord self) -> std::string"""
        return _IMP_multifit.FittingSolutionRecord___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(FittingSolutionRecord self) -> PyObject *"""
        return _IMP_multifit.FittingSolutionRecord__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(FittingSolutionRecord self, PyObject * p)"""
        return _IMP_multifit.FittingSolutionRecord__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_multifit.delete_FittingSolutionRecord

# Register FittingSolutionRecord in _IMP_multifit:
_IMP_multifit.FittingSolutionRecord_swigregister(FittingSolutionRecord)

def pca_based_rigid_fitting(*args):
    r"""
    pca_based_rigid_fitting(RigidBody rb, Refiner rb_refiner, DensityMap em_map, IMP::Float threshold, FloatKey wei_key=IMP::atom::Mass::get_mass_key(), PrincipalComponentAnalysis3D dens_pca_input=IMP::algebra::PrincipalComponentAnalysis()) -> FittingSolutions
    pca_based_rigid_fitting(IMP::ParticlesTemp ps, DensityMap em_map, IMP::Float threshold, FloatKey wei_key=IMP::atom::Mass::get_mass_key(), PrincipalComponentAnalysis3D dens_pca_input=IMP::algebra::PrincipalComponentAnalysis()) -> FittingSolutions
    """
    return _IMP_multifit.pca_based_rigid_fitting(*args)

def write_markers(pca, out):
    r"""write_markers(PrincipalComponentAnalysis3D pca, _ostream out)"""
    return _IMP_multifit.write_markers(pca, out)
class ComponentHeader(IMP.Object):
    r"""Proxy of C++ IMP::multifit::ComponentHeader class."""

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

    def __init__(self):
        r"""__init__(ComponentHeader self) -> ComponentHeader"""
        _IMP_multifit.ComponentHeader_swiginit(self, _IMP_multifit.new_ComponentHeader())

    def set_name(self, name):
        r"""set_name(ComponentHeader self, std::string const & name)"""
        return _IMP_multifit.ComponentHeader_set_name(self, name)

    def get_name(self):
        r"""get_name(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_name(self)

    def get_filename(self):
        r"""get_filename(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_filename(self)

    def set_filename(self, filename):
        r"""set_filename(ComponentHeader self, std::string const & filename)"""
        return _IMP_multifit.ComponentHeader_set_filename(self, filename)

    def get_surface_fn(self):
        r"""get_surface_fn(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_surface_fn(self)

    def set_surface_fn(self, fn):
        r"""set_surface_fn(ComponentHeader self, std::string const & fn)"""
        return _IMP_multifit.ComponentHeader_set_surface_fn(self, fn)

    def set_txt_ap_fn(self, pdb_ap_fn):
        r"""set_txt_ap_fn(ComponentHeader self, std::string const & pdb_ap_fn)"""
        return _IMP_multifit.ComponentHeader_set_txt_ap_fn(self, pdb_ap_fn)

    def get_txt_ap_fn(self):
        r"""get_txt_ap_fn(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_txt_ap_fn(self)

    def set_txt_fine_ap_fn(self, pdb_ap_fn):
        r"""set_txt_fine_ap_fn(ComponentHeader self, std::string const & pdb_ap_fn)"""
        return _IMP_multifit.ComponentHeader_set_txt_fine_ap_fn(self, pdb_ap_fn)

    def get_txt_fine_ap_fn(self):
        r"""get_txt_fine_ap_fn(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_txt_fine_ap_fn(self)

    def set_num_ap(self, num_ap):
        r"""set_num_ap(ComponentHeader self, int num_ap)"""
        return _IMP_multifit.ComponentHeader_set_num_ap(self, num_ap)

    def get_num_ap(self):
        r"""get_num_ap(ComponentHeader self) -> int"""
        return _IMP_multifit.ComponentHeader_get_num_ap(self)

    def set_num_fine_ap(self, num_ap):
        r"""set_num_fine_ap(ComponentHeader self, int num_ap)"""
        return _IMP_multifit.ComponentHeader_set_num_fine_ap(self, num_ap)

    def get_num_fine_ap(self):
        r"""get_num_fine_ap(ComponentHeader self) -> int"""
        return _IMP_multifit.ComponentHeader_get_num_fine_ap(self)

    def set_transformations_fn(self, transformations_fn):
        r"""set_transformations_fn(ComponentHeader self, std::string transformations_fn)"""
        return _IMP_multifit.ComponentHeader_set_transformations_fn(self, transformations_fn)

    def get_transformations_fn(self):
        r"""get_transformations_fn(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_transformations_fn(self)

    def set_reference_fn(self, ref_fn):
        r"""set_reference_fn(ComponentHeader self, std::string const & ref_fn)"""
        return _IMP_multifit.ComponentHeader_set_reference_fn(self, ref_fn)

    def get_reference_fn(self):
        r"""get_reference_fn(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_reference_fn(self)

    def get_version_info(self):
        r"""get_version_info(ComponentHeader self) -> VersionInfo"""
        return _IMP_multifit.ComponentHeader_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_ComponentHeader

    def __str__(self):
        r"""__str__(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader___str__(self)

    def __repr__(self):
        r"""__repr__(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader___repr__(self)

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


# Register ComponentHeader in _IMP_multifit:
_IMP_multifit.ComponentHeader_swigregister(ComponentHeader)
class AssemblyHeader(IMP.Object):
    r"""Proxy of C++ IMP::multifit::AssemblyHeader class."""

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

    def __init__(self):
        r"""__init__(AssemblyHeader self) -> AssemblyHeader"""
        _IMP_multifit.AssemblyHeader_swiginit(self, _IMP_multifit.new_AssemblyHeader())

    def set_dens_fn(self, dens_fn):
        r"""set_dens_fn(AssemblyHeader self, std::string const & dens_fn)"""
        return _IMP_multifit.AssemblyHeader_set_dens_fn(self, dens_fn)

    def get_dens_fn(self):
        r"""get_dens_fn(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader_get_dens_fn(self)

    def set_resolution(self, res):
        r"""set_resolution(AssemblyHeader self, float res)"""
        return _IMP_multifit.AssemblyHeader_set_resolution(self, res)

    def get_resolution(self):
        r"""get_resolution(AssemblyHeader self) -> float"""
        return _IMP_multifit.AssemblyHeader_get_resolution(self)

    def get_spacing(self):
        r"""get_spacing(AssemblyHeader self) -> float"""
        return _IMP_multifit.AssemblyHeader_get_spacing(self)

    def set_spacing(self, spacing):
        r"""set_spacing(AssemblyHeader self, float spacing)"""
        return _IMP_multifit.AssemblyHeader_set_spacing(self, spacing)

    def set_threshold(self, t):
        r"""set_threshold(AssemblyHeader self, float t)"""
        return _IMP_multifit.AssemblyHeader_set_threshold(self, t)

    def get_threshold(self):
        r"""get_threshold(AssemblyHeader self) -> float"""
        return _IMP_multifit.AssemblyHeader_get_threshold(self)

    def get_origin(self):
        r"""get_origin(AssemblyHeader self) -> Vector3D"""
        return _IMP_multifit.AssemblyHeader_get_origin(self)

    def set_origin(self, origin):
        r"""set_origin(AssemblyHeader self, Vector3D origin)"""
        return _IMP_multifit.AssemblyHeader_set_origin(self, origin)

    def get_coarse_ap_fn(self):
        r"""get_coarse_ap_fn(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader_get_coarse_ap_fn(self)

    def set_coarse_ap_fn(self, new_fn):
        r"""set_coarse_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_coarse_ap_fn(self, new_fn)

    def get_coarse_over_sampled_ap_fn(self):
        r"""get_coarse_over_sampled_ap_fn(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader_get_coarse_over_sampled_ap_fn(self)

    def set_coarse_over_sampled_ap_fn(self, new_fn):
        r"""set_coarse_over_sampled_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_coarse_over_sampled_ap_fn(self, new_fn)

    def get_fine_ap_fn(self):
        r"""get_fine_ap_fn(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader_get_fine_ap_fn(self)

    def set_fine_ap_fn(self, new_fn):
        r"""set_fine_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_fine_ap_fn(self, new_fn)

    def get_fine_over_sampled_ap_fn(self):
        r"""get_fine_over_sampled_ap_fn(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader_get_fine_over_sampled_ap_fn(self)

    def set_fine_over_sampled_ap_fn(self, new_fn):
        r"""set_fine_over_sampled_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_fine_over_sampled_ap_fn(self, new_fn)

    def get_version_info(self):
        r"""get_version_info(AssemblyHeader self) -> VersionInfo"""
        return _IMP_multifit.AssemblyHeader_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_AssemblyHeader

    def __str__(self):
        r"""__str__(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader___str__(self)

    def __repr__(self):
        r"""__repr__(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader___repr__(self)

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


# Register AssemblyHeader in _IMP_multifit:
_IMP_multifit.AssemblyHeader_swigregister(AssemblyHeader)
class SettingsData(IMP.Object):
    r"""Proxy of C++ IMP::multifit::SettingsData class."""

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

    def __init__(self):
        r"""__init__(SettingsData self) -> SettingsData"""
        _IMP_multifit.SettingsData_swiginit(self, _IMP_multifit.new_SettingsData())

    @staticmethod
    def show_component_header_line(*args):
        r"""show_component_header_line(_ostream out=std::cout)"""
        return _IMP_multifit.SettingsData_show_component_header_line(*args)

    @staticmethod
    def get_component_header_line():
        r"""get_component_header_line() -> std::string"""
        return _IMP_multifit.SettingsData_get_component_header_line()

    @staticmethod
    def show_density_header_line(*args):
        r"""show_density_header_line(_ostream out=std::cout)"""
        return _IMP_multifit.SettingsData_show_density_header_line(*args)

    @staticmethod
    def get_density_header_line():
        r"""get_density_header_line() -> std::string"""
        return _IMP_multifit.SettingsData_get_density_header_line()

    def set_assembly_filename(self, fn):
        r"""set_assembly_filename(SettingsData self, std::string const & fn)"""
        return _IMP_multifit.SettingsData_set_assembly_filename(self, fn)

    def get_assembly_filename(self):
        r"""get_assembly_filename(SettingsData self) -> char const *"""
        return _IMP_multifit.SettingsData_get_assembly_filename(self)

    def set_assembly_header(self, h):
        r"""set_assembly_header(SettingsData self, AssemblyHeader h)"""
        return _IMP_multifit.SettingsData_set_assembly_header(self, h)

    def get_assembly_header(self):
        r"""get_assembly_header(SettingsData self) -> AssemblyHeader"""
        return _IMP_multifit.SettingsData_get_assembly_header(self)

    def set_data_path(self, fn):
        r"""set_data_path(SettingsData self, std::string const & fn)"""
        return _IMP_multifit.SettingsData_set_data_path(self, fn)

    def get_data_path(self):
        r"""get_data_path(SettingsData self) -> std::string"""
        return _IMP_multifit.SettingsData_get_data_path(self)

    def get_version_info(self):
        r"""get_version_info(SettingsData self) -> VersionInfo"""
        return _IMP_multifit.SettingsData_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_SettingsData
    def __get_component_headers(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_component_headers,  getfunc=self.get_component_header, erasefunc=self.erase_component_header,  appendfunc=self.add_component_header, extendfunc=self.add_component_headers,  clearfunc=self.clear_component_headers, indexfunc=self._python_index_component_header)  
    def __set_component_headers(self, obj): IMP._list_util.set_varlist(self.component_headers, obj)  
    def __del_component_headers(self): IMP._list_util.del_varlist(self.component_headers)       
    component_headers = property(__get_component_headers, __set_component_headers, __del_component_headers, doc="List of ##ucnames")  

    def remove_component_header(self, d):
        r"""remove_component_header(SettingsData self, ComponentHeader d)"""
        return _IMP_multifit.SettingsData_remove_component_header(self, d)

    def _python_index_component_header(self, d, start, stop):
        r"""_python_index_component_header(SettingsData self, ComponentHeader d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_multifit.SettingsData__python_index_component_header(self, d, start, stop)

    def remove_component_headers(self, d):
        r"""remove_component_headers(SettingsData self, IMP::multifit::ComponentHeaders const & d)"""
        return _IMP_multifit.SettingsData_remove_component_headers(self, d)

    def set_component_headers(self, ps):
        r"""set_component_headers(SettingsData self, IMP::multifit::ComponentHeaders const & ps)"""
        return _IMP_multifit.SettingsData_set_component_headers(self, ps)

    def set_component_headers_order(self, objs):
        r"""set_component_headers_order(SettingsData self, IMP::multifit::ComponentHeaders const & objs)"""
        return _IMP_multifit.SettingsData_set_component_headers_order(self, objs)

    def add_component_header(self, obj):
        r"""add_component_header(SettingsData self, ComponentHeader obj) -> unsigned int"""
        return _IMP_multifit.SettingsData_add_component_header(self, obj)

    def add_component_headers(self, objs):
        r"""add_component_headers(SettingsData self, IMP::multifit::ComponentHeaders const & objs)"""
        return _IMP_multifit.SettingsData_add_component_headers(self, objs)

    def clear_component_headers(self):
        r"""clear_component_headers(SettingsData self)"""
        return _IMP_multifit.SettingsData_clear_component_headers(self)

    def get_number_of_component_headers(self):
        r"""get_number_of_component_headers(SettingsData self) -> unsigned int"""
        return _IMP_multifit.SettingsData_get_number_of_component_headers(self)

    def get_has_component_headers(self):
        r"""get_has_component_headers(SettingsData self) -> bool"""
        return _IMP_multifit.SettingsData_get_has_component_headers(self)

    def get_component_header(self, i):
        r"""get_component_header(SettingsData self, unsigned int i) -> ComponentHeader"""
        return _IMP_multifit.SettingsData_get_component_header(self, i)

    def get_component_headers(self):
        r"""get_component_headers(SettingsData self) -> IMP::multifit::ComponentHeaders"""
        return _IMP_multifit.SettingsData_get_component_headers(self)

    def erase_component_header(self, i):
        r"""erase_component_header(SettingsData self, unsigned int i)"""
        return _IMP_multifit.SettingsData_erase_component_header(self, i)

    def reserve_component_headers(self, sz):
        r"""reserve_component_headers(SettingsData self, unsigned int sz)"""
        return _IMP_multifit.SettingsData_reserve_component_headers(self, sz)

    def __str__(self):
        r"""__str__(SettingsData self) -> std::string"""
        return _IMP_multifit.SettingsData___str__(self)

    def __repr__(self):
        r"""__repr__(SettingsData self) -> std::string"""
        return _IMP_multifit.SettingsData___repr__(self)

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


# Register SettingsData in _IMP_multifit:
_IMP_multifit.SettingsData_swigregister(SettingsData)

def read_settings(filename):
    r"""read_settings(char const * filename) -> SettingsData"""
    return _IMP_multifit.read_settings(filename)

def write_settings(filename, sd):
    r"""write_settings(char const * filename, SettingsData sd)"""
    return _IMP_multifit.write_settings(filename, sd)
class WeightedExcludedVolumeRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::multifit::WeightedExcludedVolumeRestraint 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__(WeightedExcludedVolumeRestraint self, IMP::core::RigidBodies rbs, Refiner refiner, FloatKey weight_key=IMP::atom::Mass::get_mass_key()) -> WeightedExcludedVolumeRestraint"""
        _IMP_multifit.WeightedExcludedVolumeRestraint_swiginit(self, _IMP_multifit.new_WeightedExcludedVolumeRestraint(*args))

    def do_get_inputs(self):
        r"""do_get_inputs(WeightedExcludedVolumeRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_multifit.WeightedExcludedVolumeRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(WeightedExcludedVolumeRestraint self) -> VersionInfo"""
        return _IMP_multifit.WeightedExcludedVolumeRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_WeightedExcludedVolumeRestraint

    def __str__(self):
        r"""__str__(WeightedExcludedVolumeRestraint self) -> std::string"""
        return _IMP_multifit.WeightedExcludedVolumeRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(WeightedExcludedVolumeRestraint self) -> std::string"""
        return _IMP_multifit.WeightedExcludedVolumeRestraint___repr__(self)

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


# Register WeightedExcludedVolumeRestraint in _IMP_multifit:
_IMP_multifit.WeightedExcludedVolumeRestraint_swigregister(WeightedExcludedVolumeRestraint)
class FFTFittingOutput(IMP.Object):
    r"""Proxy of C++ IMP::multifit::FFTFittingOutput class."""

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

    def __init__(self):
        r"""__init__(FFTFittingOutput self) -> FFTFittingOutput"""
        _IMP_multifit.FFTFittingOutput_swiginit(self, _IMP_multifit.new_FFTFittingOutput())

    def get_version_info(self):
        r"""get_version_info(FFTFittingOutput self) -> VersionInfo"""
        return _IMP_multifit.FFTFittingOutput_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_FFTFittingOutput
    best_fits_ = property(_IMP_multifit.FFTFittingOutput_best_fits__get, _IMP_multifit.FFTFittingOutput_best_fits__set, doc=r"""best_fits_ : IMP::multifit::FittingSolutionRecords""")
    best_trans_per_rot_ = property(_IMP_multifit.FFTFittingOutput_best_trans_per_rot__get, _IMP_multifit.FFTFittingOutput_best_trans_per_rot__set, doc=r"""best_trans_per_rot_ : IMP::multifit::FittingSolutionRecords""")

    def __str__(self):
        r"""__str__(FFTFittingOutput self) -> std::string"""
        return _IMP_multifit.FFTFittingOutput___str__(self)

    def __repr__(self):
        r"""__repr__(FFTFittingOutput self) -> std::string"""
        return _IMP_multifit.FFTFittingOutput___repr__(self)

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


# Register FFTFittingOutput in _IMP_multifit:
_IMP_multifit.FFTFittingOutput_swigregister(FFTFittingOutput)
class FFTFitting(IMP.Object):
    r"""Proxy of C++ IMP::multifit::FFTFitting class."""

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

    def get_version_info(self):
        r"""get_version_info(FFTFitting self) -> VersionInfo"""
        return _IMP_multifit.FFTFitting_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_FFTFitting

    def __init__(self):
        r"""__init__(FFTFitting self) -> FFTFitting"""
        _IMP_multifit.FFTFitting_swiginit(self, _IMP_multifit.new_FFTFitting())

    def do_global_fitting(self, *args):
        r"""do_global_fitting(FFTFitting self, DensityMap dmap, double density_threshold, Hierarchy mol2fit, double angle_sampling_interval_rad, int num_fits_to_report, double max_clustering_translation, double max_clustering_angle, bool cluster_fits=True, int num_angle_per_voxel=1, std::string const & angles_filename="") -> FFTFittingOutput"""
        return _IMP_multifit.FFTFitting_do_global_fitting(self, *args)

    def do_local_fitting(self, *args):
        r"""do_local_fitting(FFTFitting self, DensityMap dmap, double density_threshold, Hierarchy mol2fit, double angle_sampling_interval_rad, double max_angle_sampling_rad, double max_translation, int num_fits_to_report, bool cluster_fits, int num_angle_per_voxel, double max_clustering_translation, double max_clustering_rotation, std::string const & angles_filename="") -> FFTFittingOutput"""
        return _IMP_multifit.FFTFitting_do_local_fitting(self, *args)

    def __str__(self):
        r"""__str__(FFTFitting self) -> std::string"""
        return _IMP_multifit.FFTFitting___str__(self)

    def __repr__(self):
        r"""__repr__(FFTFitting self) -> std::string"""
        return _IMP_multifit.FFTFitting___repr__(self)

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


# Register FFTFitting in _IMP_multifit:
_IMP_multifit.FFTFitting_swigregister(FFTFitting)

def fft_based_rigid_fitting(mol2fit, dmap, density_threshold, angle_sampling_interval_rad):
    r"""fft_based_rigid_fitting(Hierarchy mol2fit, DensityMap dmap, double density_threshold, double angle_sampling_interval_rad) -> IMP::multifit::FittingSolutionRecords"""
    return _IMP_multifit.fft_based_rigid_fitting(mol2fit, dmap, density_threshold, angle_sampling_interval_rad)

def remove_background(dmap, threshold, edge_threshold):
    r"""remove_background(DensityMap dmap, float threshold, float edge_threshold) -> DensityMap"""
    return _IMP_multifit.remove_background(dmap, threshold, edge_threshold)

def get_connected_components(dmap, threshold, edge_threshold):
    r"""get_connected_components(DensityMap dmap, float threshold, float edge_threshold) -> IMP::IntsList"""
    return _IMP_multifit.get_connected_components(dmap, threshold, edge_threshold)

def get_segmentation(dmap, apix, density_threshold, num_means, pdb_filename, cmm_filename, seg_filename, txt_filename):
    r"""get_segmentation(DensityMap dmap, double apix, double density_threshold, int num_means, std::string const pdb_filename, std::string const cmm_filename, std::string const seg_filename, std::string const txt_filename)"""
    return _IMP_multifit.get_segmentation(dmap, apix, density_threshold, num_means, pdb_filename, cmm_filename, seg_filename, txt_filename)
class ComplementarityRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::multifit::ComplementarityRestraint 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__(ComplementarityRestraint self, IMP::ParticlesTemp const & a, IMP::ParticlesTemp const & b, std::string name="ComplementarityRestraint %1%") -> ComplementarityRestraint"""
        _IMP_multifit.ComplementarityRestraint_swiginit(self, _IMP_multifit.new_ComplementarityRestraint(*args))

    def set_maximum_penetration_score(self, s):
        r"""set_maximum_penetration_score(ComplementarityRestraint self, double s)"""
        return _IMP_multifit.ComplementarityRestraint_set_maximum_penetration_score(self, s)

    def set_maximum_penetration(self, d):
        r"""set_maximum_penetration(ComplementarityRestraint self, double d)"""
        return _IMP_multifit.ComplementarityRestraint_set_maximum_penetration(self, d)

    def set_maximum_separation(self, s):
        r"""set_maximum_separation(ComplementarityRestraint self, double s)"""
        return _IMP_multifit.ComplementarityRestraint_set_maximum_separation(self, s)

    def set_complementarity_thickness(self, th):
        r"""set_complementarity_thickness(ComplementarityRestraint self, double th)"""
        return _IMP_multifit.ComplementarityRestraint_set_complementarity_thickness(self, th)

    def set_complementarity_value(self, th):
        r"""set_complementarity_value(ComplementarityRestraint self, double th)"""
        return _IMP_multifit.ComplementarityRestraint_set_complementarity_value(self, th)

    def set_interior_layer_thickness(self, th):
        r"""set_interior_layer_thickness(ComplementarityRestraint self, double th)"""
        return _IMP_multifit.ComplementarityRestraint_set_interior_layer_thickness(self, th)

    def set_penetration_coefficient(self, pc):
        r"""set_penetration_coefficient(ComplementarityRestraint self, double pc)"""
        return _IMP_multifit.ComplementarityRestraint_set_penetration_coefficient(self, pc)

    def set_complementarity_coefficient(self, cc):
        r"""set_complementarity_coefficient(ComplementarityRestraint self, double cc)"""
        return _IMP_multifit.ComplementarityRestraint_set_complementarity_coefficient(self, cc)

    def set_boundary_coefficient(self, bc):
        r"""set_boundary_coefficient(ComplementarityRestraint self, double bc)"""
        return _IMP_multifit.ComplementarityRestraint_set_boundary_coefficient(self, bc)

    def get_voxel_size(self):
        r"""get_voxel_size(ComplementarityRestraint self) -> float"""
        return _IMP_multifit.ComplementarityRestraint_get_voxel_size(self)

    def do_get_inputs(self):
        r"""do_get_inputs(ComplementarityRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_multifit.ComplementarityRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ComplementarityRestraint self) -> VersionInfo"""
        return _IMP_multifit.ComplementarityRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_ComplementarityRestraint

    def __str__(self):
        r"""__str__(ComplementarityRestraint self) -> std::string"""
        return _IMP_multifit.ComplementarityRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ComplementarityRestraint self) -> std::string"""
        return _IMP_multifit.ComplementarityRestraint___repr__(self)

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


# Register ComplementarityRestraint in _IMP_multifit:
_IMP_multifit.ComplementarityRestraint_swigregister(ComplementarityRestraint)

def read_fitting_solutions(fitting_fn):
    r"""read_fitting_solutions(char const * fitting_fn) -> IMP::multifit::FittingSolutionRecords"""
    return _IMP_multifit.read_fitting_solutions(fitting_fn)

def write_fitting_solutions(fitting_fn, fit_sols, num_sols=-1):
    r"""write_fitting_solutions(char const * fitting_fn, IMP::multifit::FittingSolutionRecords const & fit_sols, int num_sols=-1)"""
    return _IMP_multifit.write_fitting_solutions(fitting_fn, fit_sols, num_sols)

def convert_em_to_multifit_format(em_fits):
    r"""convert_em_to_multifit_format(FittingSolutions em_fits) -> IMP::multifit::FittingSolutionRecords"""
    return _IMP_multifit.convert_em_to_multifit_format(em_fits)

def convert_multifit_to_em_format(multifit_fits):
    r"""convert_multifit_to_em_format(IMP::multifit::FittingSolutionRecords const & multifit_fits) -> FittingSolutions"""
    return _IMP_multifit.convert_multifit_to_em_format(multifit_fits)

def convert_transformations_to_multifit_format(trans):
    r"""convert_transformations_to_multifit_format(IMP::algebra::Transformation3Ds const & trans) -> IMP::multifit::FittingSolutionRecords"""
    return _IMP_multifit.convert_transformations_to_multifit_format(trans)

def convert_multifit_format_to_transformations(recs):
    r"""convert_multifit_format_to_transformations(IMP::multifit::FittingSolutionRecords const & recs) -> IMP::algebra::Transformation3Ds"""
    return _IMP_multifit.convert_multifit_format_to_transformations(recs)

def get_close_to_point(fit_sols, mh, ap, dist):
    r"""get_close_to_point(IMP::multifit::FittingSolutionRecords const & fit_sols, Hierarchy mh, Particle ap, IMP::Float dist) -> IMP::multifit::FittingSolutionRecords"""
    return _IMP_multifit.get_close_to_point(fit_sols, mh, ap, dist)
class ProbabilisticAnchorGraph(IMP.Object):
    r"""Proxy of C++ IMP::multifit::ProbabilisticAnchorGraph class."""

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

    def __init__(self, anchor_positions):
        r"""__init__(ProbabilisticAnchorGraph self, IMP::algebra::Vector3Ds anchor_positions) -> ProbabilisticAnchorGraph"""
        _IMP_multifit.ProbabilisticAnchorGraph_swiginit(self, _IMP_multifit.new_ProbabilisticAnchorGraph(anchor_positions))

    def add_edge(self, i, j):
        r"""add_edge(ProbabilisticAnchorGraph self, int i, int j)"""
        return _IMP_multifit.ProbabilisticAnchorGraph_add_edge(self, i, j)

    def set_particle_probabilities_on_anchors(self, p, sols):
        r"""set_particle_probabilities_on_anchors(ProbabilisticAnchorGraph self, Particle p, IMP::multifit::FittingSolutionRecords sols)"""
        return _IMP_multifit.ProbabilisticAnchorGraph_set_particle_probabilities_on_anchors(self, p, sols)

    def show(self, *args):
        r"""show(ProbabilisticAnchorGraph self, _ostream out=std::cout)"""
        return _IMP_multifit.ProbabilisticAnchorGraph_show(self, *args)

    def get_number_of_anchors(self):
        r"""get_number_of_anchors(ProbabilisticAnchorGraph self) -> unsigned int"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_number_of_anchors(self)

    def get_number_of_edges(self):
        r"""get_number_of_edges(ProbabilisticAnchorGraph self) -> unsigned int"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_number_of_edges(self)

    def get_edge_list(self):
        r"""get_edge_list(ProbabilisticAnchorGraph self) -> IMP::IntRanges"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_edge_list(self)

    def get_anchors(self):
        r"""get_anchors(ProbabilisticAnchorGraph self) -> IMP::algebra::Vector3Ds"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_anchors(self)

    def get_particle_anchors(self, p, min_prob=0):
        r"""get_particle_anchors(ProbabilisticAnchorGraph self, Particle p, float min_prob=0) -> IMP::algebra::Vector3Ds"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_particle_anchors(self, p, min_prob)

    def get_are_probabilities_for_particle_set(self, p):
        r"""get_are_probabilities_for_particle_set(ProbabilisticAnchorGraph self, Particle p) -> bool"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_are_probabilities_for_particle_set(self, p)

    def get_particle_probabilities(self, p):
        r"""get_particle_probabilities(ProbabilisticAnchorGraph self, Particle p) -> IMP::Floats"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_particle_probabilities(self, p)

    def get_version_info(self):
        r"""get_version_info(ProbabilisticAnchorGraph self) -> VersionInfo"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_ProbabilisticAnchorGraph

    def __str__(self):
        r"""__str__(ProbabilisticAnchorGraph self) -> std::string"""
        return _IMP_multifit.ProbabilisticAnchorGraph___str__(self)

    def __repr__(self):
        r"""__repr__(ProbabilisticAnchorGraph self) -> std::string"""
        return _IMP_multifit.ProbabilisticAnchorGraph___repr__(self)

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


# Register ProbabilisticAnchorGraph in _IMP_multifit:
_IMP_multifit.ProbabilisticAnchorGraph_swigregister(ProbabilisticAnchorGraph)
class ProteinRecordData(object):
    r"""Proxy of C++ IMP::multifit::ProteinRecordData class."""

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

    def reset_all(self):
        r"""reset_all(ProteinRecordData self)"""
        return _IMP_multifit.ProteinRecordData_reset_all(self)

    def __init__(self, *args):
        r"""
        __init__(ProteinRecordData self) -> ProteinRecordData
        __init__(ProteinRecordData self, std::string const & name) -> ProteinRecordData
        __init__(ProteinRecordData self, std::string const & name, std::string const fn) -> ProteinRecordData
        __init__(ProteinRecordData self, std::string const & name, int start_res, int end_res, std::string const fn) -> ProteinRecordData
        __init__(ProteinRecordData self, std::string const & name, int start_res, int end_res, std::string const & fn, std::string const & surface_fn, std::string const & ref_fn) -> ProteinRecordData
        """
        _IMP_multifit.ProteinRecordData_swiginit(self, _IMP_multifit.new_ProteinRecordData(*args))

    def show(self, *args):
        r"""show(ProteinRecordData self, _ostream out=std::cout)"""
        return _IMP_multifit.ProteinRecordData_show(self, *args)
    name_ = property(_IMP_multifit.ProteinRecordData_name__get, _IMP_multifit.ProteinRecordData_name__set, doc=r"""name_ : std::string""")
    start_res_ = property(_IMP_multifit.ProteinRecordData_start_res__get, _IMP_multifit.ProteinRecordData_start_res__set, doc=r"""start_res_ : int""")
    end_res_ = property(_IMP_multifit.ProteinRecordData_end_res__get, _IMP_multifit.ProteinRecordData_end_res__set, doc=r"""end_res_ : int""")
    filename_ = property(_IMP_multifit.ProteinRecordData_filename__get, _IMP_multifit.ProteinRecordData_filename__set, doc=r"""filename_ : std::string""")
    surface_filename_ = property(_IMP_multifit.ProteinRecordData_surface_filename__get, _IMP_multifit.ProteinRecordData_surface_filename__set, doc=r"""surface_filename_ : std::string""")
    ref_filename_ = property(_IMP_multifit.ProteinRecordData_ref_filename__get, _IMP_multifit.ProteinRecordData_ref_filename__set, doc=r"""ref_filename_ : std::string""")

    def __str__(self):
        r"""__str__(ProteinRecordData self) -> std::string"""
        return _IMP_multifit.ProteinRecordData___str__(self)

    def __repr__(self):
        r"""__repr__(ProteinRecordData self) -> std::string"""
        return _IMP_multifit.ProteinRecordData___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ProteinRecordData self) -> PyObject *"""
        return _IMP_multifit.ProteinRecordData__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ProteinRecordData self, PyObject * p)"""
        return _IMP_multifit.ProteinRecordData__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_multifit.delete_ProteinRecordData

# Register ProteinRecordData in _IMP_multifit:
_IMP_multifit.ProteinRecordData_swigregister(ProteinRecordData)
class ProteomicsData(IMP.Object):
    r"""Proxy of C++ IMP::multifit::ProteomicsData class."""

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

    def __init__(self):
        r"""__init__(ProteomicsData self) -> ProteomicsData"""
        _IMP_multifit.ProteomicsData_swiginit(self, _IMP_multifit.new_ProteomicsData())

    def add_protein(self, *args):
        r"""
        add_protein(ProteomicsData self, std::string name, int start_res, int end_res, std::string const & mol_fn, std::string const & surface_fn, std::string const & ref_fn) -> int
        add_protein(ProteomicsData self, ProteinRecordData rec) -> int
        """
        return _IMP_multifit.ProteomicsData_add_protein(self, *args)

    def find(self, name):
        r"""find(ProteomicsData self, std::string const & name) -> int"""
        return _IMP_multifit.ProteomicsData_find(self, name)

    def add_interaction(self, ii, used_for_filter, linker_len):
        r"""add_interaction(ProteomicsData self, IMP::Ints const & ii, bool used_for_filter, float linker_len)"""
        return _IMP_multifit.ProteomicsData_add_interaction(self, ii, used_for_filter, linker_len)

    def add_cross_link_interaction(self, prot1, res1, prot2, res2, used_in_filter, linker_len):
        r"""add_cross_link_interaction(ProteomicsData self, IMP::Int prot1, IMP::Int res1, IMP::Int prot2, IMP::Int res2, bool used_in_filter, IMP::Float linker_len)"""
        return _IMP_multifit.ProteomicsData_add_cross_link_interaction(self, prot1, res1, prot2, res2, used_in_filter, linker_len)

    def add_ev_pair(self, prot1, prot2):
        r"""add_ev_pair(ProteomicsData self, IMP::Int prot1, IMP::Int prot2)"""
        return _IMP_multifit.ProteomicsData_add_ev_pair(self, prot1, prot2)

    def get_number_of_proteins(self):
        r"""get_number_of_proteins(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_number_of_proteins(self)

    def get_number_of_interactions(self):
        r"""get_number_of_interactions(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_number_of_interactions(self)

    def get_interaction(self, interaction_ind):
        r"""get_interaction(ProteomicsData self, int interaction_ind) -> IMP::Ints"""
        return _IMP_multifit.ProteomicsData_get_interaction(self, interaction_ind)

    def get_interaction_part_of_filter(self, interaction_ind):
        r"""get_interaction_part_of_filter(ProteomicsData self, int interaction_ind) -> bool"""
        return _IMP_multifit.ProteomicsData_get_interaction_part_of_filter(self, interaction_ind)

    def get_interaction_linker_length(self, interaction_ind):
        r"""get_interaction_linker_length(ProteomicsData self, int interaction_ind) -> int"""
        return _IMP_multifit.ProteomicsData_get_interaction_linker_length(self, interaction_ind)

    def get_number_of_cross_links(self):
        r"""get_number_of_cross_links(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_number_of_cross_links(self)

    def get_cross_link(self, xlink_ind):
        r"""get_cross_link(ProteomicsData self, int xlink_ind) -> std::pair< IMP::IntPair,IMP::IntPair >"""
        return _IMP_multifit.ProteomicsData_get_cross_link(self, xlink_ind)

    def get_cross_link_part_of_filter(self, xlink_ind):
        r"""get_cross_link_part_of_filter(ProteomicsData self, int xlink_ind) -> bool"""
        return _IMP_multifit.ProteomicsData_get_cross_link_part_of_filter(self, xlink_ind)

    def get_cross_link_length(self, xlink_ind):
        r"""get_cross_link_length(ProteomicsData self, int xlink_ind) -> float"""
        return _IMP_multifit.ProteomicsData_get_cross_link_length(self, xlink_ind)

    def get_number_of_ev_pairs(self):
        r"""get_number_of_ev_pairs(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_number_of_ev_pairs(self)

    def get_ev_pair(self, ev_ind):
        r"""get_ev_pair(ProteomicsData self, int ev_ind) -> IMP::IntPair"""
        return _IMP_multifit.ProteomicsData_get_ev_pair(self, ev_ind)

    def get_protein_name(self, protein_ind):
        r"""get_protein_name(ProteomicsData self, int protein_ind) -> std::string"""
        return _IMP_multifit.ProteomicsData_get_protein_name(self, protein_ind)

    def get_end_res(self, protein_ind):
        r"""get_end_res(ProteomicsData self, int protein_ind) -> int"""
        return _IMP_multifit.ProteomicsData_get_end_res(self, protein_ind)

    def get_start_res(self, protein_ind):
        r"""get_start_res(ProteomicsData self, int protein_ind) -> int"""
        return _IMP_multifit.ProteomicsData_get_start_res(self, protein_ind)

    def get_protein_filename(self, protein_ind):
        r"""get_protein_filename(ProteomicsData self, int protein_ind) -> std::string"""
        return _IMP_multifit.ProteomicsData_get_protein_filename(self, protein_ind)

    def get_reference_filename(self, protein_ind):
        r"""get_reference_filename(ProteomicsData self, int protein_ind) -> std::string"""
        return _IMP_multifit.ProteomicsData_get_reference_filename(self, protein_ind)

    def get_surface_filename(self, protein_ind):
        r"""get_surface_filename(ProteomicsData self, int protein_ind) -> std::string"""
        return _IMP_multifit.ProteomicsData_get_surface_filename(self, protein_ind)

    def get_protein_data(self, protein_ind):
        r"""get_protein_data(ProteomicsData self, int protein_ind) -> ProteinRecordData"""
        return _IMP_multifit.ProteomicsData_get_protein_data(self, protein_ind)

    def get_version_info(self):
        r"""get_version_info(ProteomicsData self) -> VersionInfo"""
        return _IMP_multifit.ProteomicsData_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_ProteomicsData

    def get_num_allowed_violated_interactions(self):
        r"""get_num_allowed_violated_interactions(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_num_allowed_violated_interactions(self)

    def set_num_allowed_violated_interactions(self, n):
        r"""set_num_allowed_violated_interactions(ProteomicsData self, int n)"""
        return _IMP_multifit.ProteomicsData_set_num_allowed_violated_interactions(self, n)

    def get_num_allowed_violated_cross_links(self):
        r"""get_num_allowed_violated_cross_links(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_num_allowed_violated_cross_links(self)

    def set_num_allowed_violated_cross_links(self, n):
        r"""set_num_allowed_violated_cross_links(ProteomicsData self, int n)"""
        return _IMP_multifit.ProteomicsData_set_num_allowed_violated_cross_links(self, n)

    def get_num_allowed_violated_ev(self):
        r"""get_num_allowed_violated_ev(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_num_allowed_violated_ev(self)

    def set_num_allowed_violated_ev(self, n):
        r"""set_num_allowed_violated_ev(ProteomicsData self, int n)"""
        return _IMP_multifit.ProteomicsData_set_num_allowed_violated_ev(self, n)

    def __str__(self):
        r"""__str__(ProteomicsData self) -> std::string"""
        return _IMP_multifit.ProteomicsData___str__(self)

    def __repr__(self):
        r"""__repr__(ProteomicsData self) -> std::string"""
        return _IMP_multifit.ProteomicsData___repr__(self)

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


# Register ProteomicsData in _IMP_multifit:
_IMP_multifit.ProteomicsData_swigregister(ProteomicsData)

def read_proteomics_data(proteomics_fn):
    r"""read_proteomics_data(char const * proteomics_fn) -> ProteomicsData"""
    return _IMP_multifit.read_proteomics_data(proteomics_fn)

def get_partial_proteomics_data(pd, prot_names):
    r"""get_partial_proteomics_data(ProteomicsData pd, IMP::Strings const & prot_names) -> ProteomicsData"""
    return _IMP_multifit.get_partial_proteomics_data(pd, prot_names)
class AnchorsData(object):
    r"""Proxy of C++ IMP::multifit::AnchorsData 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__(AnchorsData self) -> AnchorsData
        __init__(AnchorsData self, IMP::algebra::Vector3Ds points, IMP::IntPairs edges) -> AnchorsData
        """
        _IMP_multifit.AnchorsData_swiginit(self, _IMP_multifit.new_AnchorsData(*args))

    def remove_edges_for_node(self, node_ind):
        r"""remove_edges_for_node(AnchorsData self, int node_ind)"""
        return _IMP_multifit.AnchorsData_remove_edges_for_node(self, node_ind)

    def get_number_of_points(self):
        r"""get_number_of_points(AnchorsData self) -> int"""
        return _IMP_multifit.AnchorsData_get_number_of_points(self)

    def get_number_of_edges(self):
        r"""get_number_of_edges(AnchorsData self) -> int"""
        return _IMP_multifit.AnchorsData_get_number_of_edges(self)

    def get_is_point_considered(self, node_ind):
        r"""get_is_point_considered(AnchorsData self, int node_ind) -> bool"""
        return _IMP_multifit.AnchorsData_get_is_point_considered(self, node_ind)

    def show(self, *args):
        r"""show(AnchorsData self, _ostream out=std::cout)"""
        return _IMP_multifit.AnchorsData_show(self, *args)

    def get_secondary_structure_is_set(self):
        r"""get_secondary_structure_is_set(AnchorsData self) -> bool"""
        return _IMP_multifit.AnchorsData_get_secondary_structure_is_set(self)

    def setup_secondary_structure(self, mdl):
        r"""setup_secondary_structure(AnchorsData self, Model mdl)"""
        return _IMP_multifit.AnchorsData_setup_secondary_structure(self, mdl)

    def set_secondary_structure_probabilities(self, *args):
        r"""set_secondary_structure_probabilities(AnchorsData self, IMP::Particles const & ssres_ps, IMP::Ints const & indices=IMP::Ints())"""
        return _IMP_multifit.AnchorsData_set_secondary_structure_probabilities(self, *args)

    def get_secondary_structure_particles(self):
        r"""get_secondary_structure_particles(AnchorsData self) -> IMP::Particles"""
        return _IMP_multifit.AnchorsData_get_secondary_structure_particles(self)
    points_ = property(_IMP_multifit.AnchorsData_points__get, _IMP_multifit.AnchorsData_points__set, doc=r"""points_ : IMP::algebra::Vector3Ds""")
    consider_point_ = property(_IMP_multifit.AnchorsData_consider_point__get, _IMP_multifit.AnchorsData_consider_point__set, doc=r"""consider_point_ : std::vector<(bool,std::allocator<(bool)>)>""")
    edges_ = property(_IMP_multifit.AnchorsData_edges__get, _IMP_multifit.AnchorsData_edges__set, doc=r"""edges_ : IMP::IntPairs""")

    def __str__(self):
        r"""__str__(AnchorsData self) -> std::string"""
        return _IMP_multifit.AnchorsData___str__(self)

    def __repr__(self):
        r"""__repr__(AnchorsData self) -> std::string"""
        return _IMP_multifit.AnchorsData___repr__(self)
    __swig_destroy__ = _IMP_multifit.delete_AnchorsData

# Register AnchorsData in _IMP_multifit:
_IMP_multifit.AnchorsData_swigregister(AnchorsData)

def read_anchors_data(txt_filename):
    r"""read_anchors_data(char const * txt_filename) -> AnchorsData"""
    return _IMP_multifit.read_anchors_data(txt_filename)

def write_txt(txt_filename, ad):
    r"""write_txt(std::string const & txt_filename, AnchorsData ad)"""
    return _IMP_multifit.write_txt(txt_filename, ad)

def write_cmm(cmm_filename, marker_set_name, dpa):
    r"""write_cmm(std::string const & cmm_filename, std::string const & marker_set_name, AnchorsData dpa)"""
    return _IMP_multifit.write_cmm(cmm_filename, marker_set_name, dpa)

def create_coarse_molecule_from_density(dmap, dens_threshold, num_beads, mdl, bead_radius):
    r"""create_coarse_molecule_from_density(DensityMap dmap, float dens_threshold, int num_beads, Model mdl, float bead_radius) -> Hierarchy"""
    return _IMP_multifit.create_coarse_molecule_from_density(dmap, dens_threshold, num_beads, mdl, bead_radius)

def create_hit_map(rb, rb_ref, sols, damp):
    r"""create_hit_map(RigidBody rb, Refiner rb_ref, IMP::multifit::FittingSolutionRecords const & sols, DensityMap damp) -> DensityMap"""
    return _IMP_multifit.create_hit_map(rb, rb_ref, sols, damp)

def get_points_close_to_molecule(mh, points, max_dist):
    r"""get_points_close_to_molecule(Hierarchy mh, IMP::algebra::Vector3Ds const points, IMP::Float max_dist) -> IMP::algebra::Vector3Ds"""
    return _IMP_multifit.get_points_close_to_molecule(mh, points, max_dist)

def get_points_far_from_molecule(mh, points, max_dist):
    r"""get_points_far_from_molecule(Hierarchy mh, IMP::algebra::Vector3Ds const points, IMP::Float max_dist) -> IMP::algebra::Vector3Ds"""
    return _IMP_multifit.get_points_far_from_molecule(mh, points, max_dist)
class RadiusOfGyrationRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::multifit::RadiusOfGyrationRestraint class."""

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

    def __init__(self, ps, num_residues, scale=1.):
        r"""__init__(RadiusOfGyrationRestraint self, IMP::Particles ps, int num_residues, IMP::Float scale=1.) -> RadiusOfGyrationRestraint"""
        _IMP_multifit.RadiusOfGyrationRestraint_swiginit(self, _IMP_multifit.new_RadiusOfGyrationRestraint(ps, num_residues, scale))

    def do_get_inputs(self):
        r"""do_get_inputs(RadiusOfGyrationRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_multifit.RadiusOfGyrationRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(RadiusOfGyrationRestraint self) -> VersionInfo"""
        return _IMP_multifit.RadiusOfGyrationRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_RadiusOfGyrationRestraint

    def set_radius_of_gyration(self, r):
        r"""set_radius_of_gyration(RadiusOfGyrationRestraint self, IMP::Float r)"""
        return _IMP_multifit.RadiusOfGyrationRestraint_set_radius_of_gyration(self, r)

    def get_radius_of_gyration(self):
        r"""get_radius_of_gyration(RadiusOfGyrationRestraint self) -> IMP::Float"""
        return _IMP_multifit.RadiusOfGyrationRestraint_get_radius_of_gyration(self)

    def __str__(self):
        r"""__str__(RadiusOfGyrationRestraint self) -> std::string"""
        return _IMP_multifit.RadiusOfGyrationRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(RadiusOfGyrationRestraint self) -> std::string"""
        return _IMP_multifit.RadiusOfGyrationRestraint___repr__(self)

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


# Register RadiusOfGyrationRestraint in _IMP_multifit:
_IMP_multifit.RadiusOfGyrationRestraint_swigregister(RadiusOfGyrationRestraint)

def get_approximated_radius_of_gyration(len):
    r"""get_approximated_radius_of_gyration(int len) -> float"""
    return _IMP_multifit.get_approximated_radius_of_gyration(len)

def get_actual_radius_of_gyration(ps):
    r"""get_actual_radius_of_gyration(IMP::ParticlesTemp ps) -> float"""
    return _IMP_multifit.get_actual_radius_of_gyration(ps)

def get_approximated_radius(len):
    r"""get_approximated_radius(int len) -> float"""
    return _IMP_multifit.get_approximated_radius(len)
class ProteinsAnchorsSamplingSpace(object):
    r"""Proxy of C++ IMP::multifit::ProteinsAnchorsSamplingSpace class."""

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

    def __init__(self, prots=None):
        r"""__init__(ProteinsAnchorsSamplingSpace self, ProteomicsData prots=None) -> ProteinsAnchorsSamplingSpace"""
        _IMP_multifit.ProteinsAnchorsSamplingSpace_swiginit(self, _IMP_multifit.new_ProteinsAnchorsSamplingSpace(prots))

    def set_anchors(self, data):
        r"""set_anchors(ProteinsAnchorsSamplingSpace self, AnchorsData data)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_set_anchors(self, data)

    def get_anchors(self):
        r"""get_anchors(ProteinsAnchorsSamplingSpace self) -> AnchorsData"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_get_anchors(self)

    def get_anchors_filename(self):
        r"""get_anchors_filename(ProteinsAnchorsSamplingSpace self) -> std::string"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_get_anchors_filename(self)

    def set_anchors_filename(self, fn):
        r"""set_anchors_filename(ProteinsAnchorsSamplingSpace self, std::string const & fn)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_set_anchors_filename(self, fn)

    def get_proteomics_data(self):
        r"""get_proteomics_data(ProteinsAnchorsSamplingSpace self) -> ProteomicsData"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_get_proteomics_data(self)

    def add_protein(self, rec):
        r"""add_protein(ProteinsAnchorsSamplingSpace self, ProteinRecordData rec)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_add_protein(self, rec)

    def get_paths_for_protein(self, prot_name):
        r"""get_paths_for_protein(ProteinsAnchorsSamplingSpace self, std::string const & prot_name) -> IMP::IntsList"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_get_paths_for_protein(self, prot_name)

    def set_paths_filename_for_protein(self, prot_name, paths_filename):
        r"""set_paths_filename_for_protein(ProteinsAnchorsSamplingSpace self, std::string const & prot_name, std::string const & paths_filename)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_set_paths_filename_for_protein(self, prot_name, paths_filename)

    def get_paths_filename_for_protein(self, prot_name):
        r"""get_paths_filename_for_protein(ProteinsAnchorsSamplingSpace self, std::string const & prot_name) -> std::string"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_get_paths_filename_for_protein(self, prot_name)

    def set_paths_for_protein(self, prot_name, paths):
        r"""set_paths_for_protein(ProteinsAnchorsSamplingSpace self, std::string const & prot_name, IMP::IntsList paths)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_set_paths_for_protein(self, prot_name, paths)

    def show(self, *args):
        r"""show(ProteinsAnchorsSamplingSpace self, _ostream s=std::cout)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_show(self, *args)

    def __str__(self):
        r"""__str__(ProteinsAnchorsSamplingSpace self) -> std::string"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace___str__(self)

    def __repr__(self):
        r"""__repr__(ProteinsAnchorsSamplingSpace self) -> std::string"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace___repr__(self)
    __swig_destroy__ = _IMP_multifit.delete_ProteinsAnchorsSamplingSpace

# Register ProteinsAnchorsSamplingSpace in _IMP_multifit:
_IMP_multifit.ProteinsAnchorsSamplingSpace_swigregister(ProteinsAnchorsSamplingSpace)

def read_protein_anchors_mapping(*args):
    r"""read_protein_anchors_mapping(ProteomicsData prots, std::string const & anchors_prot_map_fn, int max_paths=INT_MAX) -> ProteinsAnchorsSamplingSpace"""
    return _IMP_multifit.read_protein_anchors_mapping(*args)

def write_protein_anchors_mapping(*args):
    r"""
    write_protein_anchors_mapping(std::string const & anchors_prot_map_fn, std::string const & anchors_fn, std::vector< std::pair< IMP::String,IMP::String >,std::allocator< std::pair< IMP::String,IMP::String > > > const & prot_paths)
    write_protein_anchors_mapping(std::string const & anchors_prot_map_fn, ProteinsAnchorsSamplingSpace pa, IMP::Strings const & prot_names)
    """
    return _IMP_multifit.write_protein_anchors_mapping(*args)

def get_part_of_sampling_space(prots_ss, prot_names):
    r"""get_part_of_sampling_space(ProteinsAnchorsSamplingSpace prots_ss, IMP::Strings const & prot_names) -> ProteinsAnchorsSamplingSpace"""
    return _IMP_multifit.get_part_of_sampling_space(prots_ss, prot_names)

def get_partial_assembly_setting_data(prots_sd, prot_names):
    r"""get_partial_assembly_setting_data(SettingsData prots_sd, IMP::Strings const & prot_names) -> SettingsData"""
    return _IMP_multifit.get_partial_assembly_setting_data(prots_sd, prot_names)

def read_paths(*args):
    r"""read_paths(char const * txt_filename, int max_paths=INT_MAX) -> IMP::IntsList"""
    return _IMP_multifit.read_paths(*args)

def write_paths(paths, txt_filename):
    r"""write_paths(IMP::IntsList const & paths, std::string const & txt_filename)"""
    return _IMP_multifit.write_paths(paths, txt_filename)

def molecule2anchors(mh, k):
    r"""molecule2anchors(Hierarchy mh, int k) -> AnchorsData"""
    return _IMP_multifit.molecule2anchors(mh, k)

def get_anchors_for_density(dmap, number_of_means, density_threshold, pdb_filename, cmm_filename, seg_filename, txt_filename):
    r"""get_anchors_for_density(DensityMap dmap, int number_of_means, float density_threshold, std::string pdb_filename, std::string cmm_filename, std::string seg_filename, std::string txt_filename)"""
    return _IMP_multifit.get_anchors_for_density(dmap, number_of_means, density_threshold, pdb_filename, cmm_filename, seg_filename, txt_filename)

def get_anchor_indices_matching_secondary_structure(ad, ssrs, max_rmsd=0.7):
    r"""get_anchor_indices_matching_secondary_structure(AnchorsData ad, IMP::atom::SecondaryStructureResidues const & ssrs, IMP::Float max_rmsd=0.7) -> IMP::IntsList"""
    return _IMP_multifit.get_anchor_indices_matching_secondary_structure(ad, ssrs, max_rmsd)
class DominoParams(object):
    r"""Proxy of C++ IMP::multifit::DominoParams class."""

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

    def __init__(self):
        r"""__init__(DominoParams self) -> DominoParams"""
        _IMP_multifit.DominoParams_swiginit(self, _IMP_multifit.new_DominoParams())

    def add(self, pt):
        r"""add(DominoParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.DominoParams_add(self, pt)

    def show(self, *args):
        r"""show(DominoParams self, _ostream s=std::cout)"""
        return _IMP_multifit.DominoParams_show(self, *args)
    max_value_threshold_ = property(_IMP_multifit.DominoParams_max_value_threshold__get, _IMP_multifit.DominoParams_max_value_threshold__set, doc=r"""max_value_threshold_ : float""")
    max_num_states_for_subset_ = property(_IMP_multifit.DominoParams_max_num_states_for_subset__get, _IMP_multifit.DominoParams_max_num_states_for_subset__set, doc=r"""max_num_states_for_subset_ : int""")
    max_anchor_penetration_ = property(_IMP_multifit.DominoParams_max_anchor_penetration__get, _IMP_multifit.DominoParams_max_anchor_penetration__set, doc=r"""max_anchor_penetration_ : float""")
    heap_size_ = property(_IMP_multifit.DominoParams_heap_size__get, _IMP_multifit.DominoParams_heap_size__set, doc=r"""heap_size_ : int""")
    cache_size_ = property(_IMP_multifit.DominoParams_cache_size__get, _IMP_multifit.DominoParams_cache_size__set, doc=r"""cache_size_ : int""")

    def __str__(self):
        r"""__str__(DominoParams self) -> std::string"""
        return _IMP_multifit.DominoParams___str__(self)

    def __repr__(self):
        r"""__repr__(DominoParams self) -> std::string"""
        return _IMP_multifit.DominoParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(DominoParams self) -> PyObject *"""
        return _IMP_multifit.DominoParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DominoParams self, PyObject * p)"""
        return _IMP_multifit.DominoParams__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_multifit.delete_DominoParams

# Register DominoParams in _IMP_multifit:
_IMP_multifit.DominoParams_swigregister(DominoParams)
class XlinkParams(object):
    r"""Proxy of C++ IMP::multifit::XlinkParams class."""

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

    def __init__(self):
        r"""__init__(XlinkParams self) -> XlinkParams"""
        _IMP_multifit.XlinkParams_swiginit(self, _IMP_multifit.new_XlinkParams())

    def add(self, pt):
        r"""add(XlinkParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.XlinkParams_add(self, pt)

    def show(self, *args):
        r"""show(XlinkParams self, _ostream s=std::cout)"""
        return _IMP_multifit.XlinkParams_show(self, *args)
    upper_bound_ = property(_IMP_multifit.XlinkParams_upper_bound__get, _IMP_multifit.XlinkParams_upper_bound__set, doc=r"""upper_bound_ : float""")
    k_ = property(_IMP_multifit.XlinkParams_k__get, _IMP_multifit.XlinkParams_k__set, doc=r"""k_ : float""")
    max_xlink_val_ = property(_IMP_multifit.XlinkParams_max_xlink_val__get, _IMP_multifit.XlinkParams_max_xlink_val__set, doc=r"""max_xlink_val_ : float""")
    treat_between_residues_ = property(_IMP_multifit.XlinkParams_treat_between_residues__get, _IMP_multifit.XlinkParams_treat_between_residues__set, doc=r"""treat_between_residues_ : bool""")

    def __str__(self):
        r"""__str__(XlinkParams self) -> std::string"""
        return _IMP_multifit.XlinkParams___str__(self)

    def __repr__(self):
        r"""__repr__(XlinkParams self) -> std::string"""
        return _IMP_multifit.XlinkParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(XlinkParams self) -> PyObject *"""
        return _IMP_multifit.XlinkParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XlinkParams self, PyObject * p)"""
        return _IMP_multifit.XlinkParams__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_multifit.delete_XlinkParams

# Register XlinkParams in _IMP_multifit:
_IMP_multifit.XlinkParams_swigregister(XlinkParams)
class ConnectivityParams(object):
    r"""Proxy of C++ IMP::multifit::ConnectivityParams class."""

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

    def __init__(self):
        r"""__init__(ConnectivityParams self) -> ConnectivityParams"""
        _IMP_multifit.ConnectivityParams_swiginit(self, _IMP_multifit.new_ConnectivityParams())

    def add(self, pt):
        r"""add(ConnectivityParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.ConnectivityParams_add(self, pt)

    def show(self, *args):
        r"""show(ConnectivityParams self, _ostream s=std::cout)"""
        return _IMP_multifit.ConnectivityParams_show(self, *args)
    upper_bound_ = property(_IMP_multifit.ConnectivityParams_upper_bound__get, _IMP_multifit.ConnectivityParams_upper_bound__set, doc=r"""upper_bound_ : float""")
    k_ = property(_IMP_multifit.ConnectivityParams_k__get, _IMP_multifit.ConnectivityParams_k__set, doc=r"""k_ : float""")
    max_conn_rest_val_ = property(_IMP_multifit.ConnectivityParams_max_conn_rest_val__get, _IMP_multifit.ConnectivityParams_max_conn_rest_val__set, doc=r"""max_conn_rest_val_ : float""")

    def __str__(self):
        r"""__str__(ConnectivityParams self) -> std::string"""
        return _IMP_multifit.ConnectivityParams___str__(self)

    def __repr__(self):
        r"""__repr__(ConnectivityParams self) -> std::string"""
        return _IMP_multifit.ConnectivityParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ConnectivityParams self) -> PyObject *"""
        return _IMP_multifit.ConnectivityParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ConnectivityParams self, PyObject * p)"""
        return _IMP_multifit.ConnectivityParams__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_multifit.delete_ConnectivityParams

# Register ConnectivityParams in _IMP_multifit:
_IMP_multifit.ConnectivityParams_swigregister(ConnectivityParams)
class FragmentsParams(object):
    r"""Proxy of C++ IMP::multifit::FragmentsParams class."""

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

    def __init__(self):
        r"""__init__(FragmentsParams self) -> FragmentsParams"""
        _IMP_multifit.FragmentsParams_swiginit(self, _IMP_multifit.new_FragmentsParams())

    def add(self, pt):
        r"""add(FragmentsParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.FragmentsParams_add(self, pt)

    def show(self, *args):
        r"""show(FragmentsParams self, _ostream s=std::cout)"""
        return _IMP_multifit.FragmentsParams_show(self, *args)
    frag_len_ = property(_IMP_multifit.FragmentsParams_frag_len__get, _IMP_multifit.FragmentsParams_frag_len__set, doc=r"""frag_len_ : int""")
    bead_radius_scale_ = property(_IMP_multifit.FragmentsParams_bead_radius_scale__get, _IMP_multifit.FragmentsParams_bead_radius_scale__set, doc=r"""bead_radius_scale_ : float""")
    load_atomic_ = property(_IMP_multifit.FragmentsParams_load_atomic__get, _IMP_multifit.FragmentsParams_load_atomic__set, doc=r"""load_atomic_ : bool""")
    subunit_rigid_ = property(_IMP_multifit.FragmentsParams_subunit_rigid__get, _IMP_multifit.FragmentsParams_subunit_rigid__set, doc=r"""subunit_rigid_ : bool""")

    def __str__(self):
        r"""__str__(FragmentsParams self) -> std::string"""
        return _IMP_multifit.FragmentsParams___str__(self)

    def __repr__(self):
        r"""__repr__(FragmentsParams self) -> std::string"""
        return _IMP_multifit.FragmentsParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(FragmentsParams self) -> PyObject *"""
        return _IMP_multifit.FragmentsParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(FragmentsParams self, PyObject * p)"""
        return _IMP_multifit.FragmentsParams__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_multifit.delete_FragmentsParams

# Register FragmentsParams in _IMP_multifit:
_IMP_multifit.FragmentsParams_swigregister(FragmentsParams)
class RogParams(object):
    r"""Proxy of C++ IMP::multifit::RogParams class."""

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

    def __init__(self):
        r"""__init__(RogParams self) -> RogParams"""
        _IMP_multifit.RogParams_swiginit(self, _IMP_multifit.new_RogParams())

    def add(self, pt):
        r"""add(RogParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.RogParams_add(self, pt)

    def get_max_score(self):
        r"""get_max_score(RogParams self) -> float"""
        return _IMP_multifit.RogParams_get_max_score(self)

    def get_scale(self):
        r"""get_scale(RogParams self) -> float"""
        return _IMP_multifit.RogParams_get_scale(self)

    def show(self, *args):
        r"""show(RogParams self, _ostream s=std::cout)"""
        return _IMP_multifit.RogParams_show(self, *args)

    def __str__(self):
        r"""__str__(RogParams self) -> std::string"""
        return _IMP_multifit.RogParams___str__(self)

    def __repr__(self):
        r"""__repr__(RogParams self) -> std::string"""
        return _IMP_multifit.RogParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(RogParams self) -> PyObject *"""
        return _IMP_multifit.RogParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RogParams self, PyObject * p)"""
        return _IMP_multifit.RogParams__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_multifit.delete_RogParams

# Register RogParams in _IMP_multifit:
_IMP_multifit.RogParams_swigregister(RogParams)
class EVParams(object):
    r"""Proxy of C++ IMP::multifit::EVParams class."""

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

    def __init__(self):
        r"""__init__(EVParams self) -> EVParams"""
        _IMP_multifit.EVParams_swiginit(self, _IMP_multifit.new_EVParams())

    def add(self, pt):
        r"""add(EVParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.EVParams_add(self, pt)

    def show(self, *args):
        r"""show(EVParams self, _ostream s=std::cout)"""
        return _IMP_multifit.EVParams_show(self, *args)
    pair_distance_ = property(_IMP_multifit.EVParams_pair_distance__get, _IMP_multifit.EVParams_pair_distance__set, doc=r"""pair_distance_ : float""")
    pair_slack_ = property(_IMP_multifit.EVParams_pair_slack__get, _IMP_multifit.EVParams_pair_slack__set, doc=r"""pair_slack_ : float""")
    hlb_mean_ = property(_IMP_multifit.EVParams_hlb_mean__get, _IMP_multifit.EVParams_hlb_mean__set, doc=r"""hlb_mean_ : float""")
    hlb_k_ = property(_IMP_multifit.EVParams_hlb_k__get, _IMP_multifit.EVParams_hlb_k__set, doc=r"""hlb_k_ : float""")
    maximum_ev_score_for_pair_ = property(_IMP_multifit.EVParams_maximum_ev_score_for_pair__get, _IMP_multifit.EVParams_maximum_ev_score_for_pair__set, doc=r"""maximum_ev_score_for_pair_ : float""")
    allowed_percentage_of_bad_pairs_ = property(_IMP_multifit.EVParams_allowed_percentage_of_bad_pairs__get, _IMP_multifit.EVParams_allowed_percentage_of_bad_pairs__set, doc=r"""allowed_percentage_of_bad_pairs_ : float""")
    scoring_mode_ = property(_IMP_multifit.EVParams_scoring_mode__get, _IMP_multifit.EVParams_scoring_mode__set, doc=r"""scoring_mode_ : int""")

    def __str__(self):
        r"""__str__(EVParams self) -> std::string"""
        return _IMP_multifit.EVParams___str__(self)

    def __repr__(self):
        r"""__repr__(EVParams self) -> std::string"""
        return _IMP_multifit.EVParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(EVParams self) -> PyObject *"""
        return _IMP_multifit.EVParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(EVParams self, PyObject * p)"""
        return _IMP_multifit.EVParams__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_multifit.delete_EVParams

# Register EVParams in _IMP_multifit:
_IMP_multifit.EVParams_swigregister(EVParams)
class FiltersParams(object):
    r"""Proxy of C++ IMP::multifit::FiltersParams class."""

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

    def __init__(self):
        r"""__init__(FiltersParams self) -> FiltersParams"""
        _IMP_multifit.FiltersParams_swiginit(self, _IMP_multifit.new_FiltersParams())

    def add(self, pt):
        r"""add(FiltersParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.FiltersParams_add(self, pt)

    def show(self, *args):
        r"""show(FiltersParams self, _ostream s=std::cout)"""
        return _IMP_multifit.FiltersParams_show(self, *args)
    max_num_violated_xlink_ = property(_IMP_multifit.FiltersParams_max_num_violated_xlink__get, _IMP_multifit.FiltersParams_max_num_violated_xlink__set, doc=r"""max_num_violated_xlink_ : int""")
    max_num_violated_conn_ = property(_IMP_multifit.FiltersParams_max_num_violated_conn__get, _IMP_multifit.FiltersParams_max_num_violated_conn__set, doc=r"""max_num_violated_conn_ : int""")
    max_num_violated_ev_ = property(_IMP_multifit.FiltersParams_max_num_violated_ev__get, _IMP_multifit.FiltersParams_max_num_violated_ev__set, doc=r"""max_num_violated_ev_ : int""")

    def __str__(self):
        r"""__str__(FiltersParams self) -> std::string"""
        return _IMP_multifit.FiltersParams___str__(self)

    def __repr__(self):
        r"""__repr__(FiltersParams self) -> std::string"""
        return _IMP_multifit.FiltersParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(FiltersParams self) -> PyObject *"""
        return _IMP_multifit.FiltersParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(FiltersParams self, PyObject * p)"""
        return _IMP_multifit.FiltersParams__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_multifit.delete_FiltersParams

# Register FiltersParams in _IMP_multifit:
_IMP_multifit.FiltersParams_swigregister(FiltersParams)
class FittingParams(object):
    r"""Proxy of C++ IMP::multifit::FittingParams class."""

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

    def __init__(self):
        r"""__init__(FittingParams self) -> FittingParams"""
        _IMP_multifit.FittingParams_swiginit(self, _IMP_multifit.new_FittingParams())

    def add(self, pt):
        r"""add(FittingParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.FittingParams_add(self, pt)

    def show(self, *args):
        r"""show(FittingParams self, _ostream s=std::cout)"""
        return _IMP_multifit.FittingParams_show(self, *args)
    pca_max_angle_diff_ = property(_IMP_multifit.FittingParams_pca_max_angle_diff__get, _IMP_multifit.FittingParams_pca_max_angle_diff__set, doc=r"""pca_max_angle_diff_ : float""")
    pca_max_size_diff_ = property(_IMP_multifit.FittingParams_pca_max_size_diff__get, _IMP_multifit.FittingParams_pca_max_size_diff__set, doc=r"""pca_max_size_diff_ : float""")
    pca_max_cent_dist_diff_ = property(_IMP_multifit.FittingParams_pca_max_cent_dist_diff__get, _IMP_multifit.FittingParams_pca_max_cent_dist_diff__set, doc=r"""pca_max_cent_dist_diff_ : float""")
    max_asmb_fit_score_ = property(_IMP_multifit.FittingParams_max_asmb_fit_score__get, _IMP_multifit.FittingParams_max_asmb_fit_score__set, doc=r"""max_asmb_fit_score_ : float""")

    def __str__(self):
        r"""__str__(FittingParams self) -> std::string"""
        return _IMP_multifit.FittingParams___str__(self)

    def __repr__(self):
        r"""__repr__(FittingParams self) -> std::string"""
        return _IMP_multifit.FittingParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(FittingParams self) -> PyObject *"""
        return _IMP_multifit.FittingParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(FittingParams self, PyObject * p)"""
        return _IMP_multifit.FittingParams__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_multifit.delete_FittingParams

# Register FittingParams in _IMP_multifit:
_IMP_multifit.FittingParams_swigregister(FittingParams)
class ComplementarityParams(object):
    r"""Proxy of C++ IMP::multifit::ComplementarityParams class."""

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

    def __init__(self):
        r"""__init__(ComplementarityParams self) -> ComplementarityParams"""
        _IMP_multifit.ComplementarityParams_swiginit(self, _IMP_multifit.new_ComplementarityParams())

    def add(self, pt):
        r"""add(ComplementarityParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.ComplementarityParams_add(self, pt)

    def show(self, *args):
        r"""show(ComplementarityParams self, _ostream s=std::cout)"""
        return _IMP_multifit.ComplementarityParams_show(self, *args)
    max_score_ = property(_IMP_multifit.ComplementarityParams_max_score__get, _IMP_multifit.ComplementarityParams_max_score__set, doc=r"""max_score_ : float""")
    max_penetration_ = property(_IMP_multifit.ComplementarityParams_max_penetration__get, _IMP_multifit.ComplementarityParams_max_penetration__set, doc=r"""max_penetration_ : float""")
    interior_layer_thickness_ = property(_IMP_multifit.ComplementarityParams_interior_layer_thickness__get, _IMP_multifit.ComplementarityParams_interior_layer_thickness__set, doc=r"""interior_layer_thickness_ : float""")
    boundary_coef_ = property(_IMP_multifit.ComplementarityParams_boundary_coef__get, _IMP_multifit.ComplementarityParams_boundary_coef__set, doc=r"""boundary_coef_ : float""")
    comp_coef_ = property(_IMP_multifit.ComplementarityParams_comp_coef__get, _IMP_multifit.ComplementarityParams_comp_coef__set, doc=r"""comp_coef_ : float""")
    penetration_coef_ = property(_IMP_multifit.ComplementarityParams_penetration_coef__get, _IMP_multifit.ComplementarityParams_penetration_coef__set, doc=r"""penetration_coef_ : float""")

    def __str__(self):
        r"""__str__(ComplementarityParams self) -> std::string"""
        return _IMP_multifit.ComplementarityParams___str__(self)

    def __repr__(self):
        r"""__repr__(ComplementarityParams self) -> std::string"""
        return _IMP_multifit.ComplementarityParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(ComplementarityParams self) -> PyObject *"""
        return _IMP_multifit.ComplementarityParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ComplementarityParams self, PyObject * p)"""
        return _IMP_multifit.ComplementarityParams__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_multifit.delete_ComplementarityParams

# Register ComplementarityParams in _IMP_multifit:
_IMP_multifit.ComplementarityParams_swigregister(ComplementarityParams)
class AlignmentParams(object):
    r"""Proxy of C++ IMP::multifit::AlignmentParams 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__(AlignmentParams self) -> AlignmentParams
        __init__(AlignmentParams self, char const * param_filename) -> AlignmentParams
        """
        _IMP_multifit.AlignmentParams_swiginit(self, _IMP_multifit.new_AlignmentParams(*args))

    def get_domino_params(self):
        r"""get_domino_params(AlignmentParams self) -> DominoParams"""
        return _IMP_multifit.AlignmentParams_get_domino_params(self)

    def get_fitting_params(self):
        r"""get_fitting_params(AlignmentParams self) -> FittingParams"""
        return _IMP_multifit.AlignmentParams_get_fitting_params(self)

    def get_complementarity_params(self):
        r"""get_complementarity_params(AlignmentParams self) -> ComplementarityParams"""
        return _IMP_multifit.AlignmentParams_get_complementarity_params(self)

    def get_xlink_params(self):
        r"""get_xlink_params(AlignmentParams self) -> XlinkParams"""
        return _IMP_multifit.AlignmentParams_get_xlink_params(self)

    def get_connectivity_params(self):
        r"""get_connectivity_params(AlignmentParams self) -> ConnectivityParams"""
        return _IMP_multifit.AlignmentParams_get_connectivity_params(self)

    def get_rog_params(self):
        r"""get_rog_params(AlignmentParams self) -> RogParams"""
        return _IMP_multifit.AlignmentParams_get_rog_params(self)

    def get_fragments_params(self):
        r"""get_fragments_params(AlignmentParams self) -> FragmentsParams"""
        return _IMP_multifit.AlignmentParams_get_fragments_params(self)

    def get_filters_params(self):
        r"""get_filters_params(AlignmentParams self) -> FiltersParams"""
        return _IMP_multifit.AlignmentParams_get_filters_params(self)

    def get_ev_params(self):
        r"""get_ev_params(AlignmentParams self) -> EVParams"""
        return _IMP_multifit.AlignmentParams_get_ev_params(self)

    def show(self, *args):
        r"""show(AlignmentParams self, _ostream s=std::cout)"""
        return _IMP_multifit.AlignmentParams_show(self, *args)

    def __str__(self):
        r"""__str__(AlignmentParams self) -> std::string"""
        return _IMP_multifit.AlignmentParams___str__(self)

    def __repr__(self):
        r"""__repr__(AlignmentParams self) -> std::string"""
        return _IMP_multifit.AlignmentParams___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(AlignmentParams self) -> PyObject *"""
        return _IMP_multifit.AlignmentParams__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AlignmentParams self, PyObject * p)"""
        return _IMP_multifit.AlignmentParams__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_multifit.delete_AlignmentParams

# Register AlignmentParams in _IMP_multifit:
_IMP_multifit.AlignmentParams_swigregister(AlignmentParams)
class ProteomicsEMAlignmentAtomic(IMP.Object):
    r"""Proxy of C++ IMP::multifit::ProteomicsEMAlignmentAtomic class."""

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

    def __init__(self, mapping_data, asmb_data, align_param):
        r"""__init__(ProteomicsEMAlignmentAtomic self, ProteinsAnchorsSamplingSpace mapping_data, SettingsData asmb_data, AlignmentParams align_param) -> ProteomicsEMAlignmentAtomic"""
        _IMP_multifit.ProteomicsEMAlignmentAtomic_swiginit(self, _IMP_multifit.new_ProteomicsEMAlignmentAtomic(mapping_data, asmb_data, align_param))

    def align(self):
        r"""align(ProteomicsEMAlignmentAtomic self)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_align(self)

    def add_all_restraints(self):
        r"""add_all_restraints(ProteomicsEMAlignmentAtomic self)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_add_all_restraints(self)

    def get_restraint_set(self):
        r"""get_restraint_set(ProteomicsEMAlignmentAtomic self) -> RestraintSet"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_get_restraint_set(self)

    def add_states_and_filters(self):
        r"""add_states_and_filters(ProteomicsEMAlignmentAtomic self)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_add_states_and_filters(self)

    def show_domino_merge_tree(self):
        r"""show_domino_merge_tree(ProteomicsEMAlignmentAtomic self)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_show_domino_merge_tree(self)

    def get_combinations(self, uniques=False):
        r"""get_combinations(ProteomicsEMAlignmentAtomic self, bool uniques=False) -> IMP::domino::Assignments"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_get_combinations(self, uniques)

    def set_density_map(self, dmap, threshold):
        r"""set_density_map(ProteomicsEMAlignmentAtomic self, DensityMap dmap, float threshold)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_set_density_map(self, dmap, threshold)

    def get_molecules(self):
        r"""get_molecules(ProteomicsEMAlignmentAtomic self) -> IMP::atom::Hierarchies"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_get_molecules(self)

    def get_rigid_bodies(self):
        r"""get_rigid_bodies(ProteomicsEMAlignmentAtomic self) -> IMP::core::RigidBodies"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_get_rigid_bodies(self)

    def load_combination_of_states(self, state4particles):
        r"""load_combination_of_states(ProteomicsEMAlignmentAtomic self, IMP::Ints const & state4particles)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_load_combination_of_states(self, state4particles)

    def show_scores_header(self, *args):
        r"""show_scores_header(ProteomicsEMAlignmentAtomic self, _ostream ous=std::cout)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_show_scores_header(self, *args)

    def get_model(self):
        r"""get_model(ProteomicsEMAlignmentAtomic self) -> Model"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_get_model(self)

    def set_fast_scoring(self, state):
        r"""set_fast_scoring(ProteomicsEMAlignmentAtomic self, bool state)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_set_fast_scoring(self, state)

    def get_version_info(self):
        r"""get_version_info(ProteomicsEMAlignmentAtomic self) -> VersionInfo"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_ProteomicsEMAlignmentAtomic

    def __str__(self):
        r"""__str__(ProteomicsEMAlignmentAtomic self) -> std::string"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic___str__(self)

    def __repr__(self):
        r"""__repr__(ProteomicsEMAlignmentAtomic self) -> std::string"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic___repr__(self)

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


# Register ProteomicsEMAlignmentAtomic in _IMP_multifit:
_IMP_multifit.ProteomicsEMAlignmentAtomic_swigregister(ProteomicsEMAlignmentAtomic)

def write_connolly_surface(atoms, fn, density, probe_radius):
    r"""write_connolly_surface(IMP::atom::Atoms atoms, TextOutput fn, float density, float probe_radius)"""
    return _IMP_multifit.write_connolly_surface(atoms, fn, density, probe_radius)
class Ensemble(IMP.Object):
    r"""Proxy of C++ IMP::multifit::Ensemble class."""

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

    def load_combination(self, fit_comb):
        r"""load_combination(Ensemble self, IMP::Ints fit_comb)"""
        return _IMP_multifit.Ensemble_load_combination(self, fit_comb)

    def unload_combination(self, fit_comb):
        r"""unload_combination(Ensemble self, IMP::Ints fit_comb)"""
        return _IMP_multifit.Ensemble_unload_combination(self, fit_comb)

    def add_component_and_fits(self, mh, fits):
        r"""add_component_and_fits(Ensemble self, Hierarchy mh, IMP::multifit::FittingSolutionRecords const & fits)"""
        return _IMP_multifit.Ensemble_add_component_and_fits(self, mh, fits)

    def get_molecules(self):
        r"""get_molecules(Ensemble self) -> IMP::atom::Hierarchies"""
        return _IMP_multifit.Ensemble_get_molecules(self)

    def get_rigid_bodies(self):
        r"""get_rigid_bodies(Ensemble self) -> IMP::core::RigidBodies"""
        return _IMP_multifit.Ensemble_get_rigid_bodies(self)

    def get_rmsd(self, second_xyz):
        r"""get_rmsd(Ensemble self, IMP::core::XYZs const & second_xyz) -> float"""
        return _IMP_multifit.Ensemble_get_rmsd(self, second_xyz)

    def __init__(self, sd, mapping_data):
        r"""__init__(Ensemble self, SettingsData sd, ProteinsAnchorsSamplingSpace mapping_data) -> Ensemble"""
        _IMP_multifit.Ensemble_swiginit(self, _IMP_multifit.new_Ensemble(sd, mapping_data))

    def score_by_restraints(self, rs, combinations):
        r"""score_by_restraints(Ensemble self, IMP::Restraints rs, IMP::IntsList const & combinations) -> std::vector< IMP::Floats,std::allocator< IMP::Floats > >"""
        return _IMP_multifit.Ensemble_score_by_restraints(self, rs, combinations)

    def get_version_info(self):
        r"""get_version_info(Ensemble self) -> VersionInfo"""
        return _IMP_multifit.Ensemble_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_Ensemble

    def __str__(self):
        r"""__str__(Ensemble self) -> std::string"""
        return _IMP_multifit.Ensemble___str__(self)

    def __repr__(self):
        r"""__repr__(Ensemble self) -> std::string"""
        return _IMP_multifit.Ensemble___repr__(self)

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


# Register Ensemble in _IMP_multifit:
_IMP_multifit.Ensemble_swigregister(Ensemble)

def load_ensemble(sd, mdl, mapping_data):
    r"""load_ensemble(SettingsData sd, Model mdl, ProteinsAnchorsSamplingSpace mapping_data) -> Ensemble"""
    return _IMP_multifit.load_ensemble(sd, mdl, mapping_data)
class RigidLeavesRefiner(IMP.Refiner):
    r"""Proxy of C++ IMP::multifit::RigidLeavesRefiner 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__(RigidLeavesRefiner self, std::string name="RigidLeavesRefiner%d") -> RigidLeavesRefiner"""
        _IMP_multifit.RigidLeavesRefiner_swiginit(self, _IMP_multifit.new_RigidLeavesRefiner(*args))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(RigidLeavesRefiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_multifit.RigidLeavesRefiner_do_get_inputs(self, m, pis)

    def get_version_info(self):
        r"""get_version_info(RigidLeavesRefiner self) -> VersionInfo"""
        return _IMP_multifit.RigidLeavesRefiner_get_version_info(self)
    __swig_destroy__ = _IMP_multifit.delete_RigidLeavesRefiner

    def __str__(self):
        r"""__str__(RigidLeavesRefiner self) -> std::string"""
        return _IMP_multifit.RigidLeavesRefiner___str__(self)

    def __repr__(self):
        r"""__repr__(RigidLeavesRefiner self) -> std::string"""
        return _IMP_multifit.RigidLeavesRefiner___repr__(self)

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


# Register RigidLeavesRefiner in _IMP_multifit:
_IMP_multifit.RigidLeavesRefiner_swigregister(RigidLeavesRefiner)

_all_commands = ["param", "anchors", "fit_fft", "cluster", "add_fit_rmsd",
                 "indexes", "proteomics", "align", "models", "transforms",
                 "score", "merge_tree", "reference", "refine_fft", "segment"]


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

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

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

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