multifit/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.



from sys import version_info
if 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 version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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):
        self.__dict__[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(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


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


class IMP_MULTIFIT_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_MULTIFIT_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_MULTIFIT_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_MULTIFIT_SwigPyIterator, name)
    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, *args):
        """distance(IMP_MULTIFIT_SwigPyIterator self, IMP_MULTIFIT_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_distance(self, *args)

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

    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, *args):
        """advance(IMP_MULTIFIT_SwigPyIterator self, ptrdiff_t n) -> IMP_MULTIFIT_SwigPyIterator"""
        return _IMP_multifit.IMP_MULTIFIT_SwigPyIterator_advance(self, *args)

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

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

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

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

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

    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_HAS_DEPRECATED = _IMP_multifit.IMP_HAS_DEPRECATED
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_NONE = _IMP_multifit.IMP_NONE
IMP_USAGE = _IMP_multifit.IMP_USAGE
IMP_INTERNAL = _IMP_multifit.IMP_INTERNAL
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_NULLPTR = _IMP_multifit.IMP_COMPILER_HAS_NULLPTR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_multifit.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_multifit.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_LOG4CXX = _IMP_multifit.IMP_BASE_HAS_LOG4CXX
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_multifit.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_multifit.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
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]
        
        
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

DEFAULT_CHECK = _IMP_multifit.DEFAULT_CHECK
NONE = _IMP_multifit.NONE
USAGE = _IMP_multifit.USAGE
USAGE_AND_INTERNAL = _IMP_multifit.USAGE_AND_INTERNAL

def set_check_level(*args):
  """set_check_level(IMP::base::CheckLevel tf)"""
  return _IMP_multifit.set_check_level(*args)

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_multifit.get_check_level()
class _ostream(_object):
    """Proxy of C++ std::ostream class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ostream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ostream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *args):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_multifit._ostream_write(self, *args)

_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
import IMP.base
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
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
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_multifit.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_multifit.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_multifit.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_multifit.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_multifit.IMP_KERNEL_HAS_CGAL
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_multifit.IMP_DISPLAY_HAS_IMP_BASE
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
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
import IMP.score_functor
IMP_STATISTICS_HAS_IMP_BASE = _IMP_multifit.IMP_STATISTICS_HAS_IMP_BASE
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
import IMP.statistics
IMP_CORE_HAS_IMP_BASE = _IMP_multifit.IMP_CORE_HAS_IMP_BASE
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
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_multifit.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_multifit.IMP_CONTAINER_HAS_IMP_BASE
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
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_multifit.IMP_ATOM_HAS_IMP_BASE
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_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_KERNEL = _IMP_multifit.IMP_EM_HAS_IMP_KERNEL
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
import IMP.em
IMP_RMF_HAS_IMP_BASE = _IMP_multifit.IMP_RMF_HAS_IMP_BASE
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
import IMP.rmf
import RMF
IMP_DOMINO_HAS_IMP_ATOM = _IMP_multifit.IMP_DOMINO_HAS_IMP_ATOM
IMP_DOMINO_HAS_IMP_BASE = _IMP_multifit.IMP_DOMINO_HAS_IMP_BASE
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
import RMF_HDF5
import IMP.domino
IMP_MULTIFIT_HAS_IMP_BASE = _IMP_multifit.IMP_MULTIFIT_HAS_IMP_BASE
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
_object_types.append("RadiusOfGyrationRestraint")


def _object_cast_to_RadiusOfGyrationRestraint(*args):
  """_object_cast_to_RadiusOfGyrationRestraint(Object o) -> RadiusOfGyrationRestraint"""
  return _IMP_multifit._object_cast_to_RadiusOfGyrationRestraint(*args)
_object_types.append("ComponentHeader")


def _object_cast_to_ComponentHeader(*args):
  """_object_cast_to_ComponentHeader(Object o) -> ComponentHeader"""
  return _IMP_multifit._object_cast_to_ComponentHeader(*args)
_object_types.append("AssemblyHeader")


def _object_cast_to_AssemblyHeader(*args):
  """_object_cast_to_AssemblyHeader(Object o) -> AssemblyHeader"""
  return _IMP_multifit._object_cast_to_AssemblyHeader(*args)
_object_types.append("SettingsData")


def _object_cast_to_SettingsData(*args):
  """_object_cast_to_SettingsData(Object o) -> SettingsData"""
  return _IMP_multifit._object_cast_to_SettingsData(*args)
_object_types.append("WeightedExcludedVolumeRestraint")


def _object_cast_to_WeightedExcludedVolumeRestraint(*args):
  """_object_cast_to_WeightedExcludedVolumeRestraint(Object o) -> WeightedExcludedVolumeRestraint"""
  return _IMP_multifit._object_cast_to_WeightedExcludedVolumeRestraint(*args)
_object_types.append("ComplementarityRestraint")


def _object_cast_to_ComplementarityRestraint(*args):
  """_object_cast_to_ComplementarityRestraint(Object o) -> ComplementarityRestraint"""
  return _IMP_multifit._object_cast_to_ComplementarityRestraint(*args)
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(*args):
  """_object_cast_to_ProteomicsData(Object o) -> ProteomicsData"""
  return _IMP_multifit._object_cast_to_ProteomicsData(*args)
_object_types.append("TransformationClustering")


def _object_cast_to_TransformationClustering(*args):
  """_object_cast_to_TransformationClustering(Object o) -> TransformationClustering"""
  return _IMP_multifit._object_cast_to_TransformationClustering(*args)
_object_types.append("FFTFitting")


def _object_cast_to_FFTFitting(*args):
  """_object_cast_to_FFTFitting(Object o) -> FFTFitting"""
  return _IMP_multifit._object_cast_to_FFTFitting(*args)
_object_types.append("FFTFittingOutput")


def _object_cast_to_FFTFittingOutput(*args):
  """_object_cast_to_FFTFittingOutput(Object o) -> FFTFittingOutput"""
  return _IMP_multifit._object_cast_to_FFTFittingOutput(*args)
_object_types.append("ProbabilisticAnchorGraph")


def _object_cast_to_ProbabilisticAnchorGraph(*args):
  """_object_cast_to_ProbabilisticAnchorGraph(Object o) -> ProbabilisticAnchorGraph"""
  return _IMP_multifit._object_cast_to_ProbabilisticAnchorGraph(*args)
_object_types.append("Ensemble")


def _object_cast_to_Ensemble(*args):
  """_object_cast_to_Ensemble(Object o) -> Ensemble"""
  return _IMP_multifit._object_cast_to_Ensemble(*args)
_object_types.append("ProteomicsEMAlignmentAtomic")


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

