multifit/__init__.py

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

from __future__ import print_function, division, absolute_import




from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_IMP_multifit')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_IMP_multifit')
    _IMP_multifit = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_multifit', [dirname(__file__)])
        except ImportError:
            import _IMP_multifit
            return _IMP_multifit
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_multifit', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_multifit = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_multifit
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


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

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_multifit.delete_IMP_MULTIFIT_SwigPyIterator
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def __sub__(self, *args):
        """
        __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
IMP_MULTIFIT_SwigPyIterator_swigregister = _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_swigregister
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_AUTO = _IMP_multifit.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_multifit.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_multifit.IMP_COMPILER_HAS_UNIQUE_PTR
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_multifit.IMP_KERNEL_HAS_BOOST_RANDOM
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):
    """Proxy of C++ std::ostream class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def write(self, osa_buf):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_multifit._ostream_write(self, osa_buf)

_ostream_swigregister = _IMP_multifit._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_multifit.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_multifit.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_multifit.IMP_HAS_NOEXCEPT
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
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_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
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
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
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
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
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
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
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
IMPEM_SHOW_WARNINGS = _IMP_multifit.IMPEM_SHOW_WARNINGS
import IMP.em
IMP_RMF_HAS_IMP_CGAL = _IMP_multifit.IMP_RMF_HAS_IMP_CGAL
IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_multifit.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
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
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_KERNEL = _IMP_multifit.IMP_DOMINO_HAS_IMP_KERNEL
IMP_DOMINO_HAS_IMP_RMF = _IMP_multifit.IMP_DOMINO_HAS_IMP_RMF
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_RMF = _IMP_multifit.IMP_DOMINO_HAS_RMF
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_KERNEL = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_KERNEL
IMP_MULTIFIT_HAS_IMP_RMF = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_RMF
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_RMF = _IMP_multifit.IMP_MULTIFIT_HAS_RMF
IMPMULTIFIT_SHOW_WARNINGS = _IMP_multifit.IMPMULTIFIT_SHOW_WARNINGS

_object_types.append("RadiusOfGyrationRestraint")


def _object_cast_to_RadiusOfGyrationRestraint(o):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_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):
    """_object_cast_to_RigidLeavesRefiner(Object o) -> RigidLeavesRefiner"""
    return _IMP_multifit._object_cast_to_RigidLeavesRefiner(o)

def add_surface_index(*args):
    """
    add_surface_index(Hierarchy mhd, IMP::Float apix, FloatKey shell_key, FloatKey radius_key, FloatKey weight_key)
    add_surface_index(Hierarchy mhd, IMP::Float apix, FloatKey shell_key, FloatKey radius_key)
    add_surface_index(Hierarchy mhd, IMP::Float apix, FloatKey shell_key)
    add_surface_index(Hierarchy mhd, IMP::Float apix)
    """
    return _IMP_multifit.add_surface_index(*args)

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

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

    def __init__(self):
        """__init__(IMP::multifit::FittingSolutionRecord self) -> FittingSolutionRecord"""
        this = _IMP_multifit.new_FittingSolutionRecord()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


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


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


    def set_match_size(self, match_size):
        """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):
        """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):
        """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):
        """get_fitting_score(FittingSolutionRecord self) -> IMP::Float"""
        return _IMP_multifit.FittingSolutionRecord_get_fitting_score(self)


    def set_fitting_score(self, fit_score):
        """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):
        """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):
        """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):
        """get_dock_transformation(FittingSolutionRecord self) -> Transformation3D"""
        return _IMP_multifit.FittingSolutionRecord_get_dock_transformation(self)


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


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


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


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


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

    get_record_header = staticmethod(get_record_header)

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


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

    __swig_destroy__ = _IMP_multifit.delete_FittingSolutionRecord
    __del__ = lambda self: None
FittingSolutionRecord_swigregister = _IMP_multifit.FittingSolutionRecord_swigregister
FittingSolutionRecord_swigregister(FittingSolutionRecord)

def FittingSolutionRecord_get_record_header():
    """FittingSolutionRecord_get_record_header() -> std::string"""
    return _IMP_multifit.FittingSolutionRecord_get_record_header()


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

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

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

    def __init__(self):
        """__init__(IMP::multifit::ComponentHeader self) -> ComponentHeader"""
        this = _IMP_multifit.new_ComponentHeader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


    def set_surface_fn(self, fn):
        """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):
        """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):
        """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):
        """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):
        """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):
        """set_num_ap(ComponentHeader self, int num_ap)"""
        return _IMP_multifit.ComponentHeader_set_num_ap(self, num_ap)


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


    def set_num_fine_ap(self, num_ap):
        """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):
        """get_num_fine_ap(ComponentHeader self) -> int"""
        return _IMP_multifit.ComponentHeader_get_num_fine_ap(self)


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


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


    def set_reference_fn(self, ref_fn):
        """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):
        """get_reference_fn(ComponentHeader self) -> std::string"""
        return _IMP_multifit.ComponentHeader_get_reference_fn(self)


    def get_version_info(self):
        """get_version_info(ComponentHeader self) -> VersionInfo"""
        return _IMP_multifit.ComponentHeader_get_version_info(self)


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


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


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

ComponentHeader_swigregister = _IMP_multifit.ComponentHeader_swigregister
ComponentHeader_swigregister(ComponentHeader)

class AssemblyHeader(IMP.Object):
    """Proxy of C++ IMP::multifit::AssemblyHeader class."""

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

    def __init__(self):
        """__init__(IMP::multifit::AssemblyHeader self) -> AssemblyHeader"""
        this = _IMP_multifit.new_AssemblyHeader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def set_dens_fn(self, dens_fn):
        """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):
        """get_dens_fn(AssemblyHeader self) -> std::string"""
        return _IMP_multifit.AssemblyHeader_get_dens_fn(self)


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


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


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


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


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


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


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


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


    def get_coarse_ap_fn(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """get_version_info(AssemblyHeader self) -> VersionInfo"""
        return _IMP_multifit.AssemblyHeader_get_version_info(self)


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


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


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

AssemblyHeader_swigregister = _IMP_multifit.AssemblyHeader_swigregister
AssemblyHeader_swigregister(AssemblyHeader)

class SettingsData(IMP.Object):
    """Proxy of C++ IMP::multifit::SettingsData class."""

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

    def __init__(self):
        """__init__(IMP::multifit::SettingsData self) -> SettingsData"""
        this = _IMP_multifit.new_SettingsData()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def show_component_header_line(*args):
        """
        show_component_header_line(_ostream out)
        show_component_header_line()
        """
        return _IMP_multifit.SettingsData_show_component_header_line(*args)

    show_component_header_line = staticmethod(show_component_header_line)

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

    get_component_header_line = staticmethod(get_component_header_line)

    def show_density_header_line(*args):
        """
        show_density_header_line(_ostream out)
        show_density_header_line()
        """
        return _IMP_multifit.SettingsData_show_density_header_line(*args)

    show_density_header_line = staticmethod(show_density_header_line)

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

    get_density_header_line = staticmethod(get_density_header_line)

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


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


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


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


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


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


    def get_version_info(self):
        """get_version_info(SettingsData self) -> VersionInfo"""
        return _IMP_multifit.SettingsData_get_version_info(self)


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


    def remove_component_headers(self, d):
        """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):
        """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):
        """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):
        """add_component_header(SettingsData self, ComponentHeader obj) -> unsigned int"""
        return _IMP_multifit.SettingsData_add_component_header(self, obj)


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


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


    def get_number_of_component_headers(self):
        """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):
        """get_has_component_headers(SettingsData self) -> bool"""
        return _IMP_multifit.SettingsData_get_has_component_headers(self)


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


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


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


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


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


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

SettingsData_swigregister = _IMP_multifit.SettingsData_swigregister
SettingsData_swigregister(SettingsData)

def SettingsData_show_component_header_line(*args):
    """
    show_component_header_line(_ostream out)
    SettingsData_show_component_header_line()
    """
    return _IMP_multifit.SettingsData_show_component_header_line(*args)

def SettingsData_get_component_header_line():
    """SettingsData_get_component_header_line() -> std::string"""
    return _IMP_multifit.SettingsData_get_component_header_line()

def SettingsData_show_density_header_line(*args):
    """
    show_density_header_line(_ostream out)
    SettingsData_show_density_header_line()
    """
    return _IMP_multifit.SettingsData_show_density_header_line(*args)

def SettingsData_get_density_header_line():
    """SettingsData_get_density_header_line() -> std::string"""
    return _IMP_multifit.SettingsData_get_density_header_line()


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

def write_settings(filename, sd):
    """write_settings(char const * filename, SettingsData sd)"""
    return _IMP_multifit.write_settings(filename, sd)