def add_surface_index(*args):
  """
    add_surface_index(Hierarchy mhd, IMP::Float apix, FloatKey shell_key=FloatKey("surf_ind"), FloatKey radius_key=IMP::core::XYZR::get_radius_key(), 
        FloatKey weight_key=IMP::atom::Mass::get_mass_key())
    add_surface_index(Hierarchy mhd, IMP::Float apix, FloatKey shell_key=FloatKey("surf_ind"), FloatKey radius_key=IMP::core::XYZR::get_radius_key())
    add_surface_index(Hierarchy mhd, IMP::Float apix, FloatKey shell_key=FloatKey("surf_ind"))
    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=FloatKey("surf_ind")) -> 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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FittingSolutionRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FittingSolutionRecord, name)
    def __init__(self): 
        """__init__(IMP::multifit::FittingSolutionRecord self) -> FittingSolutionRecord"""
        this = _IMP_multifit.new_FittingSolutionRecord()
        try: self.this.append(this)
        except: self.this = this
    def get_index(self):
        """get_index(FittingSolutionRecord self) -> unsigned int"""
        return _IMP_multifit.FittingSolutionRecord_get_index(self)

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

    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, *args):
        """set_solution_filename(FittingSolutionRecord self, std::string sol_fn)"""
        return _IMP_multifit.FittingSolutionRecord_set_solution_filename(self, *args)

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

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

    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, *args):
        """set_match_size(FittingSolutionRecord self, unsigned int match_size)"""
        return _IMP_multifit.FittingSolutionRecord_set_match_size(self, *args)

    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, *args):
        """set_match_average_distance(FittingSolutionRecord self, IMP::Float match_avg_dist)"""
        return _IMP_multifit.FittingSolutionRecord_set_match_average_distance(self, *args)

    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, *args):
        """set_fitting_score(FittingSolutionRecord self, IMP::Float fit_score)"""
        return _IMP_multifit.FittingSolutionRecord_set_fitting_score(self, *args)

    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, *args):
        """set_rmsd_to_reference(FittingSolutionRecord self, IMP::Float rmsd_to_ref)"""
        return _IMP_multifit.FittingSolutionRecord_set_rmsd_to_reference(self, *args)

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

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

    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, *args):
        """set_envelope_penetration_score(FittingSolutionRecord self, IMP::Float s)"""
        return _IMP_multifit.FittingSolutionRecord_set_envelope_penetration_score(self, *args)

    def show(self, *args):
        """
        show(FittingSolutionRecord self, _ostream out=std::cout)
        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()

    if _newclass:get_record_header = staticmethod(get_record_header)
    __swig_getmethods__["get_record_header"] = lambda x: 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=IMP::atom::Mass::get_mass_key(), 
        PrincipalComponentAnalysis3D dens_pca_input=IMP::algebra::PrincipalComponentAnalysis()) -> FittingSolutions
    pca_based_rigid_fitting(RigidBody rb, Refiner rb_refiner, DensityMap em_map, IMP::Float threshold, FloatKey wei_key=IMP::atom::Mass::get_mass_key()) -> FittingSolutions
    pca_based_rigid_fitting(RigidBody rb, Refiner rb_refiner, DensityMap em_map, IMP::Float threshold) -> FittingSolutions
    pca_based_rigid_fitting(IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::Float threshold, FloatKey wei_key=IMP::atom::Mass::get_mass_key(), 
        PrincipalComponentAnalysis3D dens_pca_input=IMP::algebra::PrincipalComponentAnalysis()) -> FittingSolutions
    pca_based_rigid_fitting(IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::Float threshold, FloatKey wei_key=IMP::atom::Mass::get_mass_key()) -> FittingSolutions
    pca_based_rigid_fitting(IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::Float threshold) -> FittingSolutions
    """
  return _IMP_multifit.pca_based_rigid_fitting(*args)

def write_markers(*args):
  """write_markers(PrincipalComponentAnalysis3D pca, _ostream out)"""
  return _IMP_multifit.write_markers(*args)
class ComponentHeader(IMP.base.Object):
    """Proxy of C++ IMP::multifit::ComponentHeader class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComponentHeader, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComponentHeader, name)
    def __init__(self): 
        """__init__(IMP::multifit::ComponentHeader self) -> ComponentHeader"""
        this = _IMP_multifit.new_ComponentHeader()
        try: self.this.append(this)
        except: self.this = this
    def set_name(self, *args):
        """set_name(ComponentHeader self, std::string const & name)"""
        return _IMP_multifit.ComponentHeader_set_name(self, *args)

    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, *args):
        """set_filename(ComponentHeader self, std::string const & filename)"""
        return _IMP_multifit.ComponentHeader_set_filename(self, *args)

    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, *args):
        """set_surface_fn(ComponentHeader self, std::string const & fn)"""
        return _IMP_multifit.ComponentHeader_set_surface_fn(self, *args)

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

    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, *args):
        """set_txt_fine_ap_fn(ComponentHeader self, std::string const & pdb_ap_fn)"""
        return _IMP_multifit.ComponentHeader_set_txt_fine_ap_fn(self, *args)

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

    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, *args):
        """set_num_fine_ap(ComponentHeader self, int num_ap)"""
        return _IMP_multifit.ComponentHeader_set_num_fine_ap(self, *args)

    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, *args):
        """set_transformations_fn(ComponentHeader self, std::string transformations_fn)"""
        return _IMP_multifit.ComponentHeader_set_transformations_fn(self, *args)

    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, *args):
        """set_reference_fn(ComponentHeader self, std::string const & ref_fn)"""
        return _IMP_multifit.ComponentHeader_set_reference_fn(self, *args)

    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)

    __swig_destroy__ = _IMP_multifit.delete_ComponentHeader
    __del__ = lambda self : None;
    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)

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

ComponentHeader_swigregister = _IMP_multifit.ComponentHeader_swigregister
ComponentHeader_swigregister(ComponentHeader)

class AssemblyHeader(IMP.base.Object):
    """Proxy of C++ IMP::multifit::AssemblyHeader class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AssemblyHeader, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AssemblyHeader, name)
    def __init__(self): 
        """__init__(IMP::multifit::AssemblyHeader self) -> AssemblyHeader"""
        this = _IMP_multifit.new_AssemblyHeader()
        try: self.this.append(this)
        except: self.this = this
    def set_dens_fn(self, *args):
        """set_dens_fn(AssemblyHeader self, std::string const & dens_fn)"""
        return _IMP_multifit.AssemblyHeader_set_dens_fn(self, *args)

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

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

    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, *args):
        """set_spacing(AssemblyHeader self, float spacing)"""
        return _IMP_multifit.AssemblyHeader_set_spacing(self, *args)

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

    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, *args):
        """set_origin(AssemblyHeader self, Vector3D origin)"""
        return _IMP_multifit.AssemblyHeader_set_origin(self, *args)

    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, *args):
        """set_coarse_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_coarse_ap_fn(self, *args)

    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, *args):
        """set_coarse_over_sampled_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_coarse_over_sampled_ap_fn(self, *args)

    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, *args):
        """set_fine_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_fine_ap_fn(self, *args)

    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, *args):
        """set_fine_over_sampled_ap_fn(AssemblyHeader self, std::string const & new_fn)"""
        return _IMP_multifit.AssemblyHeader_set_fine_over_sampled_ap_fn(self, *args)

    def get_version_info(self):
        """get_version_info(AssemblyHeader self) -> VersionInfo"""
        return _IMP_multifit.AssemblyHeader_get_version_info(self)

    __swig_destroy__ = _IMP_multifit.delete_AssemblyHeader
    __del__ = lambda self : None;
    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)

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

AssemblyHeader_swigregister = _IMP_multifit.AssemblyHeader_swigregister
AssemblyHeader_swigregister(AssemblyHeader)

class SettingsData(IMP.base.Object):
    """Proxy of C++ IMP::multifit::SettingsData class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SettingsData, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SettingsData, name)
    def __init__(self): 
        """__init__(IMP::multifit::SettingsData self) -> SettingsData"""
        this = _IMP_multifit.new_SettingsData()
        try: self.this.append(this)
        except: self.this = this
    def show_component_header_line(*args):
        """
        show_component_header_line(_ostream out=std::cout)
        show_component_header_line()
        """
        return _IMP_multifit.SettingsData_show_component_header_line(*args)

    if _newclass:show_component_header_line = staticmethod(show_component_header_line)
    __swig_getmethods__["show_component_header_line"] = lambda x: show_component_header_line
    def get_component_header_line():
        """get_component_header_line() -> std::string"""
        return _IMP_multifit.SettingsData_get_component_header_line()

    if _newclass:get_component_header_line = staticmethod(get_component_header_line)
    __swig_getmethods__["get_component_header_line"] = lambda x: get_component_header_line
    def show_density_header_line(*args):
        """
        show_density_header_line(_ostream out=std::cout)
        show_density_header_line()
        """
        return _IMP_multifit.SettingsData_show_density_header_line(*args)

    if _newclass:show_density_header_line = staticmethod(show_density_header_line)
    __swig_getmethods__["show_density_header_line"] = lambda x: show_density_header_line
    def get_density_header_line():
        """get_density_header_line() -> std::string"""
        return _IMP_multifit.SettingsData_get_density_header_line()

    if _newclass:get_density_header_line = staticmethod(get_density_header_line)
    __swig_getmethods__["get_density_header_line"] = lambda x: get_density_header_line
    def set_assembly_filename(self, *args):
        """set_assembly_filename(SettingsData self, std::string const & fn)"""
        return _IMP_multifit.SettingsData_set_assembly_filename(self, *args)

    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, *args):
        """set_assembly_header(SettingsData self, AssemblyHeader h)"""
        return _IMP_multifit.SettingsData_set_assembly_header(self, *args)

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

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

    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)

    __swig_destroy__ = _IMP_multifit.delete_SettingsData
    __del__ = lambda self : None;
    def remove_component_header(self, *args):
        """remove_component_header(SettingsData self, ComponentHeader d)"""
        return _IMP_multifit.SettingsData_remove_component_header(self, *args)

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

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

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

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

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

    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, *args):
        """get_component_header(SettingsData self, unsigned int i) -> ComponentHeader"""
        return _IMP_multifit.SettingsData_get_component_header(self, *args)

    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, *args):
        """reserve_component_headers(SettingsData self, unsigned int sz)"""
        return _IMP_multifit.SettingsData_reserve_component_headers(self, *args)

    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)

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

SettingsData_swigregister = _IMP_multifit.SettingsData_swigregister
SettingsData_swigregister(SettingsData)

def SettingsData_show_component_header_line(*args):
  """
    show_component_header_line(_ostream out=std::cout)
    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=std::cout)
    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(*args):
  """read_settings(char const * filename) -> SettingsData"""
  return _IMP_multifit.read_settings(*args)

def write_settings(*args):
  """write_settings(char const * filename, SettingsData sd)"""
  return _IMP_multifit.write_settings(*args)
class TransformationClustering(IMP.base.Object):
    """Proxy of C++ IMP::multifit::TransformationClustering class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransformationClustering, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TransformationClustering, name)
    def __init__(self, *args): 
        """__init__(IMP::multifit::TransformationClustering self, IMP::kernel::Particles ps, IMP::Float max_rmsd) -> TransformationClustering"""
        this = _IMP_multifit.new_TransformationClustering(*args)
        try: self.this.append(this)
        except: self.this = this
    def cluster_by_rotation(self, *args):
        """cluster_by_rotation(TransformationClustering self, IMP::algebra::Transformation3Ds const & trans, float max_angle_diff_in_rad, int min_cluster_size) -> IMP::IntsList"""
        return _IMP_multifit.TransformationClustering_cluster_by_rotation(self, *args)

    def cluster_by_transformation(self, *args):
        """
        cluster_by_transformation(TransformationClustering self, IMP::algebra::Transformation3Ds const & trans, float max_angle_diff, float max_translation_diff, 
            int min_cluster_size) -> IMP::IntsList
        """
        return _IMP_multifit.TransformationClustering_cluster_by_transformation(self, *args)

    def cluster_by_rmsd(self, *args):
        """
        cluster_by_rmsd(TransformationClustering self, IMP::algebra::Transformation3Ds const & trans, float max_rmsd_between_transformations, 
            int min_cluster_size) -> IMP::IntsList
        """
        return _IMP_multifit.TransformationClustering_cluster_by_rmsd(self, *args)

    def get_version_info(self):
        """get_version_info(TransformationClustering self) -> VersionInfo"""
        return _IMP_multifit.TransformationClustering_get_version_info(self)

    __swig_destroy__ = _IMP_multifit.delete_TransformationClustering
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TransformationClustering self) -> std::string"""
        return _IMP_multifit.TransformationClustering___str__(self)

    def __repr__(self):
        """__repr__(TransformationClustering self) -> std::string"""
        return _IMP_multifit.TransformationClustering___repr__(self)

    def get_from(o):
       return _object_cast_to_TransformationClustering(o)
    get_from = staticmethod(get_from)

TransformationClustering_swigregister = _IMP_multifit.TransformationClustering_swigregister
TransformationClustering_swigregister(TransformationClustering)


def get_clustered(*args):
  """
    get_clustered(IMP::kernel::Particles ps, IMP::algebra::Transformation3Ds const & trans, float max_rmsd, 
        float max_angle_diff_in_rad, float max_displace, int min_cluster_size) -> IMP::IntsList
    """
  return _IMP_multifit.get_clustered(*args)
class WeightedExcludedVolumeRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::multifit::WeightedExcludedVolumeRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WeightedExcludedVolumeRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WeightedExcludedVolumeRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::multifit::WeightedExcludedVolumeRestraint self, IMP::core::RigidBodies rbs, Refiner refiner, FloatKey weight_key=IMP::atom::Mass::get_mass_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: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(WeightedExcludedVolumeRestraint self) -> IMP::kernel::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)

    __swig_destroy__ = _IMP_multifit.delete_WeightedExcludedVolumeRestraint
    __del__ = lambda self : None;
    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)

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

WeightedExcludedVolumeRestraint_swigregister = _IMP_multifit.WeightedExcludedVolumeRestraint_swigregister
WeightedExcludedVolumeRestraint_swigregister(WeightedExcludedVolumeRestraint)