class WeightedExcludedVolumeRestraint(IMP.Restraint):
    """Proxy of C++ IMP::multifit::WeightedExcludedVolumeRestraint class."""

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

    def __init__(self, *args):
        """
        __init__(IMP::multifit::WeightedExcludedVolumeRestraint self, IMP::core::RigidBodies rbs, Refiner refiner, FloatKey weight_key) -> WeightedExcludedVolumeRestraint
        __init__(IMP::multifit::WeightedExcludedVolumeRestraint self, IMP::core::RigidBodies rbs, Refiner refiner) -> WeightedExcludedVolumeRestraint
        """
        this = _IMP_multifit.new_WeightedExcludedVolumeRestraint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(WeightedExcludedVolumeRestraint self) -> VersionInfo"""
        return _IMP_multifit.WeightedExcludedVolumeRestraint_get_version_info(self)


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


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


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

WeightedExcludedVolumeRestraint_swigregister = _IMP_multifit.WeightedExcludedVolumeRestraint_swigregister
WeightedExcludedVolumeRestraint_swigregister(WeightedExcludedVolumeRestraint)

class FFTFittingOutput(IMP.Object):
    """Proxy of C++ IMP::multifit::FFTFittingOutput class."""

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

    def __init__(self):
        """__init__(IMP::multifit::FFTFittingOutput self) -> FFTFittingOutput"""
        this = _IMP_multifit.new_FFTFittingOutput()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(FFTFittingOutput self) -> VersionInfo"""
        return _IMP_multifit.FFTFittingOutput_get_version_info(self)

    best_fits_ = _swig_property(_IMP_multifit.FFTFittingOutput_best_fits__get, _IMP_multifit.FFTFittingOutput_best_fits__set)
    best_trans_per_rot_ = _swig_property(_IMP_multifit.FFTFittingOutput_best_trans_per_rot__get, _IMP_multifit.FFTFittingOutput_best_trans_per_rot__set)

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


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


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

FFTFittingOutput_swigregister = _IMP_multifit.FFTFittingOutput_swigregister
FFTFittingOutput_swigregister(FFTFittingOutput)

class FFTFitting(IMP.Object):
    """Proxy of C++ IMP::multifit::FFTFitting class."""

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

    def get_version_info(self):
        """get_version_info(FFTFitting self) -> VersionInfo"""
        return _IMP_multifit.FFTFitting_get_version_info(self)


    def __init__(self):
        """__init__(IMP::multifit::FFTFitting self) -> FFTFitting"""
        this = _IMP_multifit.new_FFTFitting()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def do_global_fitting(self, *args):
        """
        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
        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) -> FFTFittingOutput
        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) -> FFTFittingOutput
        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) -> FFTFittingOutput
        """
        return _IMP_multifit.FFTFitting_do_global_fitting(self, *args)


    def do_local_fitting(self, *args):
        """
        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
        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) -> FFTFittingOutput
        """
        return _IMP_multifit.FFTFitting_do_local_fitting(self, *args)


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


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


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

FFTFitting_swigregister = _IMP_multifit.FFTFitting_swigregister
FFTFitting_swigregister(FFTFitting)


def fft_based_rigid_fitting(mol2fit, dmap, density_threshold, angle_sampling_interval_rad):
    """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):
    """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):
    """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):
    """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):
    """Proxy of C++ IMP::multifit::ComplementarityRestraint class."""

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

    def __init__(self, *args):
        """
        __init__(IMP::multifit::ComplementarityRestraint self, IMP::ParticlesTemp const & a, IMP::ParticlesTemp const & b, std::string name) -> ComplementarityRestraint
        __init__(IMP::multifit::ComplementarityRestraint self, IMP::ParticlesTemp const & a, IMP::ParticlesTemp const & b) -> ComplementarityRestraint
        """
        this = _IMP_multifit.new_ComplementarityRestraint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


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


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


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


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


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


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


    def get_version_info(self):
        """get_version_info(ComplementarityRestraint self) -> VersionInfo"""
        return _IMP_multifit.ComplementarityRestraint_get_version_info(self)


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


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


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

ComplementarityRestraint_swigregister = _IMP_multifit.ComplementarityRestraint_swigregister
ComplementarityRestraint_swigregister(ComplementarityRestraint)


def read_fitting_solutions(fitting_fn):
    """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):
    """
    write_fitting_solutions(char const * fitting_fn, IMP::multifit::FittingSolutionRecords const & fit_sols, int num_sols=-1)
    write_fitting_solutions(char const * fitting_fn, IMP::multifit::FittingSolutionRecords const & fit_sols)
    """
    return _IMP_multifit.write_fitting_solutions(fitting_fn, fit_sols, num_sols)

def convert_em_to_multifit_format(em_fits):
    """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):
    """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):
    """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):
    """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):
    """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):
    """Proxy of C++ IMP::multifit::ProbabilisticAnchorGraph class."""

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

    def __init__(self, anchor_positions):
        """__init__(IMP::multifit::ProbabilisticAnchorGraph self, IMP::algebra::Vector3Ds anchor_positions) -> ProbabilisticAnchorGraph"""
        this = _IMP_multifit.new_ProbabilisticAnchorGraph(anchor_positions)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add_edge(self, i, j):
        """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):
        """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):
        """
        show(ProbabilisticAnchorGraph self, _ostream out)
        show(ProbabilisticAnchorGraph self)
        """
        return _IMP_multifit.ProbabilisticAnchorGraph_show(self, *args)


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


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


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


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


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


    def get_are_probabilities_for_particle_set(self, p):
        """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):
        """get_particle_probabilities(ProbabilisticAnchorGraph self, Particle p) -> IMP::Floats"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_particle_probabilities(self, p)


    def get_version_info(self):
        """get_version_info(ProbabilisticAnchorGraph self) -> VersionInfo"""
        return _IMP_multifit.ProbabilisticAnchorGraph_get_version_info(self)


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


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


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

ProbabilisticAnchorGraph_swigregister = _IMP_multifit.ProbabilisticAnchorGraph_swigregister
ProbabilisticAnchorGraph_swigregister(ProbabilisticAnchorGraph)

class ProteinRecordData(object):
    """Proxy of C++ IMP::multifit::ProteinRecordData class."""

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

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


    def __init__(self, *args):
        """
        __init__(IMP::multifit::ProteinRecordData self) -> ProteinRecordData
        __init__(IMP::multifit::ProteinRecordData self, std::string const & name) -> ProteinRecordData
        __init__(IMP::multifit::ProteinRecordData self, std::string const & name, std::string const fn) -> ProteinRecordData
        __init__(IMP::multifit::ProteinRecordData self, std::string const & name, int start_res, int end_res, std::string const fn) -> ProteinRecordData
        __init__(IMP::multifit::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
        """
        this = _IMP_multifit.new_ProteinRecordData(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def show(self, *args):
        """
        show(ProteinRecordData self, _ostream out)
        show(ProteinRecordData self)
        """
        return _IMP_multifit.ProteinRecordData_show(self, *args)

    name_ = _swig_property(_IMP_multifit.ProteinRecordData_name__get, _IMP_multifit.ProteinRecordData_name__set)
    start_res_ = _swig_property(_IMP_multifit.ProteinRecordData_start_res__get, _IMP_multifit.ProteinRecordData_start_res__set)
    end_res_ = _swig_property(_IMP_multifit.ProteinRecordData_end_res__get, _IMP_multifit.ProteinRecordData_end_res__set)
    filename_ = _swig_property(_IMP_multifit.ProteinRecordData_filename__get, _IMP_multifit.ProteinRecordData_filename__set)
    surface_filename_ = _swig_property(_IMP_multifit.ProteinRecordData_surface_filename__get, _IMP_multifit.ProteinRecordData_surface_filename__set)
    ref_filename_ = _swig_property(_IMP_multifit.ProteinRecordData_ref_filename__get, _IMP_multifit.ProteinRecordData_ref_filename__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_ProteinRecordData
    __del__ = lambda self: None
ProteinRecordData_swigregister = _IMP_multifit.ProteinRecordData_swigregister
ProteinRecordData_swigregister(ProteinRecordData)

class ProteomicsData(IMP.Object):
    """Proxy of C++ IMP::multifit::ProteomicsData class."""

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

    def __init__(self):
        """__init__(IMP::multifit::ProteomicsData self) -> ProteomicsData"""
        this = _IMP_multifit.new_ProteomicsData()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add_protein(self, *args):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """get_number_of_proteins(ProteomicsData self) -> int"""
        return _IMP_multifit.ProteomicsData_get_number_of_proteins(self)


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


    def get_interaction(self, interaction_ind):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """get_protein_data(ProteomicsData self, int protein_ind) -> ProteinRecordData"""
        return _IMP_multifit.ProteomicsData_get_protein_data(self, protein_ind)


    def get_version_info(self):
        """get_version_info(ProteomicsData self) -> VersionInfo"""
        return _IMP_multifit.ProteomicsData_get_version_info(self)


    def get_num_allowed_violated_interactions(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """set_num_allowed_violated_ev(ProteomicsData self, int n)"""
        return _IMP_multifit.ProteomicsData_set_num_allowed_violated_ev(self, n)


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


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


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

ProteomicsData_swigregister = _IMP_multifit.ProteomicsData_swigregister
ProteomicsData_swigregister(ProteomicsData)


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

def get_partial_proteomics_data(pd, prot_names):
    """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):
    """Proxy of C++ IMP::multifit::AnchorsData class."""

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

    def __init__(self, *args):
        """
        __init__(IMP::multifit::AnchorsData self) -> AnchorsData
        __init__(IMP::multifit::AnchorsData self, IMP::algebra::Vector3Ds points, IMP::IntPairs edges) -> AnchorsData
        """
        this = _IMP_multifit.new_AnchorsData(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def remove_edges_for_node(self, node_ind):
        """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):
        """get_number_of_points(AnchorsData self) -> int"""
        return _IMP_multifit.AnchorsData_get_number_of_points(self)


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


    def get_is_point_considered(self, node_ind):
        """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):
        """
        show(AnchorsData self, _ostream out)
        show(AnchorsData self)
        """
        return _IMP_multifit.AnchorsData_show(self, *args)


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


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


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


    def get_secondary_structure_particles(self):
        """get_secondary_structure_particles(AnchorsData self) -> IMP::Particles"""
        return _IMP_multifit.AnchorsData_get_secondary_structure_particles(self)

    points_ = _swig_property(_IMP_multifit.AnchorsData_points__get, _IMP_multifit.AnchorsData_points__set)
    consider_point_ = _swig_property(_IMP_multifit.AnchorsData_consider_point__get, _IMP_multifit.AnchorsData_consider_point__set)
    edges_ = _swig_property(_IMP_multifit.AnchorsData_edges__get, _IMP_multifit.AnchorsData_edges__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_AnchorsData
    __del__ = lambda self: None
AnchorsData_swigregister = _IMP_multifit.AnchorsData_swigregister
AnchorsData_swigregister(AnchorsData)


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

def write_txt(txt_filename, ad):
    """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):
    """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):
    """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):
    """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):
    """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):
    """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):
    """Proxy of C++ IMP::multifit::RadiusOfGyrationRestraint class."""

    thisown = _swig_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.):
        """
        __init__(IMP::multifit::RadiusOfGyrationRestraint self, IMP::Particles ps, int num_residues, IMP::Float scale=1.) -> RadiusOfGyrationRestraint
        __init__(IMP::multifit::RadiusOfGyrationRestraint self, IMP::Particles ps, int num_residues) -> RadiusOfGyrationRestraint
        """
        this = _IMP_multifit.new_RadiusOfGyrationRestraint(ps, num_residues, scale)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def get_version_info(self):
        """get_version_info(RadiusOfGyrationRestraint self) -> VersionInfo"""
        return _IMP_multifit.RadiusOfGyrationRestraint_get_version_info(self)


    def set_radius_of_gyration(self, 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):
        """get_radius_of_gyration(RadiusOfGyrationRestraint self) -> IMP::Float"""
        return _IMP_multifit.RadiusOfGyrationRestraint_get_radius_of_gyration(self)


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


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


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

RadiusOfGyrationRestraint_swigregister = _IMP_multifit.RadiusOfGyrationRestraint_swigregister
RadiusOfGyrationRestraint_swigregister(RadiusOfGyrationRestraint)


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

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

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

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

    def __init__(self, prots=None):
        """
        __init__(IMP::multifit::ProteinsAnchorsSamplingSpace self, ProteomicsData prots=None) -> ProteinsAnchorsSamplingSpace
        __init__(IMP::multifit::ProteinsAnchorsSamplingSpace self) -> ProteinsAnchorsSamplingSpace
        """
        this = _IMP_multifit.new_ProteinsAnchorsSamplingSpace(prots)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


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


    def get_paths_for_protein(self, prot_name):
        """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):
        """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):
        """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):
        """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):
        """
        show(ProteinsAnchorsSamplingSpace self, _ostream s)
        show(ProteinsAnchorsSamplingSpace self)
        """
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_show(self, *args)


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


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

    __swig_destroy__ = _IMP_multifit.delete_ProteinsAnchorsSamplingSpace
    __del__ = lambda self: None
ProteinsAnchorsSamplingSpace_swigregister = _IMP_multifit.ProteinsAnchorsSamplingSpace_swigregister
ProteinsAnchorsSamplingSpace_swigregister(ProteinsAnchorsSamplingSpace)


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

def write_protein_anchors_mapping(*args):
    """
    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):
    """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):
    """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):
    """
    read_paths(char const * txt_filename, int max_paths) -> IMP::IntsList
    read_paths(char const * txt_filename) -> IMP::IntsList
    """
    return _IMP_multifit.read_paths(*args)

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