class FFTFittingOutput(IMP.base.Object):
    """Proxy of C++ IMP::multifit::FFTFittingOutput class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FFTFittingOutput, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FFTFittingOutput, name)
    def __init__(self): 
        """__init__(IMP::multifit::FFTFittingOutput self) -> FFTFittingOutput"""
        this = _IMP_multifit.new_FFTFittingOutput()
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(FFTFittingOutput self) -> VersionInfo"""
        return _IMP_multifit.FFTFittingOutput_get_version_info(self)

    __swig_destroy__ = _IMP_multifit.delete_FFTFittingOutput
    __del__ = lambda self : None;
    __swig_setmethods__["best_fits_"] = _IMP_multifit.FFTFittingOutput_best_fits__set
    __swig_getmethods__["best_fits_"] = _IMP_multifit.FFTFittingOutput_best_fits__get
    if _newclass:best_fits_ = _swig_property(_IMP_multifit.FFTFittingOutput_best_fits__get, _IMP_multifit.FFTFittingOutput_best_fits__set)
    __swig_setmethods__["best_trans_per_rot_"] = _IMP_multifit.FFTFittingOutput_best_trans_per_rot__set
    __swig_getmethods__["best_trans_per_rot_"] = _IMP_multifit.FFTFittingOutput_best_trans_per_rot__get
    if _newclass: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)

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

FFTFittingOutput_swigregister = _IMP_multifit.FFTFittingOutput_swigregister
FFTFittingOutput_swigregister(FFTFittingOutput)

class FFTFitting(IMP.base.Object):
    """Proxy of C++ IMP::multifit::FFTFitting class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FFTFitting, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FFTFitting, name)
    def get_version_info(self):
        """get_version_info(FFTFitting self) -> VersionInfo"""
        return _IMP_multifit.FFTFitting_get_version_info(self)

    __swig_destroy__ = _IMP_multifit.delete_FFTFitting
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(IMP::multifit::FFTFitting self) -> FFTFitting"""
        this = _IMP_multifit.new_FFTFitting()
        try: self.this.append(this)
        except: 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)

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

FFTFitting_swigregister = _IMP_multifit.FFTFitting_swigregister
FFTFitting_swigregister(FFTFitting)


def fft_based_rigid_fitting(*args):
  """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(*args)

def get_density_histogram(*args):
  """get_density_histogram(DensityMap dmap, float threshold, int num_bins) -> Histogram"""
  return _IMP_multifit.get_density_histogram(*args)

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

def get_connected_components(*args):
  """get_connected_components(DensityMap dmap, float threshold, float edge_threshold) -> IMP::IntsList"""
  return _IMP_multifit.get_connected_components(*args)
class ComplementarityRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::multifit::ComplementarityRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComplementarityRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComplementarityRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::multifit::ComplementarityRestraint self, IMP::kernel::ParticlesTemp const & a, IMP::kernel::ParticlesTemp const & b, std::string name="ComplementarityRestraint %1%") -> ComplementarityRestraint
        __init__(IMP::multifit::ComplementarityRestraint self, IMP::kernel::ParticlesTemp const & a, IMP::kernel::ParticlesTemp const & b) -> ComplementarityRestraint
        """
        this = _IMP_multifit.new_ComplementarityRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_maximum_penetration_score(self, *args):
        """set_maximum_penetration_score(ComplementarityRestraint self, double s)"""
        return _IMP_multifit.ComplementarityRestraint_set_maximum_penetration_score(self, *args)

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

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

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

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

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

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

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

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

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

    def get_input_particles(self):
        """get_input_particles(ComplementarityRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_multifit.ComplementarityRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(ComplementarityRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_multifit.ComplementarityRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(ComplementarityRestraint self) -> IMP::kernel::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 do_show(self, *args):
        """do_show(ComplementarityRestraint self, _ostream out)"""
        return _IMP_multifit.ComplementarityRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_multifit.delete_ComplementarityRestraint
    __del__ = lambda self : None;
    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)

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

ComplementarityRestraint_swigregister = _IMP_multifit.ComplementarityRestraint_swigregister
ComplementarityRestraint_swigregister(ComplementarityRestraint)


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

def write_fitting_solutions(*args):
  """
    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(*args)

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

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

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

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

def get_close_to_point(*args):
  """
    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(*args)
class ProbabilisticAnchorGraph(IMP.base.Object):
    """Proxy of C++ IMP::multifit::ProbabilisticAnchorGraph class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProbabilisticAnchorGraph, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProbabilisticAnchorGraph, name)
    def __init__(self, *args): 
        """__init__(IMP::multifit::ProbabilisticAnchorGraph self, IMP::algebra::Vector3Ds anchor_positions) -> ProbabilisticAnchorGraph"""
        this = _IMP_multifit.new_ProbabilisticAnchorGraph(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_edge(self, *args):
        """add_edge(ProbabilisticAnchorGraph self, int i, int j)"""
        return _IMP_multifit.ProbabilisticAnchorGraph_add_edge(self, *args)

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

    def show(self, *args):
        """
        show(ProbabilisticAnchorGraph self, _ostream out=std::cout)
        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, *args):
        """
        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, *args)

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

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

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

    __swig_destroy__ = _IMP_multifit.delete_ProbabilisticAnchorGraph
    __del__ = lambda self : None;
    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)

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

ProbabilisticAnchorGraph_swigregister = _IMP_multifit.ProbabilisticAnchorGraph_swigregister
ProbabilisticAnchorGraph_swigregister(ProbabilisticAnchorGraph)


def fitting_clustering(*args):
  """fitting_clustering(Hierarchy mh, FittingSolutions ts, float spacing, int top_sols, float rmsd) -> FittingSolutions"""
  return _IMP_multifit.fitting_clustering(*args)