def molecule2anchors(mh, k):
    """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):
    """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):
    """
    get_anchor_indices_matching_secondary_structure(AnchorsData ad, IMP::atom::SecondaryStructureResidues const & ssrs, IMP::Float max_rmsd=0.7) -> IMP::IntsList
    get_anchor_indices_matching_secondary_structure(AnchorsData ad, IMP::atom::SecondaryStructureResidues const & ssrs) -> IMP::IntsList
    """
    return _IMP_multifit.get_anchor_indices_matching_secondary_structure(ad, ssrs, max_rmsd)
class DominoParams(object):
    """Proxy of C++ IMP::multifit::DominoParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::DominoParams self) -> DominoParams"""
        this = _IMP_multifit.new_DominoParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(DominoParams self, _ostream s)
        show(DominoParams self)
        """
        return _IMP_multifit.DominoParams_show(self, *args)

    max_value_threshold_ = _swig_property(_IMP_multifit.DominoParams_max_value_threshold__get, _IMP_multifit.DominoParams_max_value_threshold__set)
    max_num_states_for_subset_ = _swig_property(_IMP_multifit.DominoParams_max_num_states_for_subset__get, _IMP_multifit.DominoParams_max_num_states_for_subset__set)
    max_anchor_penetration_ = _swig_property(_IMP_multifit.DominoParams_max_anchor_penetration__get, _IMP_multifit.DominoParams_max_anchor_penetration__set)
    heap_size_ = _swig_property(_IMP_multifit.DominoParams_heap_size__get, _IMP_multifit.DominoParams_heap_size__set)
    cache_size_ = _swig_property(_IMP_multifit.DominoParams_cache_size__get, _IMP_multifit.DominoParams_cache_size__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_DominoParams
    __del__ = lambda self: None
DominoParams_swigregister = _IMP_multifit.DominoParams_swigregister
DominoParams_swigregister(DominoParams)

class XlinkParams(object):
    """Proxy of C++ IMP::multifit::XlinkParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::XlinkParams self) -> XlinkParams"""
        this = _IMP_multifit.new_XlinkParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(XlinkParams self, _ostream s)
        show(XlinkParams self)
        """
        return _IMP_multifit.XlinkParams_show(self, *args)

    upper_bound_ = _swig_property(_IMP_multifit.XlinkParams_upper_bound__get, _IMP_multifit.XlinkParams_upper_bound__set)
    k_ = _swig_property(_IMP_multifit.XlinkParams_k__get, _IMP_multifit.XlinkParams_k__set)
    max_xlink_val_ = _swig_property(_IMP_multifit.XlinkParams_max_xlink_val__get, _IMP_multifit.XlinkParams_max_xlink_val__set)
    treat_between_residues_ = _swig_property(_IMP_multifit.XlinkParams_treat_between_residues__get, _IMP_multifit.XlinkParams_treat_between_residues__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_XlinkParams
    __del__ = lambda self: None
XlinkParams_swigregister = _IMP_multifit.XlinkParams_swigregister
XlinkParams_swigregister(XlinkParams)

class ConnectivityParams(object):
    """Proxy of C++ IMP::multifit::ConnectivityParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::ConnectivityParams self) -> ConnectivityParams"""
        this = _IMP_multifit.new_ConnectivityParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(ConnectivityParams self, _ostream s)
        show(ConnectivityParams self)
        """
        return _IMP_multifit.ConnectivityParams_show(self, *args)

    upper_bound_ = _swig_property(_IMP_multifit.ConnectivityParams_upper_bound__get, _IMP_multifit.ConnectivityParams_upper_bound__set)
    k_ = _swig_property(_IMP_multifit.ConnectivityParams_k__get, _IMP_multifit.ConnectivityParams_k__set)
    max_conn_rest_val_ = _swig_property(_IMP_multifit.ConnectivityParams_max_conn_rest_val__get, _IMP_multifit.ConnectivityParams_max_conn_rest_val__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_ConnectivityParams
    __del__ = lambda self: None
ConnectivityParams_swigregister = _IMP_multifit.ConnectivityParams_swigregister
ConnectivityParams_swigregister(ConnectivityParams)

class FragmentsParams(object):
    """Proxy of C++ IMP::multifit::FragmentsParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::FragmentsParams self) -> FragmentsParams"""
        this = _IMP_multifit.new_FragmentsParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(FragmentsParams self, _ostream s)
        show(FragmentsParams self)
        """
        return _IMP_multifit.FragmentsParams_show(self, *args)

    frag_len_ = _swig_property(_IMP_multifit.FragmentsParams_frag_len__get, _IMP_multifit.FragmentsParams_frag_len__set)
    bead_radius_scale_ = _swig_property(_IMP_multifit.FragmentsParams_bead_radius_scale__get, _IMP_multifit.FragmentsParams_bead_radius_scale__set)
    load_atomic_ = _swig_property(_IMP_multifit.FragmentsParams_load_atomic__get, _IMP_multifit.FragmentsParams_load_atomic__set)
    subunit_rigid_ = _swig_property(_IMP_multifit.FragmentsParams_subunit_rigid__get, _IMP_multifit.FragmentsParams_subunit_rigid__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_FragmentsParams
    __del__ = lambda self: None
FragmentsParams_swigregister = _IMP_multifit.FragmentsParams_swigregister
FragmentsParams_swigregister(FragmentsParams)

class RogParams(object):
    """Proxy of C++ IMP::multifit::RogParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::RogParams self) -> RogParams"""
        this = _IMP_multifit.new_RogParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


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

    __swig_destroy__ = _IMP_multifit.delete_RogParams
    __del__ = lambda self: None
RogParams_swigregister = _IMP_multifit.RogParams_swigregister
RogParams_swigregister(RogParams)

class EVParams(object):
    """Proxy of C++ IMP::multifit::EVParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::EVParams self) -> EVParams"""
        this = _IMP_multifit.new_EVParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(EVParams self, _ostream s)
        show(EVParams self)
        """
        return _IMP_multifit.EVParams_show(self, *args)

    pair_distance_ = _swig_property(_IMP_multifit.EVParams_pair_distance__get, _IMP_multifit.EVParams_pair_distance__set)
    pair_slack_ = _swig_property(_IMP_multifit.EVParams_pair_slack__get, _IMP_multifit.EVParams_pair_slack__set)
    hlb_mean_ = _swig_property(_IMP_multifit.EVParams_hlb_mean__get, _IMP_multifit.EVParams_hlb_mean__set)
    hlb_k_ = _swig_property(_IMP_multifit.EVParams_hlb_k__get, _IMP_multifit.EVParams_hlb_k__set)
    maximum_ev_score_for_pair_ = _swig_property(_IMP_multifit.EVParams_maximum_ev_score_for_pair__get, _IMP_multifit.EVParams_maximum_ev_score_for_pair__set)
    allowed_percentage_of_bad_pairs_ = _swig_property(_IMP_multifit.EVParams_allowed_percentage_of_bad_pairs__get, _IMP_multifit.EVParams_allowed_percentage_of_bad_pairs__set)
    scoring_mode_ = _swig_property(_IMP_multifit.EVParams_scoring_mode__get, _IMP_multifit.EVParams_scoring_mode__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_EVParams
    __del__ = lambda self: None
EVParams_swigregister = _IMP_multifit.EVParams_swigregister
EVParams_swigregister(EVParams)

class FiltersParams(object):
    """Proxy of C++ IMP::multifit::FiltersParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::FiltersParams self) -> FiltersParams"""
        this = _IMP_multifit.new_FiltersParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(FiltersParams self, _ostream s)
        show(FiltersParams self)
        """
        return _IMP_multifit.FiltersParams_show(self, *args)

    max_num_violated_xlink_ = _swig_property(_IMP_multifit.FiltersParams_max_num_violated_xlink__get, _IMP_multifit.FiltersParams_max_num_violated_xlink__set)
    max_num_violated_conn_ = _swig_property(_IMP_multifit.FiltersParams_max_num_violated_conn__get, _IMP_multifit.FiltersParams_max_num_violated_conn__set)
    max_num_violated_ev_ = _swig_property(_IMP_multifit.FiltersParams_max_num_violated_ev__get, _IMP_multifit.FiltersParams_max_num_violated_ev__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_FiltersParams
    __del__ = lambda self: None
FiltersParams_swigregister = _IMP_multifit.FiltersParams_swigregister
FiltersParams_swigregister(FiltersParams)

class FittingParams(object):
    """Proxy of C++ IMP::multifit::FittingParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::FittingParams self) -> FittingParams"""
        this = _IMP_multifit.new_FittingParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(FittingParams self, _ostream s)
        show(FittingParams self)
        """
        return _IMP_multifit.FittingParams_show(self, *args)

    pca_max_angle_diff_ = _swig_property(_IMP_multifit.FittingParams_pca_max_angle_diff__get, _IMP_multifit.FittingParams_pca_max_angle_diff__set)
    pca_max_size_diff_ = _swig_property(_IMP_multifit.FittingParams_pca_max_size_diff__get, _IMP_multifit.FittingParams_pca_max_size_diff__set)
    pca_max_cent_dist_diff_ = _swig_property(_IMP_multifit.FittingParams_pca_max_cent_dist_diff__get, _IMP_multifit.FittingParams_pca_max_cent_dist_diff__set)
    max_asmb_fit_score_ = _swig_property(_IMP_multifit.FittingParams_max_asmb_fit_score__get, _IMP_multifit.FittingParams_max_asmb_fit_score__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_FittingParams
    __del__ = lambda self: None
FittingParams_swigregister = _IMP_multifit.FittingParams_swigregister
FittingParams_swigregister(FittingParams)

class ComplementarityParams(object):
    """Proxy of C++ IMP::multifit::ComplementarityParams class."""

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

    def __init__(self):
        """__init__(IMP::multifit::ComplementarityParams self) -> ComplementarityParams"""
        this = _IMP_multifit.new_ComplementarityParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


    def show(self, *args):
        """
        show(ComplementarityParams self, _ostream s)
        show(ComplementarityParams self)
        """
        return _IMP_multifit.ComplementarityParams_show(self, *args)

    max_score_ = _swig_property(_IMP_multifit.ComplementarityParams_max_score__get, _IMP_multifit.ComplementarityParams_max_score__set)
    max_penetration_ = _swig_property(_IMP_multifit.ComplementarityParams_max_penetration__get, _IMP_multifit.ComplementarityParams_max_penetration__set)
    interior_layer_thickness_ = _swig_property(_IMP_multifit.ComplementarityParams_interior_layer_thickness__get, _IMP_multifit.ComplementarityParams_interior_layer_thickness__set)
    boundary_coef_ = _swig_property(_IMP_multifit.ComplementarityParams_boundary_coef__get, _IMP_multifit.ComplementarityParams_boundary_coef__set)
    comp_coef_ = _swig_property(_IMP_multifit.ComplementarityParams_comp_coef__get, _IMP_multifit.ComplementarityParams_comp_coef__set)
    penetration_coef_ = _swig_property(_IMP_multifit.ComplementarityParams_penetration_coef__get, _IMP_multifit.ComplementarityParams_penetration_coef__set)

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


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

    __swig_destroy__ = _IMP_multifit.delete_ComplementarityParams
    __del__ = lambda self: None
ComplementarityParams_swigregister = _IMP_multifit.ComplementarityParams_swigregister
ComplementarityParams_swigregister(ComplementarityParams)

class AlignmentParams(object):
    """Proxy of C++ IMP::multifit::AlignmentParams class."""

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

    def __init__(self, param_filename):
        """__init__(IMP::multifit::AlignmentParams self, char const * param_filename) -> AlignmentParams"""
        this = _IMP_multifit.new_AlignmentParams(param_filename)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


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


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


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


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


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


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


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

    __swig_destroy__ = _IMP_multifit.delete_AlignmentParams
    __del__ = lambda self: None
AlignmentParams_swigregister = _IMP_multifit.AlignmentParams_swigregister
AlignmentParams_swigregister(AlignmentParams)

class ProteomicsEMAlignmentAtomic(IMP.Object):
    """Proxy of C++ IMP::multifit::ProteomicsEMAlignmentAtomic class."""

    thisown = _swig_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):
        """__init__(IMP::multifit::ProteomicsEMAlignmentAtomic self, ProteinsAnchorsSamplingSpace mapping_data, SettingsData asmb_data, AlignmentParams align_param) -> ProteomicsEMAlignmentAtomic"""
        this = _IMP_multifit.new_ProteomicsEMAlignmentAtomic(mapping_data, asmb_data, align_param)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


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


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


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


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


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


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


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


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


    def load_combination_of_states(self, state4particles):
        """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):
        """
        show_scores_header(ProteomicsEMAlignmentAtomic self, _ostream ous)
        show_scores_header(ProteomicsEMAlignmentAtomic self)
        """
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_show_scores_header(self, *args)


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


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


    def get_version_info(self):
        """get_version_info(ProteomicsEMAlignmentAtomic self) -> VersionInfo"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_get_version_info(self)


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


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


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

ProteomicsEMAlignmentAtomic_swigregister = _IMP_multifit.ProteomicsEMAlignmentAtomic_swigregister
ProteomicsEMAlignmentAtomic_swigregister(ProteomicsEMAlignmentAtomic)


def write_connolly_surface(atoms, fn, density, probe_radius):
    """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):
    """Proxy of C++ IMP::multifit::Ensemble class."""

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

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


    def unload_combination(self, fit_comb):
        """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):
        """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):
        """get_molecules(Ensemble self) -> IMP::atom::Hierarchies"""
        return _IMP_multifit.Ensemble_get_molecules(self)


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


    def get_rmsd(self, second_xyz):
        """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):
        """__init__(IMP::multifit::Ensemble self, SettingsData sd, ProteinsAnchorsSamplingSpace mapping_data) -> Ensemble"""
        this = _IMP_multifit.new_Ensemble(sd, mapping_data)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def score_by_restraints(self, rs, combinations):
        """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):
        """get_version_info(Ensemble self) -> VersionInfo"""
        return _IMP_multifit.Ensemble_get_version_info(self)


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


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


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

Ensemble_swigregister = _IMP_multifit.Ensemble_swigregister
Ensemble_swigregister(Ensemble)


def load_ensemble(sd, mdl, mapping_data):
    """load_ensemble(SettingsData sd, Model mdl, ProteinsAnchorsSamplingSpace mapping_data) -> Ensemble"""
    return _IMP_multifit.load_ensemble(sd, mdl, mapping_data)
class RigidLeavesRefiner(IMP.Refiner):
    """Proxy of C++ IMP::multifit::RigidLeavesRefiner class."""

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

    def __init__(self, *args):
        """
        __init__(IMP::multifit::RigidLeavesRefiner self, std::string name) -> RigidLeavesRefiner
        __init__(IMP::multifit::RigidLeavesRefiner self) -> RigidLeavesRefiner
        """
        this = _IMP_multifit.new_RigidLeavesRefiner(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """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):
        """get_version_info(RigidLeavesRefiner self) -> VersionInfo"""
        return _IMP_multifit.RigidLeavesRefiner_get_version_info(self)


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


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


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

RigidLeavesRefiner_swigregister = _IMP_multifit.RigidLeavesRefiner_swigregister
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():
    """get_module_version() -> std::string const"""
    return _IMP_multifit.get_module_version()

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

def get_data_path(fname):
    """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()