class ProteinRecordData(_object):
    """Proxy of C++ IMP::multifit::ProteinRecordData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProteinRecordData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProteinRecordData, name)
    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: self.this = this
    def show(self, *args):
        """
        show(ProteinRecordData self, _ostream out=std::cout)
        show(ProteinRecordData self)
        """
        return _IMP_multifit.ProteinRecordData_show(self, *args)

    __swig_setmethods__["name_"] = _IMP_multifit.ProteinRecordData_name__set
    __swig_getmethods__["name_"] = _IMP_multifit.ProteinRecordData_name__get
    if _newclass:name_ = _swig_property(_IMP_multifit.ProteinRecordData_name__get, _IMP_multifit.ProteinRecordData_name__set)
    __swig_setmethods__["start_res_"] = _IMP_multifit.ProteinRecordData_start_res__set
    __swig_getmethods__["start_res_"] = _IMP_multifit.ProteinRecordData_start_res__get
    if _newclass:start_res_ = _swig_property(_IMP_multifit.ProteinRecordData_start_res__get, _IMP_multifit.ProteinRecordData_start_res__set)
    __swig_setmethods__["end_res_"] = _IMP_multifit.ProteinRecordData_end_res__set
    __swig_getmethods__["end_res_"] = _IMP_multifit.ProteinRecordData_end_res__get
    if _newclass:end_res_ = _swig_property(_IMP_multifit.ProteinRecordData_end_res__get, _IMP_multifit.ProteinRecordData_end_res__set)
    __swig_setmethods__["filename_"] = _IMP_multifit.ProteinRecordData_filename__set
    __swig_getmethods__["filename_"] = _IMP_multifit.ProteinRecordData_filename__get
    if _newclass:filename_ = _swig_property(_IMP_multifit.ProteinRecordData_filename__get, _IMP_multifit.ProteinRecordData_filename__set)
    __swig_setmethods__["surface_filename_"] = _IMP_multifit.ProteinRecordData_surface_filename__set
    __swig_getmethods__["surface_filename_"] = _IMP_multifit.ProteinRecordData_surface_filename__get
    if _newclass:surface_filename_ = _swig_property(_IMP_multifit.ProteinRecordData_surface_filename__get, _IMP_multifit.ProteinRecordData_surface_filename__set)
    __swig_setmethods__["ref_filename_"] = _IMP_multifit.ProteinRecordData_ref_filename__set
    __swig_getmethods__["ref_filename_"] = _IMP_multifit.ProteinRecordData_ref_filename__get
    if _newclass: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.base.Object):
    """Proxy of C++ IMP::multifit::ProteomicsData class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProteomicsData, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProteomicsData, name)
    def __init__(self): 
        """__init__(IMP::multifit::ProteomicsData self) -> ProteomicsData"""
        this = _IMP_multifit.new_ProteomicsData()
        try: self.this.append(this)
        except: 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, *args):
        """find(ProteomicsData self, std::string const & name) -> int"""
        return _IMP_multifit.ProteomicsData_find(self, *args)

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

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

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

    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, *args):
        """get_interaction(ProteomicsData self, int interaction_ind) -> IMP::Ints"""
        return _IMP_multifit.ProteomicsData_get_interaction(self, *args)

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

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

    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, *args):
        """get_cross_link(ProteomicsData self, int xlink_ind) -> std::pair< IMP::IntPair,IMP::IntPair >"""
        return _IMP_multifit.ProteomicsData_get_cross_link(self, *args)

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

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

    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, *args):
        """get_ev_pair(ProteomicsData self, int ev_ind) -> IMP::IntPair"""
        return _IMP_multifit.ProteomicsData_get_ev_pair(self, *args)

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

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

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

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

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

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

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

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

    __swig_destroy__ = _IMP_multifit.delete_ProteomicsData
    __del__ = lambda self : None;
    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, *args):
        """set_num_allowed_violated_interactions(ProteomicsData self, int n)"""
        return _IMP_multifit.ProteomicsData_set_num_allowed_violated_interactions(self, *args)

    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, *args):
        """set_num_allowed_violated_cross_links(ProteomicsData self, int n)"""
        return _IMP_multifit.ProteomicsData_set_num_allowed_violated_cross_links(self, *args)

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

    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)

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

ProteomicsData_swigregister = _IMP_multifit.ProteomicsData_swigregister
ProteomicsData_swigregister(ProteomicsData)


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

def get_partial_proteomics_data(*args):
  """get_partial_proteomics_data(ProteomicsData pd, IMP::Strings const & prot_names) -> ProteomicsData"""
  return _IMP_multifit.get_partial_proteomics_data(*args)
class AnchorsData(_object):
    """Proxy of C++ IMP::multifit::AnchorsData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnchorsData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AnchorsData, name)
    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: self.this = this
    def remove_edges_for_node(self, *args):
        """remove_edges_for_node(AnchorsData self, int node_ind)"""
        return _IMP_multifit.AnchorsData_remove_edges_for_node(self, *args)

    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, *args):
        """get_is_point_considered(AnchorsData self, int node_ind) -> bool"""
        return _IMP_multifit.AnchorsData_get_is_point_considered(self, *args)

    def show(self, *args):
        """
        show(AnchorsData self, _ostream out=std::cout)
        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, *args):
        """setup_secondary_structure(AnchorsData self, Model mdl)"""
        return _IMP_multifit.AnchorsData_setup_secondary_structure(self, *args)

    def set_secondary_structure_probabilities(self, *args):
        """
        set_secondary_structure_probabilities(AnchorsData self, IMP::kernel::Particles const & ssres_ps, IMP::Ints const & indices=IMP::Ints())
        set_secondary_structure_probabilities(AnchorsData self, IMP::kernel::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::kernel::Particles"""
        return _IMP_multifit.AnchorsData_get_secondary_structure_particles(self)

    __swig_setmethods__["points_"] = _IMP_multifit.AnchorsData_points__set
    __swig_getmethods__["points_"] = _IMP_multifit.AnchorsData_points__get
    if _newclass:points_ = _swig_property(_IMP_multifit.AnchorsData_points__get, _IMP_multifit.AnchorsData_points__set)
    __swig_setmethods__["consider_point_"] = _IMP_multifit.AnchorsData_consider_point__set
    __swig_getmethods__["consider_point_"] = _IMP_multifit.AnchorsData_consider_point__get
    if _newclass:consider_point_ = _swig_property(_IMP_multifit.AnchorsData_consider_point__get, _IMP_multifit.AnchorsData_consider_point__set)
    __swig_setmethods__["edges_"] = _IMP_multifit.AnchorsData_edges__set
    __swig_getmethods__["edges_"] = _IMP_multifit.AnchorsData_edges__get
    if _newclass: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(*args):
  """read_anchors_data(char const * txt_filename) -> AnchorsData"""
  return _IMP_multifit.read_anchors_data(*args)

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

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

def create_coarse_molecule_from_molecule(*args):
  """
    create_coarse_molecule_from_molecule(Hierarchy mh, int num_beads, Model mdl, float bead_radius, bool add_conn_restraint=False) -> Hierarchy
    create_coarse_molecule_from_molecule(Hierarchy mh, int num_beads, Model mdl, float bead_radius) -> Hierarchy
    """
  return _IMP_multifit.create_coarse_molecule_from_molecule(*args)

def create_coarse_molecules_from_molecules(*args):
  """
    create_coarse_molecules_from_molecules(IMP::atom::Hierarchies const & mhs, int frag_len, Model mdl, float bead_radius, bool add_conn_restraint=False) -> IMP::atom::Hierarchies
    create_coarse_molecules_from_molecules(IMP::atom::Hierarchies const & mhs, int frag_len, Model mdl, float bead_radius) -> IMP::atom::Hierarchies
    """
  return _IMP_multifit.create_coarse_molecules_from_molecules(*args)

def create_coarse_molecule_from_density(*args):
  """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(*args)

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

def get_points_close_to_molecule(*args):
  """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(*args)

def get_points_far_from_molecule(*args):
  """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(*args)
class RadiusOfGyrationRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::multifit::RadiusOfGyrationRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RadiusOfGyrationRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RadiusOfGyrationRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::multifit::RadiusOfGyrationRestraint self, IMP::kernel::Particles ps, int num_residues, IMP::Float scale=1.) -> RadiusOfGyrationRestraint
        __init__(IMP::multifit::RadiusOfGyrationRestraint self, IMP::kernel::Particles ps, int num_residues) -> RadiusOfGyrationRestraint
        """
        this = _IMP_multifit.new_RadiusOfGyrationRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self):
        """get_input_particles(RadiusOfGyrationRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_multifit.RadiusOfGyrationRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(RadiusOfGyrationRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_multifit.RadiusOfGyrationRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(RadiusOfGyrationRestraint self) -> IMP::kernel::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 do_show(self, *args):
        """do_show(RadiusOfGyrationRestraint self, _ostream out)"""
        return _IMP_multifit.RadiusOfGyrationRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_multifit.delete_RadiusOfGyrationRestraint
    __del__ = lambda self : None;
    def set_radius_of_gyration(self, *args):
        """set_radius_of_gyration(RadiusOfGyrationRestraint self, IMP::Float r)"""
        return _IMP_multifit.RadiusOfGyrationRestraint_set_radius_of_gyration(self, *args)

    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)

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

RadiusOfGyrationRestraint_swigregister = _IMP_multifit.RadiusOfGyrationRestraint_swigregister
RadiusOfGyrationRestraint_swigregister(RadiusOfGyrationRestraint)


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

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

def get_approximated_radius(*args):
  """get_approximated_radius(int len) -> float"""
  return _IMP_multifit.get_approximated_radius(*args)
class ProteinsAnchorsSamplingSpace(_object):
    """Proxy of C++ IMP::multifit::ProteinsAnchorsSamplingSpace class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProteinsAnchorsSamplingSpace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProteinsAnchorsSamplingSpace, name)
    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: self.this = this
    def set_anchors(self, *args):
        """set_anchors(ProteinsAnchorsSamplingSpace self, AnchorsData data)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_set_anchors(self, *args)

    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, *args):
        """set_anchors_filename(ProteinsAnchorsSamplingSpace self, std::string const & fn)"""
        return _IMP_multifit.ProteinsAnchorsSamplingSpace_set_anchors_filename(self, *args)

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

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

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

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

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

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

    def show(self, *args):
        """
        show(ProteinsAnchorsSamplingSpace self, _ostream s=std::cout)
        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=INT_MAX) -> 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(*args):
  """get_part_of_sampling_space(ProteinsAnchorsSamplingSpace prots_ss, IMP::Strings const & prot_names) -> ProteinsAnchorsSamplingSpace"""
  return _IMP_multifit.get_part_of_sampling_space(*args)

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

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

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

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

def get_anchors_for_density(*args):
  """
    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(*args)

def get_anchor_indices_matching_secondary_structure(*args):
  """
    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(*args)
class DominoParams(_object):
    """Proxy of C++ IMP::multifit::DominoParams class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DominoParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DominoParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::DominoParams self) -> DominoParams"""
        this = _IMP_multifit.new_DominoParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(DominoParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.DominoParams_add(self, *args)

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

    __swig_setmethods__["max_value_threshold_"] = _IMP_multifit.DominoParams_max_value_threshold__set
    __swig_getmethods__["max_value_threshold_"] = _IMP_multifit.DominoParams_max_value_threshold__get
    if _newclass:max_value_threshold_ = _swig_property(_IMP_multifit.DominoParams_max_value_threshold__get, _IMP_multifit.DominoParams_max_value_threshold__set)
    __swig_setmethods__["max_num_states_for_subset_"] = _IMP_multifit.DominoParams_max_num_states_for_subset__set
    __swig_getmethods__["max_num_states_for_subset_"] = _IMP_multifit.DominoParams_max_num_states_for_subset__get
    if _newclass: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)
    __swig_setmethods__["max_anchor_penetration_"] = _IMP_multifit.DominoParams_max_anchor_penetration__set
    __swig_getmethods__["max_anchor_penetration_"] = _IMP_multifit.DominoParams_max_anchor_penetration__get
    if _newclass:max_anchor_penetration_ = _swig_property(_IMP_multifit.DominoParams_max_anchor_penetration__get, _IMP_multifit.DominoParams_max_anchor_penetration__set)
    __swig_setmethods__["heap_size_"] = _IMP_multifit.DominoParams_heap_size__set
    __swig_getmethods__["heap_size_"] = _IMP_multifit.DominoParams_heap_size__get
    if _newclass:heap_size_ = _swig_property(_IMP_multifit.DominoParams_heap_size__get, _IMP_multifit.DominoParams_heap_size__set)
    __swig_setmethods__["cache_size_"] = _IMP_multifit.DominoParams_cache_size__set
    __swig_getmethods__["cache_size_"] = _IMP_multifit.DominoParams_cache_size__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XlinkParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XlinkParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::XlinkParams self) -> XlinkParams"""
        this = _IMP_multifit.new_XlinkParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(XlinkParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.XlinkParams_add(self, *args)

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

    __swig_setmethods__["upper_bound_"] = _IMP_multifit.XlinkParams_upper_bound__set
    __swig_getmethods__["upper_bound_"] = _IMP_multifit.XlinkParams_upper_bound__get
    if _newclass:upper_bound_ = _swig_property(_IMP_multifit.XlinkParams_upper_bound__get, _IMP_multifit.XlinkParams_upper_bound__set)
    __swig_setmethods__["k_"] = _IMP_multifit.XlinkParams_k__set
    __swig_getmethods__["k_"] = _IMP_multifit.XlinkParams_k__get
    if _newclass:k_ = _swig_property(_IMP_multifit.XlinkParams_k__get, _IMP_multifit.XlinkParams_k__set)
    __swig_setmethods__["max_xlink_val_"] = _IMP_multifit.XlinkParams_max_xlink_val__set
    __swig_getmethods__["max_xlink_val_"] = _IMP_multifit.XlinkParams_max_xlink_val__get
    if _newclass:max_xlink_val_ = _swig_property(_IMP_multifit.XlinkParams_max_xlink_val__get, _IMP_multifit.XlinkParams_max_xlink_val__set)
    __swig_setmethods__["treat_between_residues_"] = _IMP_multifit.XlinkParams_treat_between_residues__set
    __swig_getmethods__["treat_between_residues_"] = _IMP_multifit.XlinkParams_treat_between_residues__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConnectivityParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConnectivityParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::ConnectivityParams self) -> ConnectivityParams"""
        this = _IMP_multifit.new_ConnectivityParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(ConnectivityParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.ConnectivityParams_add(self, *args)

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

    __swig_setmethods__["upper_bound_"] = _IMP_multifit.ConnectivityParams_upper_bound__set
    __swig_getmethods__["upper_bound_"] = _IMP_multifit.ConnectivityParams_upper_bound__get
    if _newclass:upper_bound_ = _swig_property(_IMP_multifit.ConnectivityParams_upper_bound__get, _IMP_multifit.ConnectivityParams_upper_bound__set)
    __swig_setmethods__["k_"] = _IMP_multifit.ConnectivityParams_k__set
    __swig_getmethods__["k_"] = _IMP_multifit.ConnectivityParams_k__get
    if _newclass:k_ = _swig_property(_IMP_multifit.ConnectivityParams_k__get, _IMP_multifit.ConnectivityParams_k__set)
    __swig_setmethods__["max_conn_rest_val_"] = _IMP_multifit.ConnectivityParams_max_conn_rest_val__set
    __swig_getmethods__["max_conn_rest_val_"] = _IMP_multifit.ConnectivityParams_max_conn_rest_val__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FragmentsParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FragmentsParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::FragmentsParams self) -> FragmentsParams"""
        this = _IMP_multifit.new_FragmentsParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(FragmentsParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.FragmentsParams_add(self, *args)

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

    __swig_setmethods__["frag_len_"] = _IMP_multifit.FragmentsParams_frag_len__set
    __swig_getmethods__["frag_len_"] = _IMP_multifit.FragmentsParams_frag_len__get
    if _newclass:frag_len_ = _swig_property(_IMP_multifit.FragmentsParams_frag_len__get, _IMP_multifit.FragmentsParams_frag_len__set)
    __swig_setmethods__["bead_radius_scale_"] = _IMP_multifit.FragmentsParams_bead_radius_scale__set
    __swig_getmethods__["bead_radius_scale_"] = _IMP_multifit.FragmentsParams_bead_radius_scale__get
    if _newclass:bead_radius_scale_ = _swig_property(_IMP_multifit.FragmentsParams_bead_radius_scale__get, _IMP_multifit.FragmentsParams_bead_radius_scale__set)
    __swig_setmethods__["load_atomic_"] = _IMP_multifit.FragmentsParams_load_atomic__set
    __swig_getmethods__["load_atomic_"] = _IMP_multifit.FragmentsParams_load_atomic__get
    if _newclass:load_atomic_ = _swig_property(_IMP_multifit.FragmentsParams_load_atomic__get, _IMP_multifit.FragmentsParams_load_atomic__set)
    __swig_setmethods__["subunit_rigid_"] = _IMP_multifit.FragmentsParams_subunit_rigid__set
    __swig_getmethods__["subunit_rigid_"] = _IMP_multifit.FragmentsParams_subunit_rigid__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RogParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RogParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::RogParams self) -> RogParams"""
        this = _IMP_multifit.new_RogParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(RogParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.RogParams_add(self, *args)

    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=std::cout)
        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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EVParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EVParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::EVParams self) -> EVParams"""
        this = _IMP_multifit.new_EVParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(EVParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.EVParams_add(self, *args)

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

    __swig_setmethods__["pair_distance_"] = _IMP_multifit.EVParams_pair_distance__set
    __swig_getmethods__["pair_distance_"] = _IMP_multifit.EVParams_pair_distance__get
    if _newclass:pair_distance_ = _swig_property(_IMP_multifit.EVParams_pair_distance__get, _IMP_multifit.EVParams_pair_distance__set)
    __swig_setmethods__["pair_slack_"] = _IMP_multifit.EVParams_pair_slack__set
    __swig_getmethods__["pair_slack_"] = _IMP_multifit.EVParams_pair_slack__get
    if _newclass:pair_slack_ = _swig_property(_IMP_multifit.EVParams_pair_slack__get, _IMP_multifit.EVParams_pair_slack__set)
    __swig_setmethods__["hlb_mean_"] = _IMP_multifit.EVParams_hlb_mean__set
    __swig_getmethods__["hlb_mean_"] = _IMP_multifit.EVParams_hlb_mean__get
    if _newclass:hlb_mean_ = _swig_property(_IMP_multifit.EVParams_hlb_mean__get, _IMP_multifit.EVParams_hlb_mean__set)
    __swig_setmethods__["hlb_k_"] = _IMP_multifit.EVParams_hlb_k__set
    __swig_getmethods__["hlb_k_"] = _IMP_multifit.EVParams_hlb_k__get
    if _newclass:hlb_k_ = _swig_property(_IMP_multifit.EVParams_hlb_k__get, _IMP_multifit.EVParams_hlb_k__set)
    __swig_setmethods__["maximum_ev_score_for_pair_"] = _IMP_multifit.EVParams_maximum_ev_score_for_pair__set
    __swig_getmethods__["maximum_ev_score_for_pair_"] = _IMP_multifit.EVParams_maximum_ev_score_for_pair__get
    if _newclass: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)
    __swig_setmethods__["allowed_percentage_of_bad_pairs_"] = _IMP_multifit.EVParams_allowed_percentage_of_bad_pairs__set
    __swig_getmethods__["allowed_percentage_of_bad_pairs_"] = _IMP_multifit.EVParams_allowed_percentage_of_bad_pairs__get
    if _newclass: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)
    __swig_setmethods__["scoring_mode_"] = _IMP_multifit.EVParams_scoring_mode__set
    __swig_getmethods__["scoring_mode_"] = _IMP_multifit.EVParams_scoring_mode__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FiltersParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FiltersParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::FiltersParams self) -> FiltersParams"""
        this = _IMP_multifit.new_FiltersParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(FiltersParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.FiltersParams_add(self, *args)

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

    __swig_setmethods__["max_num_violated_xlink_"] = _IMP_multifit.FiltersParams_max_num_violated_xlink__set
    __swig_getmethods__["max_num_violated_xlink_"] = _IMP_multifit.FiltersParams_max_num_violated_xlink__get
    if _newclass:max_num_violated_xlink_ = _swig_property(_IMP_multifit.FiltersParams_max_num_violated_xlink__get, _IMP_multifit.FiltersParams_max_num_violated_xlink__set)
    __swig_setmethods__["max_num_violated_conn_"] = _IMP_multifit.FiltersParams_max_num_violated_conn__set
    __swig_getmethods__["max_num_violated_conn_"] = _IMP_multifit.FiltersParams_max_num_violated_conn__get
    if _newclass:max_num_violated_conn_ = _swig_property(_IMP_multifit.FiltersParams_max_num_violated_conn__get, _IMP_multifit.FiltersParams_max_num_violated_conn__set)
    __swig_setmethods__["max_num_violated_ev_"] = _IMP_multifit.FiltersParams_max_num_violated_ev__set
    __swig_getmethods__["max_num_violated_ev_"] = _IMP_multifit.FiltersParams_max_num_violated_ev__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FittingParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FittingParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::FittingParams self) -> FittingParams"""
        this = _IMP_multifit.new_FittingParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(FittingParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.FittingParams_add(self, *args)

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

    __swig_setmethods__["pca_max_angle_diff_"] = _IMP_multifit.FittingParams_pca_max_angle_diff__set
    __swig_getmethods__["pca_max_angle_diff_"] = _IMP_multifit.FittingParams_pca_max_angle_diff__get
    if _newclass:pca_max_angle_diff_ = _swig_property(_IMP_multifit.FittingParams_pca_max_angle_diff__get, _IMP_multifit.FittingParams_pca_max_angle_diff__set)
    __swig_setmethods__["pca_max_size_diff_"] = _IMP_multifit.FittingParams_pca_max_size_diff__set
    __swig_getmethods__["pca_max_size_diff_"] = _IMP_multifit.FittingParams_pca_max_size_diff__get
    if _newclass:pca_max_size_diff_ = _swig_property(_IMP_multifit.FittingParams_pca_max_size_diff__get, _IMP_multifit.FittingParams_pca_max_size_diff__set)
    __swig_setmethods__["pca_max_cent_dist_diff_"] = _IMP_multifit.FittingParams_pca_max_cent_dist_diff__set
    __swig_getmethods__["pca_max_cent_dist_diff_"] = _IMP_multifit.FittingParams_pca_max_cent_dist_diff__get
    if _newclass: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)
    __swig_setmethods__["max_asmb_fit_score_"] = _IMP_multifit.FittingParams_max_asmb_fit_score__set
    __swig_getmethods__["max_asmb_fit_score_"] = _IMP_multifit.FittingParams_max_asmb_fit_score__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComplementarityParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ComplementarityParams, name)
    def __init__(self): 
        """__init__(IMP::multifit::ComplementarityParams self) -> ComplementarityParams"""
        this = _IMP_multifit.new_ComplementarityParams()
        try: self.this.append(this)
        except: self.this = this
    def add(self, *args):
        """add(ComplementarityParams self, boost::property_tree::ptree const & pt)"""
        return _IMP_multifit.ComplementarityParams_add(self, *args)

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

    __swig_setmethods__["max_score_"] = _IMP_multifit.ComplementarityParams_max_score__set
    __swig_getmethods__["max_score_"] = _IMP_multifit.ComplementarityParams_max_score__get
    if _newclass:max_score_ = _swig_property(_IMP_multifit.ComplementarityParams_max_score__get, _IMP_multifit.ComplementarityParams_max_score__set)
    __swig_setmethods__["max_penetration_"] = _IMP_multifit.ComplementarityParams_max_penetration__set
    __swig_getmethods__["max_penetration_"] = _IMP_multifit.ComplementarityParams_max_penetration__get
    if _newclass:max_penetration_ = _swig_property(_IMP_multifit.ComplementarityParams_max_penetration__get, _IMP_multifit.ComplementarityParams_max_penetration__set)
    __swig_setmethods__["interior_layer_thickness_"] = _IMP_multifit.ComplementarityParams_interior_layer_thickness__set
    __swig_getmethods__["interior_layer_thickness_"] = _IMP_multifit.ComplementarityParams_interior_layer_thickness__get
    if _newclass:interior_layer_thickness_ = _swig_property(_IMP_multifit.ComplementarityParams_interior_layer_thickness__get, _IMP_multifit.ComplementarityParams_interior_layer_thickness__set)
    __swig_setmethods__["boundary_coef_"] = _IMP_multifit.ComplementarityParams_boundary_coef__set
    __swig_getmethods__["boundary_coef_"] = _IMP_multifit.ComplementarityParams_boundary_coef__get
    if _newclass:boundary_coef_ = _swig_property(_IMP_multifit.ComplementarityParams_boundary_coef__get, _IMP_multifit.ComplementarityParams_boundary_coef__set)
    __swig_setmethods__["comp_coef_"] = _IMP_multifit.ComplementarityParams_comp_coef__set
    __swig_getmethods__["comp_coef_"] = _IMP_multifit.ComplementarityParams_comp_coef__get
    if _newclass:comp_coef_ = _swig_property(_IMP_multifit.ComplementarityParams_comp_coef__get, _IMP_multifit.ComplementarityParams_comp_coef__set)
    __swig_setmethods__["penetration_coef_"] = _IMP_multifit.ComplementarityParams_penetration_coef__set
    __swig_getmethods__["penetration_coef_"] = _IMP_multifit.ComplementarityParams_penetration_coef__get
    if _newclass: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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AlignmentParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AlignmentParams, name)
    def __init__(self, *args): 
        """__init__(IMP::multifit::AlignmentParams self, char const * param_filename) -> AlignmentParams"""
        this = _IMP_multifit.new_AlignmentParams(*args)
        try: self.this.append(this)
        except: 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=std::cout)
        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.base.Object):
    """Proxy of C++ IMP::multifit::ProteomicsEMAlignmentAtomic class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProteomicsEMAlignmentAtomic, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProteomicsEMAlignmentAtomic, name)
    def __init__(self, *args): 
        """__init__(IMP::multifit::ProteomicsEMAlignmentAtomic self, ProteinsAnchorsSamplingSpace mapping_data, SettingsData asmb_data, AlignmentParams align_param) -> ProteomicsEMAlignmentAtomic"""
        this = _IMP_multifit.new_ProteomicsEMAlignmentAtomic(*args)
        try: self.this.append(this)
        except: 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 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, *args):
        """set_density_map(ProteomicsEMAlignmentAtomic self, DensityMap dmap, float threshold)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_set_density_map(self, *args)

    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, *args):
        """load_combination_of_states(ProteomicsEMAlignmentAtomic self, IMP::Ints const & state4particles)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_load_combination_of_states(self, *args)

    def show_scores_header(self, *args):
        """
        show_scores_header(ProteomicsEMAlignmentAtomic self, _ostream ous=std::cout)
        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, *args):
        """set_fast_scoring(ProteomicsEMAlignmentAtomic self, bool state)"""
        return _IMP_multifit.ProteomicsEMAlignmentAtomic_set_fast_scoring(self, *args)

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

    __swig_destroy__ = _IMP_multifit.delete_ProteomicsEMAlignmentAtomic
    __del__ = lambda self : None;
    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)

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

ProteomicsEMAlignmentAtomic_swigregister = _IMP_multifit.ProteomicsEMAlignmentAtomic_swigregister
ProteomicsEMAlignmentAtomic_swigregister(ProteomicsEMAlignmentAtomic)


def write_connolly_surface(*args):
  """write_connolly_surface(IMP::atom::Atoms as, TextOutput fn, float density, float probe_radius)"""
  return _IMP_multifit.write_connolly_surface(*args)
class Ensemble(IMP.base.Object):
    """Proxy of C++ IMP::multifit::Ensemble class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ensemble, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Ensemble, name)
    def load_combination(self, *args):
        """load_combination(Ensemble self, IMP::Ints fit_comb)"""
        return _IMP_multifit.Ensemble_load_combination(self, *args)

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

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

    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, *args):
        """get_rmsd(Ensemble self, IMP::core::XYZs const & second_xyz) -> float"""
        return _IMP_multifit.Ensemble_get_rmsd(self, *args)

    def __init__(self, *args): 
        """__init__(IMP::multifit::Ensemble self, SettingsData sd, ProteinsAnchorsSamplingSpace mapping_data) -> Ensemble"""
        this = _IMP_multifit.new_Ensemble(*args)
        try: self.this.append(this)
        except: self.this = this
    def score_by_restraints(self, *args):
        """score_by_restraints(Ensemble self, IMP::kernel::Restraints rs, IMP::IntsList const & combinations) -> std::vector< IMP::Floats,std::allocator< IMP::Floats > >"""
        return _IMP_multifit.Ensemble_score_by_restraints(self, *args)

    def get_version_info(self):
        """get_version_info(Ensemble self) -> VersionInfo"""
        return _IMP_multifit.Ensemble_get_version_info(self)

    __swig_destroy__ = _IMP_multifit.delete_Ensemble
    __del__ = lambda self : None;
    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)

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

Ensemble_swigregister = _IMP_multifit.Ensemble_swigregister
Ensemble_swigregister(Ensemble)


def load_ensemble(*args):
  """load_ensemble(SettingsData sd, Model mdl, ProteinsAnchorsSamplingSpace mapping_data) -> Ensemble"""
  return _IMP_multifit.load_ensemble(*args)
_all_commands = ["param", "anchors", "fit_fft", "cluster", "add_fit_rmsd",
                 "indexes", "proteomics", "align", "models", "transforms",
                 "score", "merge_tree", "reference", "refine_fft"]


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

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

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_multifit.get_data_path(*args)
import _version_check
_version_check.check_version(get_module_version())

# This file is compatible with both classic and new-style classes.