isd/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.2
#
# 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_isd', [dirname(__file__)])
        except ImportError:
            import _IMP_isd
            return _IMP_isd
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_isd', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_isd = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_isd
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_ISD_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_ISD_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_ISD_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_ISD_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_isd.delete_IMP_ISD_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_ISD_SwigPyIterator self) -> PyObject *"""
        return _IMP_isd.IMP_ISD_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_ISD_SwigPyIterator self, size_t n=1) -> IMP_ISD_SwigPyIterator
        incr(IMP_ISD_SwigPyIterator self) -> IMP_ISD_SwigPyIterator
        """
        return _IMP_isd.IMP_ISD_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_ISD_SwigPyIterator self, size_t n=1) -> IMP_ISD_SwigPyIterator
        decr(IMP_ISD_SwigPyIterator self) -> IMP_ISD_SwigPyIterator
        """
        return _IMP_isd.IMP_ISD_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_ISD_SwigPyIterator self, IMP_ISD_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_isd.IMP_ISD_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_ISD_SwigPyIterator self, IMP_ISD_SwigPyIterator x) -> bool"""
        return _IMP_isd.IMP_ISD_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_ISD_SwigPyIterator self) -> IMP_ISD_SwigPyIterator"""
        return _IMP_isd.IMP_ISD_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_ISD_SwigPyIterator self) -> PyObject *"""
        return _IMP_isd.IMP_ISD_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_ISD_SwigPyIterator self) -> PyObject *"""
        return _IMP_isd.IMP_ISD_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_ISD_SwigPyIterator self) -> PyObject *"""
        return _IMP_isd.IMP_ISD_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_ISD_SwigPyIterator self, ptrdiff_t n) -> IMP_ISD_SwigPyIterator"""
        return _IMP_isd.IMP_ISD_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_ISD_SwigPyIterator self, IMP_ISD_SwigPyIterator x) -> bool"""
        return _IMP_isd.IMP_ISD_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_ISD_SwigPyIterator self, IMP_ISD_SwigPyIterator x) -> bool"""
        return _IMP_isd.IMP_ISD_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_ISD_SwigPyIterator self, ptrdiff_t n) -> IMP_ISD_SwigPyIterator"""
        return _IMP_isd.IMP_ISD_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_ISD_SwigPyIterator self, ptrdiff_t n) -> IMP_ISD_SwigPyIterator"""
        return _IMP_isd.IMP_ISD_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_ISD_SwigPyIterator self, ptrdiff_t n) -> IMP_ISD_SwigPyIterator"""
        return _IMP_isd.IMP_ISD_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_ISD_SwigPyIterator self, ptrdiff_t n) -> IMP_ISD_SwigPyIterator
        __sub__(IMP_ISD_SwigPyIterator self, IMP_ISD_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_isd.IMP_ISD_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_ISD_SwigPyIterator_swigregister = _IMP_isd.IMP_ISD_SwigPyIterator_swigregister
IMP_ISD_SwigPyIterator_swigregister(IMP_ISD_SwigPyIterator)

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

IMP_DEBUG = _IMP_isd.IMP_DEBUG
IMP_RELEASE = _IMP_isd.IMP_RELEASE
IMP_SILENT = _IMP_isd.IMP_SILENT
IMP_PROGRESS = _IMP_isd.IMP_PROGRESS
IMP_TERSE = _IMP_isd.IMP_TERSE
IMP_VERBOSE = _IMP_isd.IMP_VERBOSE
IMP_MEMORY = _IMP_isd.IMP_MEMORY
IMP_NONE = _IMP_isd.IMP_NONE
IMP_USAGE = _IMP_isd.IMP_USAGE
IMP_INTERNAL = _IMP_isd.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_isd.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_isd.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_isd.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_isd.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_isd.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_isd.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_isd.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_isd.IMPBASE_SHOW_WARNINGS
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        
        
        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_isd.DEFAULT_CHECK
NONE = _IMP_isd.NONE
USAGE = _IMP_isd.USAGE
USAGE_AND_INTERNAL = _IMP_isd.USAGE_AND_INTERNAL

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

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_isd.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_isd._ostream_write(self, *args)

_ostream_swigregister = _IMP_isd._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_isd.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_isd.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_isd.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_isd.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_isd.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_isd.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_isd.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_isd.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_isd.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_isd.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_isd.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_isd.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_isd.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_isd.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_isd.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_isd.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_isd.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_isd.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_isd.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_isd.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_isd.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_isd.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_isd.IMPDISPLAY_SHOW_WARNINGS
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_isd.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_isd.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_isd.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_isd.IMP_SCORE_FUNCTOR_HAS_CGAL
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_isd.IMP_SCORE_FUNCTOR_HAS_HDF5
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_isd.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor
IMP_STATISTICS_HAS_IMP_BASE = _IMP_isd.IMP_STATISTICS_HAS_IMP_BASE
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_isd.IMP_STATISTICS_HAS_IMP_CGAL
IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_isd.IMP_STATISTICS_HAS_BOOST_RANDOM
IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_isd.IMP_STATISTICS_HAS_BOOST_SYSTEM
IMP_STATISTICS_HAS_CGAL = _IMP_isd.IMP_STATISTICS_HAS_CGAL
IMPSTATISTICS_SHOW_WARNINGS = _IMP_isd.IMPSTATISTICS_SHOW_WARNINGS
import IMP.statistics
IMP_CORE_HAS_IMP_BASE = _IMP_isd.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_isd.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_isd.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_isd.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_isd.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_isd.IMP_CORE_HAS_CGAL
IMP_CORE_HAS_HDF5 = _IMP_isd.IMP_CORE_HAS_HDF5
IMPCORE_SHOW_WARNINGS = _IMP_isd.IMPCORE_SHOW_WARNINGS
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_isd.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_isd.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_isd.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_isd.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_isd.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_isd.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_isd.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_isd.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_isd.IMP_CONTAINER_HAS_CGAL
IMP_CONTAINER_HAS_HDF5 = _IMP_isd.IMP_CONTAINER_HAS_HDF5
IMPCONTAINER_SHOW_WARNINGS = _IMP_isd.IMPCONTAINER_SHOW_WARNINGS
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_isd.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_isd.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_isd.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_isd.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_isd.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_isd.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_isd.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_isd.IMP_ATOM_HAS_CGAL
IMP_ATOM_HAS_HDF5 = _IMP_isd.IMP_ATOM_HAS_HDF5
IMPATOM_SHOW_WARNINGS = _IMP_isd.IMPATOM_SHOW_WARNINGS
IMP_ATOM_TYPE_INDEX = _IMP_isd.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_isd.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_isd.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_isd.IMP_EM_HAS_IMP_CGAL
IMP_EM_HAS_IMP_CONTAINER = _IMP_isd.IMP_EM_HAS_IMP_CONTAINER
IMP_EM_HAS_IMP_DISPLAY = _IMP_isd.IMP_EM_HAS_IMP_DISPLAY
IMP_EM_HAS_IMP_KERNEL = _IMP_isd.IMP_EM_HAS_IMP_KERNEL
IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_isd.IMP_EM_HAS_IMP_SCORE_FUNCTOR
IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_EM_HAS_BOOST_FILESYSTEM
IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_EM_HAS_BOOST_PROGRAMOPTIONS
IMP_EM_HAS_BOOST_RANDOM = _IMP_isd.IMP_EM_HAS_BOOST_RANDOM
IMP_EM_HAS_BOOST_REGEX = _IMP_isd.IMP_EM_HAS_BOOST_REGEX
IMP_EM_HAS_BOOST_SYSTEM = _IMP_isd.IMP_EM_HAS_BOOST_SYSTEM
IMP_EM_HAS_CGAL = _IMP_isd.IMP_EM_HAS_CGAL
IMP_EM_HAS_HDF5 = _IMP_isd.IMP_EM_HAS_HDF5
IMPEM_SHOW_WARNINGS = _IMP_isd.IMPEM_SHOW_WARNINGS
import IMP.em
IMP_SAXS_HAS_IMP_BASE = _IMP_isd.IMP_SAXS_HAS_IMP_BASE
IMP_SAXS_HAS_IMP_CGAL = _IMP_isd.IMP_SAXS_HAS_IMP_CGAL
IMP_SAXS_HAS_IMP_CONTAINER = _IMP_isd.IMP_SAXS_HAS_IMP_CONTAINER
IMP_SAXS_HAS_IMP_DISPLAY = _IMP_isd.IMP_SAXS_HAS_IMP_DISPLAY
IMP_SAXS_HAS_IMP_KERNEL = _IMP_isd.IMP_SAXS_HAS_IMP_KERNEL
IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_isd.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR
IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_SAXS_HAS_BOOST_FILESYSTEM
IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS
IMP_SAXS_HAS_BOOST_RANDOM = _IMP_isd.IMP_SAXS_HAS_BOOST_RANDOM
IMP_SAXS_HAS_BOOST_REGEX = _IMP_isd.IMP_SAXS_HAS_BOOST_REGEX
IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_isd.IMP_SAXS_HAS_BOOST_SYSTEM
IMP_SAXS_HAS_CGAL = _IMP_isd.IMP_SAXS_HAS_CGAL
IMP_SAXS_HAS_HDF5 = _IMP_isd.IMP_SAXS_HAS_HDF5
IMPSAXS_SHOW_WARNINGS = _IMP_isd.IMPSAXS_SHOW_WARNINGS
import IMP.saxs
IMP_ISD_HAS_IMP_BASE = _IMP_isd.IMP_ISD_HAS_IMP_BASE
IMP_ISD_HAS_IMP_CGAL = _IMP_isd.IMP_ISD_HAS_IMP_CGAL
IMP_ISD_HAS_IMP_DISPLAY = _IMP_isd.IMP_ISD_HAS_IMP_DISPLAY
IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_isd.IMP_ISD_HAS_IMP_SCORE_FUNCTOR
IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_isd.IMP_ISD_HAS_BOOST_FILESYSTEM
IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_isd.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS
IMP_ISD_HAS_BOOST_RANDOM = _IMP_isd.IMP_ISD_HAS_BOOST_RANDOM
IMP_ISD_HAS_BOOST_REGEX = _IMP_isd.IMP_ISD_HAS_BOOST_REGEX
IMP_ISD_HAS_BOOST_SYSTEM = _IMP_isd.IMP_ISD_HAS_BOOST_SYSTEM
IMP_ISD_HAS_CGAL = _IMP_isd.IMP_ISD_HAS_CGAL
IMP_ISD_HAS_HDF5 = _IMP_isd.IMP_ISD_HAS_HDF5
IMPISD_SHOW_WARNINGS = _IMP_isd.IMPISD_SHOW_WARNINGS
_object_types.append("CrossLinkMSRestraint")


def _object_cast_to_CrossLinkMSRestraint(*args):
  """_object_cast_to_CrossLinkMSRestraint(Object o) -> CrossLinkMSRestraint"""
  return _IMP_isd._object_cast_to_CrossLinkMSRestraint(*args)
_object_types.append("LogWrapper")


def _object_cast_to_LogWrapper(*args):
  """_object_cast_to_LogWrapper(Object o) -> LogWrapper"""
  return _IMP_isd._object_cast_to_LogWrapper(*args)
_object_types.append("UniformPrior")


def _object_cast_to_UniformPrior(*args):
  """_object_cast_to_UniformPrior(Object o) -> UniformPrior"""
  return _IMP_isd._object_cast_to_UniformPrior(*args)
_object_types.append("JeffreysRestraint")


def _object_cast_to_JeffreysRestraint(*args):
  """_object_cast_to_JeffreysRestraint(Object o) -> JeffreysRestraint"""
  return _IMP_isd._object_cast_to_JeffreysRestraint(*args)
_object_types.append("vonMisesKappaJeffreysRestraint")


def _object_cast_to_vonMisesKappaJeffreysRestraint(*args):
  """_object_cast_to_vonMisesKappaJeffreysRestraint(Object o) -> vonMisesKappaJeffreysRestraint"""
  return _IMP_isd._object_cast_to_vonMisesKappaJeffreysRestraint(*args)
_object_types.append("vonMisesKappaConjugateRestraint")


def _object_cast_to_vonMisesKappaConjugateRestraint(*args):
  """_object_cast_to_vonMisesKappaConjugateRestraint(Object o) -> vonMisesKappaConjugateRestraint"""
  return _IMP_isd._object_cast_to_vonMisesKappaConjugateRestraint(*args)
_object_types.append("FNormal")


def _object_cast_to_FNormal(*args):
  """_object_cast_to_FNormal(Object o) -> FNormal"""
  return _IMP_isd._object_cast_to_FNormal(*args)
_object_types.append("vonMises")


def _object_cast_to_vonMises(*args):
  """_object_cast_to_vonMises(Object o) -> vonMises"""
  return _IMP_isd._object_cast_to_vonMises(*args)
_object_types.append("vonMisesSufficient")


def _object_cast_to_vonMisesSufficient(*args):
  """_object_cast_to_vonMisesSufficient(Object o) -> vonMisesSufficient"""
  return _IMP_isd._object_cast_to_vonMisesSufficient(*args)
def Nuisances(l=[]):
    return [Nuisance(x) for x in l]
_plural_types.append("Nuisances")

_value_types.append("Nuisance")

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

_value_types.append("Scale")

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

_value_types.append("Switching")

_object_types.append("NOERestraint")


def _object_cast_to_NOERestraint(*args):
  """_object_cast_to_NOERestraint(Object o) -> NOERestraint"""
  return _IMP_isd._object_cast_to_NOERestraint(*args)
def Weights(l=[]):
    return [Weight(x) for x in l]
_plural_types.append("Weights")

_value_types.append("Weight")

_object_types.append("GaussianRestraint")


def _object_cast_to_GaussianRestraint(*args):
  """_object_cast_to_GaussianRestraint(Object o) -> GaussianRestraint"""
  return _IMP_isd._object_cast_to_GaussianRestraint(*args)
_object_types.append("LognormalRestraint")


def _object_cast_to_LognormalRestraint(*args):
  """_object_cast_to_LognormalRestraint(Object o) -> LognormalRestraint"""
  return _IMP_isd._object_cast_to_LognormalRestraint(*args)
_object_types.append("AmbiguousNOERestraint")


def _object_cast_to_AmbiguousNOERestraint(*args):
  """_object_cast_to_AmbiguousNOERestraint(Object o) -> AmbiguousNOERestraint"""
  return _IMP_isd._object_cast_to_AmbiguousNOERestraint(*args)
_object_types.append("MarginalNOERestraint")


def _object_cast_to_MarginalNOERestraint(*args):
  """_object_cast_to_MarginalNOERestraint(Object o) -> MarginalNOERestraint"""
  return _IMP_isd._object_cast_to_MarginalNOERestraint(*args)
_object_types.append("MarginalHBondRestraint")


def _object_cast_to_MarginalHBondRestraint(*args):
  """_object_cast_to_MarginalHBondRestraint(Object o) -> MarginalHBondRestraint"""
  return _IMP_isd._object_cast_to_MarginalHBondRestraint(*args)
_object_types.append("TALOSRestraint")


def _object_cast_to_TALOSRestraint(*args):
  """_object_cast_to_TALOSRestraint(Object o) -> TALOSRestraint"""
  return _IMP_isd._object_cast_to_TALOSRestraint(*args)
_object_types.append("RepulsiveDistancePairScore")


def _object_cast_to_RepulsiveDistancePairScore(*args):
  """_object_cast_to_RepulsiveDistancePairScore(Object o) -> RepulsiveDistancePairScore"""
  return _IMP_isd._object_cast_to_RepulsiveDistancePairScore(*args)
_object_types.append("AmbiguousRestraint")


def _object_cast_to_AmbiguousRestraint(*args):
  """_object_cast_to_AmbiguousRestraint(Object o) -> AmbiguousRestraint"""
  return _IMP_isd._object_cast_to_AmbiguousRestraint(*args)
_object_types.append("UnivariateFunction")


def _object_cast_to_UnivariateFunction(*args):
  """_object_cast_to_UnivariateFunction(Object o) -> UnivariateFunction"""
  return _IMP_isd._object_cast_to_UnivariateFunction(*args)
_object_types.append("Linear1DFunction")


def _object_cast_to_Linear1DFunction(*args):
  """_object_cast_to_Linear1DFunction(Object o) -> Linear1DFunction"""
  return _IMP_isd._object_cast_to_Linear1DFunction(*args)
_object_types.append("GeneralizedGuinierPorodFunction")


def _object_cast_to_GeneralizedGuinierPorodFunction(*args):
  """_object_cast_to_GeneralizedGuinierPorodFunction(Object o) -> GeneralizedGuinierPorodFunction"""
  return _IMP_isd._object_cast_to_GeneralizedGuinierPorodFunction(*args)
_object_types.append("BivariateFunction")


def _object_cast_to_BivariateFunction(*args):
  """_object_cast_to_BivariateFunction(Object o) -> BivariateFunction"""
  return _IMP_isd._object_cast_to_BivariateFunction(*args)
_object_types.append("Covariance1DFunction")


def _object_cast_to_Covariance1DFunction(*args):
  """_object_cast_to_Covariance1DFunction(Object o) -> Covariance1DFunction"""
  return _IMP_isd._object_cast_to_Covariance1DFunction(*args)
_object_types.append("GaussianProcessInterpolation")


def _object_cast_to_GaussianProcessInterpolation(*args):
  """_object_cast_to_GaussianProcessInterpolation(Object o) -> GaussianProcessInterpolation"""
  return _IMP_isd._object_cast_to_GaussianProcessInterpolation(*args)
_object_types.append("GaussianProcessInterpolationRestraint")


def _object_cast_to_GaussianProcessInterpolationRestraint(*args):
  """_object_cast_to_GaussianProcessInterpolationRestraint(Object o) -> GaussianProcessInterpolationRestraint"""
  return _IMP_isd._object_cast_to_GaussianProcessInterpolationRestraint(*args)
_object_types.append("MolecularDynamics")

_object_types.append("MolecularDynamicsMover")


def _object_cast_to_MolecularDynamicsMover(*args):
  """_object_cast_to_MolecularDynamicsMover(Object o) -> MolecularDynamicsMover"""
  return _IMP_isd._object_cast_to_MolecularDynamicsMover(*args)
_object_types.append("HybridMonteCarlo")


def _object_cast_to_HybridMonteCarlo(*args):
  """_object_cast_to_HybridMonteCarlo(Object o) -> HybridMonteCarlo"""
  return _IMP_isd._object_cast_to_HybridMonteCarlo(*args)
_object_types.append("FretData")


def _object_cast_to_FretData(*args):
  """_object_cast_to_FretData(Object o) -> FretData"""
  return _IMP_isd._object_cast_to_FretData(*args)
_object_types.append("FretRestraint")


def _object_cast_to_FretRestraint(*args):
  """_object_cast_to_FretRestraint(Object o) -> FretRestraint"""
  return _IMP_isd._object_cast_to_FretRestraint(*args)
_object_types.append("CrossLinkData")


def _object_cast_to_CrossLinkData(*args):
  """_object_cast_to_CrossLinkData(Object o) -> CrossLinkData"""
  return _IMP_isd._object_cast_to_CrossLinkData(*args)
_object_types.append("CysteineCrossLinkData")


def _object_cast_to_CysteineCrossLinkData(*args):
  """_object_cast_to_CysteineCrossLinkData(Object o) -> CysteineCrossLinkData"""
  return _IMP_isd._object_cast_to_CysteineCrossLinkData(*args)
_object_types.append("CysteineCrossLinkRestraint")


def _object_cast_to_CysteineCrossLinkRestraint(*args):
  """_object_cast_to_CysteineCrossLinkRestraint(Object o) -> CysteineCrossLinkRestraint"""
  return _IMP_isd._object_cast_to_CysteineCrossLinkRestraint(*args)
_object_types.append("WeightMover")


def _object_cast_to_WeightMover(*args):
  """_object_cast_to_WeightMover(Object o) -> WeightMover"""
  return _IMP_isd._object_cast_to_WeightMover(*args)
_object_types.append("WeightRestraint")


def _object_cast_to_WeightRestraint(*args):
  """_object_cast_to_WeightRestraint(Object o) -> WeightRestraint"""
  return _IMP_isd._object_cast_to_WeightRestraint(*args)
_object_types.append("AtomicCrossLinkMSRestraint")


def _object_cast_to_AtomicCrossLinkMSRestraint(*args):
  """_object_cast_to_AtomicCrossLinkMSRestraint(Object o) -> AtomicCrossLinkMSRestraint"""
  return _IMP_isd._object_cast_to_AtomicCrossLinkMSRestraint(*args)
_object_types.append("GaussianEMRestraint")


def _object_cast_to_GaussianEMRestraint(*args):
  """_object_cast_to_GaussianEMRestraint(Object o) -> GaussianEMRestraint"""
  return _IMP_isd._object_cast_to_GaussianEMRestraint(*args)
def create_model_and_particles():
  m= IMP.Model()
  sc= IMP.container.ListSingletonContainer(m)
  b= IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0,0,0),
                               IMP.algebra.Vector3D(10,10,10))
  for i in range(0,100):
     p= IMP.Particle(m)
     sc.add_particle(p)
     d=IMP.core.XYZR.setup_particle(p, IMP.algebra.Sphere3D(IMP.algebra.get_random_vector_in(b), 1))
     d.set_coordinates_are_optimized(True)
  return (m, sc)

class CrossLinkMSRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::CrossLinkMSRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CrossLinkMSRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CrossLinkMSRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::CrossLinkMSRestraint self, Model m, double length, std::string name="CrossLinkMSRestraint%1%") -> CrossLinkMSRestraint
        __init__(IMP::isd::CrossLinkMSRestraint self, Model m, double length) -> CrossLinkMSRestraint
        __init__(IMP::isd::CrossLinkMSRestraint self, Model m, _ParticleIndexAdaptor lengthi, std::string name="CrossLinkMSRestraint%1%") -> CrossLinkMSRestraint
        __init__(IMP::isd::CrossLinkMSRestraint self, Model m, _ParticleIndexAdaptor lengthi) -> CrossLinkMSRestraint
        __init__(IMP::isd::CrossLinkMSRestraint self, Model m, double length, double slope, std::string name="CrossLinkMSRestraint%1%") -> CrossLinkMSRestraint
        __init__(IMP::isd::CrossLinkMSRestraint self, Model m, double length, double slope) -> CrossLinkMSRestraint
        """
        this = _IMP_isd.new_CrossLinkMSRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_contribution(self, *args):
        """
        add_contribution(CrossLinkMSRestraint self, IMP::kernel::ParticleIndexPair const & pps, IMP::kernel::ParticleIndexPair const & sigmas, 
            IMP::kernel::ParticleIndex const & psi)
        """
        return _IMP_isd.CrossLinkMSRestraint_add_contribution(self, *args)

    def get_probability(self):
        """get_probability(CrossLinkMSRestraint self) -> double"""
        return _IMP_isd.CrossLinkMSRestraint_get_probability(self)

    def get_number_of_contributions(self):
        """get_number_of_contributions(CrossLinkMSRestraint self) -> unsigned int"""
        return _IMP_isd.CrossLinkMSRestraint_get_number_of_contributions(self)

    def do_get_inputs(self):
        """do_get_inputs(CrossLinkMSRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.CrossLinkMSRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(CrossLinkMSRestraint self) -> VersionInfo"""
        return _IMP_isd.CrossLinkMSRestraint_get_version_info(self)

    def __str__(self):
        """__str__(CrossLinkMSRestraint self) -> std::string"""
        return _IMP_isd.CrossLinkMSRestraint___str__(self)

    def __repr__(self):
        """__repr__(CrossLinkMSRestraint self) -> std::string"""
        return _IMP_isd.CrossLinkMSRestraint___repr__(self)

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

CrossLinkMSRestraint_swigregister = _IMP_isd.CrossLinkMSRestraint_swigregister
CrossLinkMSRestraint_swigregister(CrossLinkMSRestraint)

class LogWrapper(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::LogWrapper class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogWrapper, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LogWrapper, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::LogWrapper self, Model m, double weight, std::string const & name="LogWrapper %1%") -> LogWrapper
        __init__(IMP::isd::LogWrapper self, Model m, double weight) -> LogWrapper
        __init__(IMP::isd::LogWrapper self, Model m, std::string const & name="LogWrapper %1%") -> LogWrapper
        __init__(IMP::isd::LogWrapper self, Model m) -> LogWrapper
        __init__(IMP::isd::LogWrapper self, IMP::kernel::RestraintsTemp const & rs, double weight, std::string const & name="LogWrapper %1%") -> LogWrapper
        __init__(IMP::isd::LogWrapper self, IMP::kernel::RestraintsTemp const & rs, double weight) -> LogWrapper
        """
        this = _IMP_isd.new_LogWrapper(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(LogWrapper self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.LogWrapper_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(LogWrapper self) -> VersionInfo"""
        return _IMP_isd.LogWrapper_get_version_info(self)

    def remove_restraint(self, *args):
        """remove_restraint(LogWrapper self, Restraint d)"""
        return _IMP_isd.LogWrapper_remove_restraint(self, *args)

    def remove_restraints(self, *args):
        """remove_restraints(LogWrapper self, IMP::kernel::Restraints const & d)"""
        return _IMP_isd.LogWrapper_remove_restraints(self, *args)

    def set_restraints(self, *args):
        """set_restraints(LogWrapper self, IMP::kernel::Restraints const & ps)"""
        return _IMP_isd.LogWrapper_set_restraints(self, *args)

    def set_restraints_order(self, *args):
        """set_restraints_order(LogWrapper self, IMP::kernel::Restraints const & objs)"""
        return _IMP_isd.LogWrapper_set_restraints_order(self, *args)

    def add_restraint(self, *args):
        """add_restraint(LogWrapper self, Restraint obj) -> unsigned int"""
        return _IMP_isd.LogWrapper_add_restraint(self, *args)

    def add_restraints(self, *args):
        """add_restraints(LogWrapper self, IMP::kernel::Restraints const & objs)"""
        return _IMP_isd.LogWrapper_add_restraints(self, *args)

    def clear_restraints(self):
        """clear_restraints(LogWrapper self)"""
        return _IMP_isd.LogWrapper_clear_restraints(self)

    def get_number_of_restraints(self):
        """get_number_of_restraints(LogWrapper self) -> unsigned int"""
        return _IMP_isd.LogWrapper_get_number_of_restraints(self)

    def get_has_restraints(self):
        """get_has_restraints(LogWrapper self) -> bool"""
        return _IMP_isd.LogWrapper_get_has_restraints(self)

    def get_restraint(self, *args):
        """get_restraint(LogWrapper self, unsigned int i) -> Restraint"""
        return _IMP_isd.LogWrapper_get_restraint(self, *args)

    def get_restraints(self):
        """get_restraints(LogWrapper self) -> IMP::kernel::Restraints"""
        return _IMP_isd.LogWrapper_get_restraints(self)

    def reserve_restraints(self, *args):
        """reserve_restraints(LogWrapper self, unsigned int sz)"""
        return _IMP_isd.LogWrapper_reserve_restraints(self, *args)

    def __str__(self):
        """__str__(LogWrapper self) -> std::string"""
        return _IMP_isd.LogWrapper___str__(self)

    def __repr__(self):
        """__repr__(LogWrapper self) -> std::string"""
        return _IMP_isd.LogWrapper___repr__(self)

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

LogWrapper_swigregister = _IMP_isd.LogWrapper_swigregister
LogWrapper_swigregister(LogWrapper)

class UniformPrior(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::UniformPrior class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniformPrior, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UniformPrior, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::UniformPrior self, Model m, Particle p, IMP::Float k, IMP::Float upperb, IMP::Float lowerb, std::string name="UniformPrior%1%") -> UniformPrior
        __init__(IMP::isd::UniformPrior self, Model m, Particle p, IMP::Float k, IMP::Float upperb, IMP::Float lowerb) -> UniformPrior
        """
        this = _IMP_isd.new_UniformPrior(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(UniformPrior self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.UniformPrior_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(UniformPrior self) -> VersionInfo"""
        return _IMP_isd.UniformPrior_get_version_info(self)

    def get_probability(self):
        """get_probability(UniformPrior self) -> double"""
        return _IMP_isd.UniformPrior_get_probability(self)

    def __str__(self):
        """__str__(UniformPrior self) -> std::string"""
        return _IMP_isd.UniformPrior___str__(self)

    def __repr__(self):
        """__repr__(UniformPrior self) -> std::string"""
        return _IMP_isd.UniformPrior___repr__(self)

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

UniformPrior_swigregister = _IMP_isd.UniformPrior_swigregister
UniformPrior_swigregister(UniformPrior)

class Nuisance(IMP.kernel.Decorator):
    """Proxy of C++ IMP::isd::Nuisance class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Nuisance, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Nuisance, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::Nuisance self) -> Nuisance
        __init__(IMP::isd::Nuisance self, Model m, ::IMP::kernel::ParticleIndex id) -> Nuisance
        __init__(IMP::isd::Nuisance self, _ParticleAdaptor d) -> Nuisance
        """
        this = _IMP_isd.new_Nuisance(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(Nuisance self, _ostream out=std::cout)
        show(Nuisance self)
        """
        return _IMP_isd.Nuisance_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Nuisance
        setup_particle(_ParticleAdaptor decorator) -> Nuisance
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, double nuisance) -> Nuisance
        setup_particle(_ParticleAdaptor decorator, double nuisance) -> Nuisance
        """
        return _IMP_isd.Nuisance_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_isd.Nuisance_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    def get_nuisance_key():
        """get_nuisance_key() -> FloatKey"""
        return _IMP_isd.Nuisance_get_nuisance_key()

    if _newclass:get_nuisance_key = staticmethod(get_nuisance_key)
    __swig_getmethods__["get_nuisance_key"] = lambda x: get_nuisance_key
    def get_nuisance(self):
        """get_nuisance(Nuisance self) -> IMP::Float"""
        return _IMP_isd.Nuisance_get_nuisance(self)

    def set_nuisance(self, *args):
        """set_nuisance(Nuisance self, IMP::Float d)"""
        return _IMP_isd.Nuisance_set_nuisance(self, *args)

    def get_has_lower(self):
        """get_has_lower(Nuisance self) -> bool"""
        return _IMP_isd.Nuisance_get_has_lower(self)

    def get_lower(self):
        """get_lower(Nuisance self) -> IMP::Float"""
        return _IMP_isd.Nuisance_get_lower(self)

    def get_lower_key():
        """get_lower_key() -> FloatKey"""
        return _IMP_isd.Nuisance_get_lower_key()

    if _newclass:get_lower_key = staticmethod(get_lower_key)
    __swig_getmethods__["get_lower_key"] = lambda x: get_lower_key
    def get_lower_particle_key():
        """get_lower_particle_key() -> ParticleIndexKey"""
        return _IMP_isd.Nuisance_get_lower_particle_key()

    if _newclass:get_lower_particle_key = staticmethod(get_lower_particle_key)
    __swig_getmethods__["get_lower_particle_key"] = lambda x: get_lower_particle_key
    def set_lower(self, *args):
        """
        set_lower(Nuisance self, IMP::Float d)
        set_lower(Nuisance self, Particle d)
        """
        return _IMP_isd.Nuisance_set_lower(self, *args)

    def remove_lower(self):
        """remove_lower(Nuisance self)"""
        return _IMP_isd.Nuisance_remove_lower(self)

    def get_has_upper(self):
        """get_has_upper(Nuisance self) -> bool"""
        return _IMP_isd.Nuisance_get_has_upper(self)

    def get_upper(self):
        """get_upper(Nuisance self) -> IMP::Float"""
        return _IMP_isd.Nuisance_get_upper(self)

    def get_upper_key():
        """get_upper_key() -> FloatKey"""
        return _IMP_isd.Nuisance_get_upper_key()

    if _newclass:get_upper_key = staticmethod(get_upper_key)
    __swig_getmethods__["get_upper_key"] = lambda x: get_upper_key
    def get_upper_particle_key():
        """get_upper_particle_key() -> ParticleIndexKey"""
        return _IMP_isd.Nuisance_get_upper_particle_key()

    if _newclass:get_upper_particle_key = staticmethod(get_upper_particle_key)
    __swig_getmethods__["get_upper_particle_key"] = lambda x: get_upper_particle_key
    def set_upper(self, *args):
        """
        set_upper(Nuisance self, IMP::Float d)
        set_upper(Nuisance self, Particle d)
        """
        return _IMP_isd.Nuisance_set_upper(self, *args)

    def remove_upper(self):
        """remove_upper(Nuisance self)"""
        return _IMP_isd.Nuisance_remove_upper(self)

    def get_nuisance_derivative(self):
        """get_nuisance_derivative(Nuisance self) -> IMP::Float"""
        return _IMP_isd.Nuisance_get_nuisance_derivative(self)

    def add_to_nuisance_derivative(self, *args):
        """add_to_nuisance_derivative(Nuisance self, IMP::Float d, DerivativeAccumulator accum)"""
        return _IMP_isd.Nuisance_add_to_nuisance_derivative(self, *args)

    def get_nuisance_is_optimized(self):
        """get_nuisance_is_optimized(Nuisance self) -> bool"""
        return _IMP_isd.Nuisance_get_nuisance_is_optimized(self)

    def set_nuisance_is_optimized(self, *args):
        """set_nuisance_is_optimized(Nuisance self, bool val)"""
        return _IMP_isd.Nuisance_set_nuisance_is_optimized(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(Nuisance self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Nuisance self, FloatKey a0, IMP::Float a1)
        add_attribute(Nuisance self, IntKey a0, IMP::Int a1)
        add_attribute(Nuisance self, StringKey a0, IMP::String a1)
        add_attribute(Nuisance self, ParticleIndexKey a0, Particle a1)
        add_attribute(Nuisance self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Nuisance_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Nuisance self, FloatKey a0) -> IMP::Float
        get_value(Nuisance self, IntKey a0) -> IMP::Int
        get_value(Nuisance self, StringKey a0) -> IMP::String
        get_value(Nuisance self, ParticleIndexKey a0) -> Particle
        get_value(Nuisance self, ObjectKey a0) -> Object
        """
        return _IMP_isd.Nuisance_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Nuisance self, FloatKey a0, IMP::Float a1)
        set_value(Nuisance self, IntKey a0, IMP::Int a1)
        set_value(Nuisance self, StringKey a0, IMP::String a1)
        set_value(Nuisance self, ParticleIndexKey a0, Particle a1)
        set_value(Nuisance self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Nuisance_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Nuisance self, FloatKey a0)
        remove_attribute(Nuisance self, IntKey a0)
        remove_attribute(Nuisance self, StringKey a0)
        remove_attribute(Nuisance self, ParticleIndexKey a0)
        remove_attribute(Nuisance self, ObjectKey a0)
        """
        return _IMP_isd.Nuisance_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Nuisance self, FloatKey a0) -> bool
        has_attribute(Nuisance self, IntKey a0) -> bool
        has_attribute(Nuisance self, StringKey a0) -> bool
        has_attribute(Nuisance self, ParticleIndexKey a0) -> bool
        has_attribute(Nuisance self, ObjectKey a0) -> bool
        """
        return _IMP_isd.Nuisance_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Nuisance self, FloatKey a0) -> double"""
        return _IMP_isd.Nuisance_get_derivative(self, *args)

    def get_name(self):
        """get_name(Nuisance self) -> std::string"""
        return _IMP_isd.Nuisance_get_name(self)

    def clear_caches(self):
        """clear_caches(Nuisance self)"""
        return _IMP_isd.Nuisance_clear_caches(self)

    def set_name(self, *args):
        """set_name(Nuisance self, std::string a0)"""
        return _IMP_isd.Nuisance_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Nuisance self, IMP::base::CheckLevel a0)"""
        return _IMP_isd.Nuisance_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Nuisance self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_isd.Nuisance_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Nuisance self, FloatKey a0, bool a1)"""
        return _IMP_isd.Nuisance_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Nuisance self, FloatKey a0) -> bool"""
        return _IMP_isd.Nuisance_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Nuisance self) -> IMP::base::CheckLevel"""
        return _IMP_isd.Nuisance_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Nuisance self, Nuisance o) -> bool
        __eq__(Nuisance self, Particle d) -> bool
        """
        return _IMP_isd.Nuisance___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Nuisance self, Nuisance o) -> bool
        __ne__(Nuisance self, Particle d) -> bool
        """
        return _IMP_isd.Nuisance___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Nuisance self, Nuisance o) -> bool
        __le__(Nuisance self, Particle d) -> bool
        """
        return _IMP_isd.Nuisance___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Nuisance self, Nuisance o) -> bool
        __lt__(Nuisance self, Particle d) -> bool
        """
        return _IMP_isd.Nuisance___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Nuisance self, Nuisance o) -> bool
        __ge__(Nuisance self, Particle d) -> bool
        """
        return _IMP_isd.Nuisance___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Nuisance self, Nuisance o) -> bool
        __gt__(Nuisance self, Particle d) -> bool
        """
        return _IMP_isd.Nuisance___gt__(self, *args)

    def __str__(self):
        """__str__(Nuisance self) -> std::string"""
        return _IMP_isd.Nuisance___str__(self)

    def __repr__(self):
        """__repr__(Nuisance self) -> std::string"""
        return _IMP_isd.Nuisance___repr__(self)

    __swig_destroy__ = _IMP_isd.delete_Nuisance
    __del__ = lambda self : None;
Nuisance_swigregister = _IMP_isd.Nuisance_swigregister
Nuisance_swigregister(Nuisance)

def Nuisance_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Nuisance
    setup_particle(_ParticleAdaptor decorator) -> Nuisance
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, double nuisance) -> Nuisance
    Nuisance_setup_particle(_ParticleAdaptor decorator, double nuisance) -> Nuisance
    """
  return _IMP_isd.Nuisance_setup_particle(*args)

def Nuisance_get_is_setup(*args):
  """
    get_is_setup(_ParticleAdaptor p) -> bool
    Nuisance_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_isd.Nuisance_get_is_setup(*args)

def Nuisance_get_nuisance_key():
  """Nuisance_get_nuisance_key() -> FloatKey"""
  return _IMP_isd.Nuisance_get_nuisance_key()

def Nuisance_get_lower_key():
  """Nuisance_get_lower_key() -> FloatKey"""
  return _IMP_isd.Nuisance_get_lower_key()

def Nuisance_get_lower_particle_key():
  """Nuisance_get_lower_particle_key() -> ParticleIndexKey"""
  return _IMP_isd.Nuisance_get_lower_particle_key()

def Nuisance_get_upper_key():
  """Nuisance_get_upper_key() -> FloatKey"""
  return _IMP_isd.Nuisance_get_upper_key()

def Nuisance_get_upper_particle_key():
  """Nuisance_get_upper_particle_key() -> ParticleIndexKey"""
  return _IMP_isd.Nuisance_get_upper_particle_key()

class Scale(Nuisance):
    """Proxy of C++ IMP::isd::Scale class"""
    __swig_setmethods__ = {}
    for _s in [Nuisance]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scale, name, value)
    __swig_getmethods__ = {}
    for _s in [Nuisance]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Scale, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::Scale self) -> Scale
        __init__(IMP::isd::Scale self, Model m, ::IMP::kernel::ParticleIndex id) -> Scale
        __init__(IMP::isd::Scale self, _ParticleAdaptor d) -> Scale
        """
        this = _IMP_isd.new_Scale(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(Scale self, _ostream out=std::cout)
        show(Scale self)
        """
        return _IMP_isd.Scale_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Scale
        setup_particle(_ParticleAdaptor decorator) -> Scale
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, double scale) -> Scale
        setup_particle(_ParticleAdaptor decorator, double scale) -> Scale
        """
        return _IMP_isd.Scale_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_isd.Scale_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    def get_scale(self):
        """get_scale(Scale self) -> IMP::Float"""
        return _IMP_isd.Scale_get_scale(self)

    def set_scale(self, *args):
        """set_scale(Scale self, IMP::Float d)"""
        return _IMP_isd.Scale_set_scale(self, *args)

    def add_to_scale_derivative(self, *args):
        """add_to_scale_derivative(Scale self, IMP::Float d, DerivativeAccumulator accum)"""
        return _IMP_isd.Scale_add_to_scale_derivative(self, *args)

    def get_scale_derivative(self):
        """get_scale_derivative(Scale self) -> IMP::Float"""
        return _IMP_isd.Scale_get_scale_derivative(self)

    def get_scale_key():
        """get_scale_key() -> FloatKey"""
        return _IMP_isd.Scale_get_scale_key()

    if _newclass:get_scale_key = staticmethod(get_scale_key)
    __swig_getmethods__["get_scale_key"] = lambda x: get_scale_key
    def get_scale_is_optimized(self):
        """get_scale_is_optimized(Scale self) -> bool"""
        return _IMP_isd.Scale_get_scale_is_optimized(self)

    def set_scale_is_optimized(self, *args):
        """set_scale_is_optimized(Scale self, bool val)"""
        return _IMP_isd.Scale_set_scale_is_optimized(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(Scale self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Scale self, FloatKey a0, IMP::Float a1)
        add_attribute(Scale self, IntKey a0, IMP::Int a1)
        add_attribute(Scale self, StringKey a0, IMP::String a1)
        add_attribute(Scale self, ParticleIndexKey a0, Particle a1)
        add_attribute(Scale self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Scale_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Scale self, FloatKey a0) -> IMP::Float
        get_value(Scale self, IntKey a0) -> IMP::Int
        get_value(Scale self, StringKey a0) -> IMP::String
        get_value(Scale self, ParticleIndexKey a0) -> Particle
        get_value(Scale self, ObjectKey a0) -> Object
        """
        return _IMP_isd.Scale_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Scale self, FloatKey a0, IMP::Float a1)
        set_value(Scale self, IntKey a0, IMP::Int a1)
        set_value(Scale self, StringKey a0, IMP::String a1)
        set_value(Scale self, ParticleIndexKey a0, Particle a1)
        set_value(Scale self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Scale_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Scale self, FloatKey a0)
        remove_attribute(Scale self, IntKey a0)
        remove_attribute(Scale self, StringKey a0)
        remove_attribute(Scale self, ParticleIndexKey a0)
        remove_attribute(Scale self, ObjectKey a0)
        """
        return _IMP_isd.Scale_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Scale self, FloatKey a0) -> bool
        has_attribute(Scale self, IntKey a0) -> bool
        has_attribute(Scale self, StringKey a0) -> bool
        has_attribute(Scale self, ParticleIndexKey a0) -> bool
        has_attribute(Scale self, ObjectKey a0) -> bool
        """
        return _IMP_isd.Scale_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Scale self, FloatKey a0) -> double"""
        return _IMP_isd.Scale_get_derivative(self, *args)

    def get_name(self):
        """get_name(Scale self) -> std::string"""
        return _IMP_isd.Scale_get_name(self)

    def clear_caches(self):
        """clear_caches(Scale self)"""
        return _IMP_isd.Scale_clear_caches(self)

    def set_name(self, *args):
        """set_name(Scale self, std::string a0)"""
        return _IMP_isd.Scale_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Scale self, IMP::base::CheckLevel a0)"""
        return _IMP_isd.Scale_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Scale self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_isd.Scale_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Scale self, FloatKey a0, bool a1)"""
        return _IMP_isd.Scale_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Scale self, FloatKey a0) -> bool"""
        return _IMP_isd.Scale_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Scale self) -> IMP::base::CheckLevel"""
        return _IMP_isd.Scale_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Scale self, Scale o) -> bool
        __eq__(Scale self, Particle d) -> bool
        """
        return _IMP_isd.Scale___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Scale self, Scale o) -> bool
        __ne__(Scale self, Particle d) -> bool
        """
        return _IMP_isd.Scale___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Scale self, Scale o) -> bool
        __le__(Scale self, Particle d) -> bool
        """
        return _IMP_isd.Scale___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Scale self, Scale o) -> bool
        __lt__(Scale self, Particle d) -> bool
        """
        return _IMP_isd.Scale___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Scale self, Scale o) -> bool
        __ge__(Scale self, Particle d) -> bool
        """
        return _IMP_isd.Scale___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Scale self, Scale o) -> bool
        __gt__(Scale self, Particle d) -> bool
        """
        return _IMP_isd.Scale___gt__(self, *args)

    def __str__(self):
        """__str__(Scale self) -> std::string"""
        return _IMP_isd.Scale___str__(self)

    def __repr__(self):
        """__repr__(Scale self) -> std::string"""
        return _IMP_isd.Scale___repr__(self)

    __swig_destroy__ = _IMP_isd.delete_Scale
    __del__ = lambda self : None;
Scale_swigregister = _IMP_isd.Scale_swigregister
Scale_swigregister(Scale)

def Scale_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Scale
    setup_particle(_ParticleAdaptor decorator) -> Scale
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, double scale) -> Scale
    Scale_setup_particle(_ParticleAdaptor decorator, double scale) -> Scale
    """
  return _IMP_isd.Scale_setup_particle(*args)

def Scale_get_is_setup(*args):
  """
    get_is_setup(_ParticleAdaptor p) -> bool
    Scale_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_isd.Scale_get_is_setup(*args)

def Scale_get_scale_key():
  """Scale_get_scale_key() -> FloatKey"""
  return _IMP_isd.Scale_get_scale_key()

class Switching(Nuisance):
    """Proxy of C++ IMP::isd::Switching class"""
    __swig_setmethods__ = {}
    for _s in [Nuisance]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Switching, name, value)
    __swig_getmethods__ = {}
    for _s in [Nuisance]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Switching, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::Switching self) -> Switching
        __init__(IMP::isd::Switching self, Model m, ::IMP::kernel::ParticleIndex id) -> Switching
        __init__(IMP::isd::Switching self, _ParticleAdaptor d) -> Switching
        """
        this = _IMP_isd.new_Switching(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(Switching self, _ostream out=std::cout)
        show(Switching self)
        """
        return _IMP_isd.Switching_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Switching
        setup_particle(_ParticleAdaptor decorator) -> Switching
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, double switching) -> Switching
        setup_particle(_ParticleAdaptor decorator, double switching) -> Switching
        """
        return _IMP_isd.Switching_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_isd.Switching_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    def get_switching(self):
        """get_switching(Switching self) -> IMP::Float"""
        return _IMP_isd.Switching_get_switching(self)

    def set_switching(self, *args):
        """set_switching(Switching self, IMP::Float d)"""
        return _IMP_isd.Switching_set_switching(self, *args)

    def add_to_switching_derivative(self, *args):
        """add_to_switching_derivative(Switching self, IMP::Float d, DerivativeAccumulator accum)"""
        return _IMP_isd.Switching_add_to_switching_derivative(self, *args)

    def get_switching_derivative(self):
        """get_switching_derivative(Switching self) -> IMP::Float"""
        return _IMP_isd.Switching_get_switching_derivative(self)

    def get_switching_key():
        """get_switching_key() -> FloatKey"""
        return _IMP_isd.Switching_get_switching_key()

    if _newclass:get_switching_key = staticmethod(get_switching_key)
    __swig_getmethods__["get_switching_key"] = lambda x: get_switching_key
    def get_switching_is_optimized(self):
        """get_switching_is_optimized(Switching self) -> bool"""
        return _IMP_isd.Switching_get_switching_is_optimized(self)

    def set_switching_is_optimized(self, *args):
        """set_switching_is_optimized(Switching self, bool val)"""
        return _IMP_isd.Switching_set_switching_is_optimized(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(Switching self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Switching self, FloatKey a0, IMP::Float a1)
        add_attribute(Switching self, IntKey a0, IMP::Int a1)
        add_attribute(Switching self, StringKey a0, IMP::String a1)
        add_attribute(Switching self, ParticleIndexKey a0, Particle a1)
        add_attribute(Switching self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Switching_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Switching self, FloatKey a0) -> IMP::Float
        get_value(Switching self, IntKey a0) -> IMP::Int
        get_value(Switching self, StringKey a0) -> IMP::String
        get_value(Switching self, ParticleIndexKey a0) -> Particle
        get_value(Switching self, ObjectKey a0) -> Object
        """
        return _IMP_isd.Switching_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Switching self, FloatKey a0, IMP::Float a1)
        set_value(Switching self, IntKey a0, IMP::Int a1)
        set_value(Switching self, StringKey a0, IMP::String a1)
        set_value(Switching self, ParticleIndexKey a0, Particle a1)
        set_value(Switching self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Switching_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Switching self, FloatKey a0)
        remove_attribute(Switching self, IntKey a0)
        remove_attribute(Switching self, StringKey a0)
        remove_attribute(Switching self, ParticleIndexKey a0)
        remove_attribute(Switching self, ObjectKey a0)
        """
        return _IMP_isd.Switching_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Switching self, FloatKey a0) -> bool
        has_attribute(Switching self, IntKey a0) -> bool
        has_attribute(Switching self, StringKey a0) -> bool
        has_attribute(Switching self, ParticleIndexKey a0) -> bool
        has_attribute(Switching self, ObjectKey a0) -> bool
        """
        return _IMP_isd.Switching_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Switching self, FloatKey a0) -> double"""
        return _IMP_isd.Switching_get_derivative(self, *args)

    def get_name(self):
        """get_name(Switching self) -> std::string"""
        return _IMP_isd.Switching_get_name(self)

    def clear_caches(self):
        """clear_caches(Switching self)"""
        return _IMP_isd.Switching_clear_caches(self)

    def set_name(self, *args):
        """set_name(Switching self, std::string a0)"""
        return _IMP_isd.Switching_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Switching self, IMP::base::CheckLevel a0)"""
        return _IMP_isd.Switching_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Switching self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_isd.Switching_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Switching self, FloatKey a0, bool a1)"""
        return _IMP_isd.Switching_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Switching self, FloatKey a0) -> bool"""
        return _IMP_isd.Switching_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Switching self) -> IMP::base::CheckLevel"""
        return _IMP_isd.Switching_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Switching self, Switching o) -> bool
        __eq__(Switching self, Particle d) -> bool
        """
        return _IMP_isd.Switching___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Switching self, Switching o) -> bool
        __ne__(Switching self, Particle d) -> bool
        """
        return _IMP_isd.Switching___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Switching self, Switching o) -> bool
        __le__(Switching self, Particle d) -> bool
        """
        return _IMP_isd.Switching___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Switching self, Switching o) -> bool
        __lt__(Switching self, Particle d) -> bool
        """
        return _IMP_isd.Switching___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Switching self, Switching o) -> bool
        __ge__(Switching self, Particle d) -> bool
        """
        return _IMP_isd.Switching___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Switching self, Switching o) -> bool
        __gt__(Switching self, Particle d) -> bool
        """
        return _IMP_isd.Switching___gt__(self, *args)

    def __str__(self):
        """__str__(Switching self) -> std::string"""
        return _IMP_isd.Switching___str__(self)

    def __repr__(self):
        """__repr__(Switching self) -> std::string"""
        return _IMP_isd.Switching___repr__(self)

    __swig_destroy__ = _IMP_isd.delete_Switching
    __del__ = lambda self : None;
Switching_swigregister = _IMP_isd.Switching_swigregister
Switching_swigregister(Switching)

def Switching_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Switching
    setup_particle(_ParticleAdaptor decorator) -> Switching
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, double switching) -> Switching
    Switching_setup_particle(_ParticleAdaptor decorator, double switching) -> Switching
    """
  return _IMP_isd.Switching_setup_particle(*args)

def Switching_get_is_setup(*args):
  """
    get_is_setup(_ParticleAdaptor p) -> bool
    Switching_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_isd.Switching_get_is_setup(*args)

def Switching_get_switching_key():
  """Switching_get_switching_key() -> FloatKey"""
  return _IMP_isd.Switching_get_switching_key()


def __lshift__(*args):
  """
    __lshift__(_ostream out, Nuisance n) -> _ostream
    __lshift__(_ostream out, Scale n) -> _ostream
    __lshift__(_ostream out, Switching n) -> _ostream
    """
  return _IMP_isd.__lshift__(*args)
class Weight(IMP.kernel.Decorator):
    """Proxy of C++ IMP::isd::Weight class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Weight, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Weight, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::Weight self) -> Weight
        __init__(IMP::isd::Weight self, Model m, ::IMP::kernel::ParticleIndex id) -> Weight
        __init__(IMP::isd::Weight self, _ParticleAdaptor d) -> Weight
        """
        this = _IMP_isd.new_Weight(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(Weight self, _ostream out=std::cout)
        show(Weight self)
        """
        return _IMP_isd.Weight_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Weight
        setup_particle(_ParticleAdaptor decorator) -> Weight
        """
        return _IMP_isd.Weight_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_nstates_key():
        """get_nstates_key() -> IntKey"""
        return _IMP_isd.Weight_get_nstates_key()

    if _newclass:get_nstates_key = staticmethod(get_nstates_key)
    __swig_getmethods__["get_nstates_key"] = lambda x: get_nstates_key
    def get_weight_key(*args):
        """get_weight_key(int i) -> FloatKey"""
        return _IMP_isd.Weight_get_weight_key(*args)

    if _newclass:get_weight_key = staticmethod(get_weight_key)
    __swig_getmethods__["get_weight_key"] = lambda x: get_weight_key
    def set_weights(self, *args):
        """set_weights(Weight self, VectorKD w)"""
        return _IMP_isd.Weight_set_weights(self, *args)

    def add_weight(self):
        """add_weight(Weight self)"""
        return _IMP_isd.Weight_add_weight(self)

    def get_weight(self, *args):
        """get_weight(Weight self, int i) -> IMP::Float"""
        return _IMP_isd.Weight_get_weight(self, *args)

    def get_weights(self):
        """get_weights(Weight self) -> VectorKD"""
        return _IMP_isd.Weight_get_weights(self)

    def set_weights_are_optimized(self, *args):
        """set_weights_are_optimized(Weight self, bool tf)"""
        return _IMP_isd.Weight_set_weights_are_optimized(self, *args)

    def get_number_of_states(self):
        """get_number_of_states(Weight self) -> IMP::Int"""
        return _IMP_isd.Weight_get_number_of_states(self)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        """
        return _IMP_isd.Weight_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    def add_attribute(self, *args):
        """
        add_attribute(Weight self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Weight self, FloatKey a0, IMP::Float a1)
        add_attribute(Weight self, IntKey a0, IMP::Int a1)
        add_attribute(Weight self, StringKey a0, IMP::String a1)
        add_attribute(Weight self, ParticleIndexKey a0, Particle a1)
        add_attribute(Weight self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Weight_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Weight self, FloatKey a0) -> IMP::Float
        get_value(Weight self, IntKey a0) -> IMP::Int
        get_value(Weight self, StringKey a0) -> IMP::String
        get_value(Weight self, ParticleIndexKey a0) -> Particle
        get_value(Weight self, ObjectKey a0) -> Object
        """
        return _IMP_isd.Weight_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Weight self, FloatKey a0, IMP::Float a1)
        set_value(Weight self, IntKey a0, IMP::Int a1)
        set_value(Weight self, StringKey a0, IMP::String a1)
        set_value(Weight self, ParticleIndexKey a0, Particle a1)
        set_value(Weight self, ObjectKey a0, Object a1)
        """
        return _IMP_isd.Weight_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Weight self, FloatKey a0)
        remove_attribute(Weight self, IntKey a0)
        remove_attribute(Weight self, StringKey a0)
        remove_attribute(Weight self, ParticleIndexKey a0)
        remove_attribute(Weight self, ObjectKey a0)
        """
        return _IMP_isd.Weight_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Weight self, FloatKey a0) -> bool
        has_attribute(Weight self, IntKey a0) -> bool
        has_attribute(Weight self, StringKey a0) -> bool
        has_attribute(Weight self, ParticleIndexKey a0) -> bool
        has_attribute(Weight self, ObjectKey a0) -> bool
        """
        return _IMP_isd.Weight_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Weight self, FloatKey a0) -> double"""
        return _IMP_isd.Weight_get_derivative(self, *args)

    def get_name(self):
        """get_name(Weight self) -> std::string"""
        return _IMP_isd.Weight_get_name(self)

    def clear_caches(self):
        """clear_caches(Weight self)"""
        return _IMP_isd.Weight_clear_caches(self)

    def set_name(self, *args):
        """set_name(Weight self, std::string a0)"""
        return _IMP_isd.Weight_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Weight self, IMP::base::CheckLevel a0)"""
        return _IMP_isd.Weight_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Weight self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_isd.Weight_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Weight self, FloatKey a0, bool a1)"""
        return _IMP_isd.Weight_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Weight self, FloatKey a0) -> bool"""
        return _IMP_isd.Weight_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Weight self) -> IMP::base::CheckLevel"""
        return _IMP_isd.Weight_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Weight self, Weight o) -> bool
        __eq__(Weight self, Particle d) -> bool
        """
        return _IMP_isd.Weight___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Weight self, Weight o) -> bool
        __ne__(Weight self, Particle d) -> bool
        """
        return _IMP_isd.Weight___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Weight self, Weight o) -> bool
        __le__(Weight self, Particle d) -> bool
        """
        return _IMP_isd.Weight___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Weight self, Weight o) -> bool
        __lt__(Weight self, Particle d) -> bool
        """
        return _IMP_isd.Weight___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Weight self, Weight o) -> bool
        __ge__(Weight self, Particle d) -> bool
        """
        return _IMP_isd.Weight___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Weight self, Weight o) -> bool
        __gt__(Weight self, Particle d) -> bool
        """
        return _IMP_isd.Weight___gt__(self, *args)

    def __str__(self):
        """__str__(Weight self) -> std::string"""
        return _IMP_isd.Weight___str__(self)

    def __repr__(self):
        """__repr__(Weight self) -> std::string"""
        return _IMP_isd.Weight___repr__(self)

    __swig_destroy__ = _IMP_isd.delete_Weight
    __del__ = lambda self : None;
Weight_swigregister = _IMP_isd.Weight_swigregister
Weight_swigregister(Weight)

def Weight_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Weight
    Weight_setup_particle(_ParticleAdaptor decorator) -> Weight
    """
  return _IMP_isd.Weight_setup_particle(*args)

def Weight_get_nstates_key():
  """Weight_get_nstates_key() -> IntKey"""
  return _IMP_isd.Weight_get_nstates_key()

def Weight_get_weight_key(*args):
  """Weight_get_weight_key(int i) -> FloatKey"""
  return _IMP_isd.Weight_get_weight_key(*args)

def Weight_get_is_setup(*args):
  """
    get_is_setup(_ParticleAdaptor p) -> bool
    Weight_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    """
  return _IMP_isd.Weight_get_is_setup(*args)

class JeffreysRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::JeffreysRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, JeffreysRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, JeffreysRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::JeffreysRestraint self, Model m, Particle p) -> JeffreysRestraint"""
        this = _IMP_isd.new_JeffreysRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(JeffreysRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.JeffreysRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(JeffreysRestraint self) -> VersionInfo"""
        return _IMP_isd.JeffreysRestraint_get_version_info(self)

    def get_probability(self):
        """get_probability(JeffreysRestraint self) -> double"""
        return _IMP_isd.JeffreysRestraint_get_probability(self)

    def __str__(self):
        """__str__(JeffreysRestraint self) -> std::string"""
        return _IMP_isd.JeffreysRestraint___str__(self)

    def __repr__(self):
        """__repr__(JeffreysRestraint self) -> std::string"""
        return _IMP_isd.JeffreysRestraint___repr__(self)

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

JeffreysRestraint_swigregister = _IMP_isd.JeffreysRestraint_swigregister
JeffreysRestraint_swigregister(JeffreysRestraint)

class FNormal(IMP.base.Object):
    """Proxy of C++ IMP::isd::FNormal class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FNormal, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FNormal, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::FNormal self, double FA, double JA, double FM, double sigma) -> FNormal"""
        this = _IMP_isd.new_FNormal(*args)
        try: self.this.append(this)
        except: self.this = this
    def evaluate(self):
        """evaluate(FNormal self) -> double"""
        return _IMP_isd.FNormal_evaluate(self)

    def evaluate_derivative_FA(self):
        """evaluate_derivative_FA(FNormal self) -> double"""
        return _IMP_isd.FNormal_evaluate_derivative_FA(self)

    def evaluate_derivative_JA(self):
        """evaluate_derivative_JA(FNormal self) -> double"""
        return _IMP_isd.FNormal_evaluate_derivative_JA(self)

    def evaluate_derivative_FM(self):
        """evaluate_derivative_FM(FNormal self) -> double"""
        return _IMP_isd.FNormal_evaluate_derivative_FM(self)

    def evaluate_derivative_sigma(self):
        """evaluate_derivative_sigma(FNormal self) -> double"""
        return _IMP_isd.FNormal_evaluate_derivative_sigma(self)

    def density(self):
        """density(FNormal self) -> double"""
        return _IMP_isd.FNormal_density(self)

    def set_FA(self, *args):
        """set_FA(FNormal self, double f)"""
        return _IMP_isd.FNormal_set_FA(self, *args)

    def set_JA(self, *args):
        """set_JA(FNormal self, double f)"""
        return _IMP_isd.FNormal_set_JA(self, *args)

    def set_FM(self, *args):
        """set_FM(FNormal self, double f)"""
        return _IMP_isd.FNormal_set_FM(self, *args)

    def set_sigma(self, *args):
        """set_sigma(FNormal self, double f)"""
        return _IMP_isd.FNormal_set_sigma(self, *args)

    def get_version_info(self):
        """get_version_info(FNormal self) -> VersionInfo"""
        return _IMP_isd.FNormal_get_version_info(self)

    def __str__(self):
        """__str__(FNormal self) -> std::string"""
        return _IMP_isd.FNormal___str__(self)

    def __repr__(self):
        """__repr__(FNormal self) -> std::string"""
        return _IMP_isd.FNormal___repr__(self)

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

FNormal_swigregister = _IMP_isd.FNormal_swigregister
FNormal_swigregister(FNormal)

class vonMises(IMP.base.Object):
    """Proxy of C++ IMP::isd::vonMises class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, vonMises, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, vonMises, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::vonMises self, double x, double mu, double kappa) -> vonMises"""
        this = _IMP_isd.new_vonMises(*args)
        try: self.this.append(this)
        except: self.this = this
    def evaluate(self):
        """evaluate(vonMises self) -> double"""
        return _IMP_isd.vonMises_evaluate(self)

    def evaluate_derivative_x(self):
        """evaluate_derivative_x(vonMises self) -> double"""
        return _IMP_isd.vonMises_evaluate_derivative_x(self)

    def evaluate_derivative_mu(self):
        """evaluate_derivative_mu(vonMises self) -> double"""
        return _IMP_isd.vonMises_evaluate_derivative_mu(self)

    def evaluate_derivative_kappa(self):
        """evaluate_derivative_kappa(vonMises self) -> double"""
        return _IMP_isd.vonMises_evaluate_derivative_kappa(self)

    def density(self):
        """density(vonMises self) -> double"""
        return _IMP_isd.vonMises_density(self)

    def set_x(self, *args):
        """set_x(vonMises self, double x)"""
        return _IMP_isd.vonMises_set_x(self, *args)

    def set_mu(self, *args):
        """set_mu(vonMises self, double mu)"""
        return _IMP_isd.vonMises_set_mu(self, *args)

    def set_kappa(self, *args):
        """set_kappa(vonMises self, double kappa)"""
        return _IMP_isd.vonMises_set_kappa(self, *args)

    def get_version_info(self):
        """get_version_info(vonMises self) -> VersionInfo"""
        return _IMP_isd.vonMises_get_version_info(self)

    def __str__(self):
        """__str__(vonMises self) -> std::string"""
        return _IMP_isd.vonMises___str__(self)

    def __repr__(self):
        """__repr__(vonMises self) -> std::string"""
        return _IMP_isd.vonMises___repr__(self)

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

vonMises_swigregister = _IMP_isd.vonMises_swigregister
vonMises_swigregister(vonMises)

class vonMisesSufficient(IMP.base.Object):
    """Proxy of C++ IMP::isd::vonMisesSufficient class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, vonMisesSufficient, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, vonMisesSufficient, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::vonMisesSufficient self, double chi, unsigned int N, double R0, double chiexp, double kappa) -> vonMisesSufficient
        __init__(IMP::isd::vonMisesSufficient self, double chi, IMP::Floats obs, double kappa) -> vonMisesSufficient
        """
        this = _IMP_isd.new_vonMisesSufficient(*args)
        try: self.this.append(this)
        except: self.this = this
    def evaluate(self):
        """evaluate(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_evaluate(self)

    def evaluate_derivative_x(self):
        """evaluate_derivative_x(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_evaluate_derivative_x(self)

    def evaluate_derivative_kappa(self):
        """evaluate_derivative_kappa(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_evaluate_derivative_kappa(self)

    def density(self):
        """density(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_density(self)

    def get_x(self):
        """get_x(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_get_x(self)

    def get_R0(self):
        """get_R0(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_get_R0(self)

    def get_chiexp(self):
        """get_chiexp(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_get_chiexp(self)

    def get_N(self):
        """get_N(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_get_N(self)

    def get_kappa(self):
        """get_kappa(vonMisesSufficient self) -> double"""
        return _IMP_isd.vonMisesSufficient_get_kappa(self)

    def set_x(self, *args):
        """set_x(vonMisesSufficient self, double x)"""
        return _IMP_isd.vonMisesSufficient_set_x(self, *args)

    def set_R0(self, *args):
        """set_R0(vonMisesSufficient self, double R0)"""
        return _IMP_isd.vonMisesSufficient_set_R0(self, *args)

    def set_chiexp(self, *args):
        """set_chiexp(vonMisesSufficient self, double chiexp)"""
        return _IMP_isd.vonMisesSufficient_set_chiexp(self, *args)

    def set_N(self, *args):
        """set_N(vonMisesSufficient self, unsigned int N)"""
        return _IMP_isd.vonMisesSufficient_set_N(self, *args)

    def set_kappa(self, *args):
        """set_kappa(vonMisesSufficient self, double kappa)"""
        return _IMP_isd.vonMisesSufficient_set_kappa(self, *args)

    def get_sufficient_statistics(*args):
        """get_sufficient_statistics(IMP::Floats data) -> IMP::Floats"""
        return _IMP_isd.vonMisesSufficient_get_sufficient_statistics(*args)

    if _newclass:get_sufficient_statistics = staticmethod(get_sufficient_statistics)
    __swig_getmethods__["get_sufficient_statistics"] = lambda x: get_sufficient_statistics
    def get_version_info(self):
        """get_version_info(vonMisesSufficient self) -> VersionInfo"""
        return _IMP_isd.vonMisesSufficient_get_version_info(self)

    def __str__(self):
        """__str__(vonMisesSufficient self) -> std::string"""
        return _IMP_isd.vonMisesSufficient___str__(self)

    def __repr__(self):
        """__repr__(vonMisesSufficient self) -> std::string"""
        return _IMP_isd.vonMisesSufficient___repr__(self)

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

vonMisesSufficient_swigregister = _IMP_isd.vonMisesSufficient_swigregister
vonMisesSufficient_swigregister(vonMisesSufficient)

def vonMisesSufficient_get_sufficient_statistics(*args):
  """vonMisesSufficient_get_sufficient_statistics(IMP::Floats data) -> IMP::Floats"""
  return _IMP_isd.vonMisesSufficient_get_sufficient_statistics(*args)

class vonMisesKappaJeffreysRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::vonMisesKappaJeffreysRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, vonMisesKappaJeffreysRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, vonMisesKappaJeffreysRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::vonMisesKappaJeffreysRestraint self, Model m, Particle kappa) -> vonMisesKappaJeffreysRestraint"""
        this = _IMP_isd.new_vonMisesKappaJeffreysRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(vonMisesKappaJeffreysRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.vonMisesKappaJeffreysRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(vonMisesKappaJeffreysRestraint self) -> VersionInfo"""
        return _IMP_isd.vonMisesKappaJeffreysRestraint_get_version_info(self)

    def get_probability(self):
        """get_probability(vonMisesKappaJeffreysRestraint self) -> double"""
        return _IMP_isd.vonMisesKappaJeffreysRestraint_get_probability(self)

    def __str__(self):
        """__str__(vonMisesKappaJeffreysRestraint self) -> std::string"""
        return _IMP_isd.vonMisesKappaJeffreysRestraint___str__(self)

    def __repr__(self):
        """__repr__(vonMisesKappaJeffreysRestraint self) -> std::string"""
        return _IMP_isd.vonMisesKappaJeffreysRestraint___repr__(self)

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

vonMisesKappaJeffreysRestraint_swigregister = _IMP_isd.vonMisesKappaJeffreysRestraint_swigregister
vonMisesKappaJeffreysRestraint_swigregister(vonMisesKappaJeffreysRestraint)

class vonMisesKappaConjugateRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::vonMisesKappaConjugateRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, vonMisesKappaConjugateRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, vonMisesKappaConjugateRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::vonMisesKappaConjugateRestraint self, Model m, Particle kappa, double c=10.0, double R0=0.0) -> vonMisesKappaConjugateRestraint
        __init__(IMP::isd::vonMisesKappaConjugateRestraint self, Model m, Particle kappa, double c=10.0) -> vonMisesKappaConjugateRestraint
        __init__(IMP::isd::vonMisesKappaConjugateRestraint self, Model m, Particle kappa) -> vonMisesKappaConjugateRestraint
        """
        this = _IMP_isd.new_vonMisesKappaConjugateRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(vonMisesKappaConjugateRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.vonMisesKappaConjugateRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(vonMisesKappaConjugateRestraint self) -> VersionInfo"""
        return _IMP_isd.vonMisesKappaConjugateRestraint_get_version_info(self)

    def get_probability(self):
        """get_probability(vonMisesKappaConjugateRestraint self) -> double"""
        return _IMP_isd.vonMisesKappaConjugateRestraint_get_probability(self)

    def __str__(self):
        """__str__(vonMisesKappaConjugateRestraint self) -> std::string"""
        return _IMP_isd.vonMisesKappaConjugateRestraint___str__(self)

    def __repr__(self):
        """__repr__(vonMisesKappaConjugateRestraint self) -> std::string"""
        return _IMP_isd.vonMisesKappaConjugateRestraint___repr__(self)

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

vonMisesKappaConjugateRestraint_swigregister = _IMP_isd.vonMisesKappaConjugateRestraint_swigregister
vonMisesKappaConjugateRestraint_swigregister(vonMisesKappaConjugateRestraint)

class NOERestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::NOERestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NOERestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NOERestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::NOERestraint self, Model m, Particle p0, Particle p1, Particle sigma, Particle gamma, double Iexp) -> NOERestraint"""
        this = _IMP_isd.new_NOERestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(NOERestraint self) -> double"""
        return _IMP_isd.NOERestraint_get_probability(self)

    def get_chi(self):
        """get_chi(NOERestraint self) -> double"""
        return _IMP_isd.NOERestraint_get_chi(self)

    def do_get_inputs(self):
        """do_get_inputs(NOERestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.NOERestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(NOERestraint self) -> VersionInfo"""
        return _IMP_isd.NOERestraint_get_version_info(self)

    def __str__(self):
        """__str__(NOERestraint self) -> std::string"""
        return _IMP_isd.NOERestraint___str__(self)

    def __repr__(self):
        """__repr__(NOERestraint self) -> std::string"""
        return _IMP_isd.NOERestraint___repr__(self)

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

NOERestraint_swigregister = _IMP_isd.NOERestraint_swigregister
NOERestraint_swigregister(NOERestraint)

class GaussianRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::GaussianRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GaussianRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GaussianRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::GaussianRestraint self, Particle x, Particle mu, Particle sigma) -> GaussianRestraint
        __init__(IMP::isd::GaussianRestraint self, double x, Particle mu, Particle sigma) -> GaussianRestraint
        __init__(IMP::isd::GaussianRestraint self, Particle x, double mu, Particle sigma) -> GaussianRestraint
        __init__(IMP::isd::GaussianRestraint self, Particle x, Particle mu, double sigma) -> GaussianRestraint
        __init__(IMP::isd::GaussianRestraint self, double x, double mu, Particle sigma) -> GaussianRestraint
        __init__(IMP::isd::GaussianRestraint self, Particle x, double mu, double sigma) -> GaussianRestraint
        __init__(IMP::isd::GaussianRestraint self, double x, Particle mu, double sigma) -> GaussianRestraint
        """
        this = _IMP_isd.new_GaussianRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(GaussianRestraint self) -> double"""
        return _IMP_isd.GaussianRestraint_get_probability(self)

    def get_chi(self):
        """get_chi(GaussianRestraint self) -> double"""
        return _IMP_isd.GaussianRestraint_get_chi(self)

    def do_get_inputs(self):
        """do_get_inputs(GaussianRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.GaussianRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(GaussianRestraint self) -> VersionInfo"""
        return _IMP_isd.GaussianRestraint_get_version_info(self)

    def __str__(self):
        """__str__(GaussianRestraint self) -> std::string"""
        return _IMP_isd.GaussianRestraint___str__(self)

    def __repr__(self):
        """__repr__(GaussianRestraint self) -> std::string"""
        return _IMP_isd.GaussianRestraint___repr__(self)

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

GaussianRestraint_swigregister = _IMP_isd.GaussianRestraint_swigregister
GaussianRestraint_swigregister(GaussianRestraint)

class LognormalRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::LognormalRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LognormalRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LognormalRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::LognormalRestraint self, Particle x, Particle mu, Particle sigma) -> LognormalRestraint
        __init__(IMP::isd::LognormalRestraint self, double x, Particle mu, Particle sigma) -> LognormalRestraint
        __init__(IMP::isd::LognormalRestraint self, Particle x, double mu, Particle sigma) -> LognormalRestraint
        __init__(IMP::isd::LognormalRestraint self, Particle x, Particle mu, double sigma) -> LognormalRestraint
        __init__(IMP::isd::LognormalRestraint self, double x, double mu, Particle sigma) -> LognormalRestraint
        __init__(IMP::isd::LognormalRestraint self, Particle x, double mu, double sigma) -> LognormalRestraint
        __init__(IMP::isd::LognormalRestraint self, double x, Particle mu, double sigma) -> LognormalRestraint
        """
        this = _IMP_isd.new_LognormalRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(LognormalRestraint self) -> double"""
        return _IMP_isd.LognormalRestraint_get_probability(self)

    def get_chi(self):
        """get_chi(LognormalRestraint self) -> double"""
        return _IMP_isd.LognormalRestraint_get_chi(self)

    def do_get_inputs(self):
        """do_get_inputs(LognormalRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.LognormalRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(LognormalRestraint self) -> VersionInfo"""
        return _IMP_isd.LognormalRestraint_get_version_info(self)

    def __str__(self):
        """__str__(LognormalRestraint self) -> std::string"""
        return _IMP_isd.LognormalRestraint___str__(self)

    def __repr__(self):
        """__repr__(LognormalRestraint self) -> std::string"""
        return _IMP_isd.LognormalRestraint___repr__(self)

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

LognormalRestraint_swigregister = _IMP_isd.LognormalRestraint_swigregister
LognormalRestraint_swigregister(LognormalRestraint)

class AmbiguousNOERestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::AmbiguousNOERestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AmbiguousNOERestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AmbiguousNOERestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::AmbiguousNOERestraint self, Model m, PairContainer pc, Particle sigma, Particle gamma, double Iexp) -> AmbiguousNOERestraint"""
        this = _IMP_isd.new_AmbiguousNOERestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(AmbiguousNOERestraint self) -> double"""
        return _IMP_isd.AmbiguousNOERestraint_get_probability(self)

    def get_chi(self):
        """get_chi(AmbiguousNOERestraint self) -> double"""
        return _IMP_isd.AmbiguousNOERestraint_get_chi(self)

    def do_get_inputs(self):
        """do_get_inputs(AmbiguousNOERestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.AmbiguousNOERestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(AmbiguousNOERestraint self) -> VersionInfo"""
        return _IMP_isd.AmbiguousNOERestraint_get_version_info(self)

    def __str__(self):
        """__str__(AmbiguousNOERestraint self) -> std::string"""
        return _IMP_isd.AmbiguousNOERestraint___str__(self)

    def __repr__(self):
        """__repr__(AmbiguousNOERestraint self) -> std::string"""
        return _IMP_isd.AmbiguousNOERestraint___repr__(self)

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

AmbiguousNOERestraint_swigregister = _IMP_isd.AmbiguousNOERestraint_swigregister
AmbiguousNOERestraint_swigregister(AmbiguousNOERestraint)

class MarginalNOERestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::MarginalNOERestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MarginalNOERestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MarginalNOERestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::MarginalNOERestraint self, Model m) -> MarginalNOERestraint"""
        this = _IMP_isd.new_MarginalNOERestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_contribution(self, *args):
        """
        add_contribution(MarginalNOERestraint self, Particle p1, Particle p2, double Iexp)
        add_contribution(MarginalNOERestraint self, PairContainer pc, double Iexp)
        """
        return _IMP_isd.MarginalNOERestraint_add_contribution(self, *args)

    def get_log_gammahat(self):
        """get_log_gammahat(MarginalNOERestraint self) -> double"""
        return _IMP_isd.MarginalNOERestraint_get_log_gammahat(self)

    def get_SS(self):
        """get_SS(MarginalNOERestraint self) -> double"""
        return _IMP_isd.MarginalNOERestraint_get_SS(self)

    def get_number_of_contributions(self):
        """get_number_of_contributions(MarginalNOERestraint self) -> unsigned int"""
        return _IMP_isd.MarginalNOERestraint_get_number_of_contributions(self)

    def get_probability(self):
        """get_probability(MarginalNOERestraint self) -> double"""
        return _IMP_isd.MarginalNOERestraint_get_probability(self)

    def do_get_inputs(self):
        """do_get_inputs(MarginalNOERestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.MarginalNOERestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MarginalNOERestraint self) -> VersionInfo"""
        return _IMP_isd.MarginalNOERestraint_get_version_info(self)

    def __str__(self):
        """__str__(MarginalNOERestraint self) -> std::string"""
        return _IMP_isd.MarginalNOERestraint___str__(self)

    def __repr__(self):
        """__repr__(MarginalNOERestraint self) -> std::string"""
        return _IMP_isd.MarginalNOERestraint___repr__(self)

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

MarginalNOERestraint_swigregister = _IMP_isd.MarginalNOERestraint_swigregister
MarginalNOERestraint_swigregister(MarginalNOERestraint)

class MarginalHBondRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::MarginalHBondRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MarginalHBondRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MarginalHBondRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::MarginalHBondRestraint self, Model m) -> MarginalHBondRestraint"""
        this = _IMP_isd.new_MarginalHBondRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_contribution(self, *args):
        """
        add_contribution(MarginalHBondRestraint self, Particle p1, Particle p2, double Iexp)
        add_contribution(MarginalHBondRestraint self, PairContainer pc, double Iexp)
        """
        return _IMP_isd.MarginalHBondRestraint_add_contribution(self, *args)

    def get_logsquares(self):
        """get_logsquares(MarginalHBondRestraint self) -> double"""
        return _IMP_isd.MarginalHBondRestraint_get_logsquares(self)

    def get_number_of_contributions(self):
        """get_number_of_contributions(MarginalHBondRestraint self) -> unsigned int"""
        return _IMP_isd.MarginalHBondRestraint_get_number_of_contributions(self)

    def get_probability(self):
        """get_probability(MarginalHBondRestraint self) -> double"""
        return _IMP_isd.MarginalHBondRestraint_get_probability(self)

    def do_get_inputs(self):
        """do_get_inputs(MarginalHBondRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.MarginalHBondRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MarginalHBondRestraint self) -> VersionInfo"""
        return _IMP_isd.MarginalHBondRestraint_get_version_info(self)

    def __str__(self):
        """__str__(MarginalHBondRestraint self) -> std::string"""
        return _IMP_isd.MarginalHBondRestraint___str__(self)

    def __repr__(self):
        """__repr__(MarginalHBondRestraint self) -> std::string"""
        return _IMP_isd.MarginalHBondRestraint___repr__(self)

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

MarginalHBondRestraint_swigregister = _IMP_isd.MarginalHBondRestraint_swigregister
MarginalHBondRestraint_swigregister(MarginalHBondRestraint)

class TALOSRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::TALOSRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TALOSRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TALOSRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::TALOSRestraint self, Model m, IMP::kernel::Particles p, IMP::Floats data, Particle kappa) -> TALOSRestraint
        __init__(IMP::isd::TALOSRestraint self, Model m, Particle p1, Particle p2, Particle p3, Particle p4, IMP::Floats data, Particle kappa) -> TALOSRestraint
        __init__(IMP::isd::TALOSRestraint self, Model m, IMP::kernel::Particles p, unsigned int N, double R0, double chiexp, Particle kappa) -> TALOSRestraint
        __init__(IMP::isd::TALOSRestraint self, Model m, Particle p1, Particle p2, Particle p3, Particle p4, unsigned int N, double R0, 
            double chiexp, Particle kappa) -> TALOSRestraint
        """
        this = _IMP_isd.new_TALOSRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(TALOSRestraint self) -> double"""
        return _IMP_isd.TALOSRestraint_get_probability(self)

    def get_R0(self):
        """get_R0(TALOSRestraint self) -> double"""
        return _IMP_isd.TALOSRestraint_get_R0(self)

    def get_chiexp(self):
        """get_chiexp(TALOSRestraint self) -> double"""
        return _IMP_isd.TALOSRestraint_get_chiexp(self)

    def do_get_inputs(self):
        """do_get_inputs(TALOSRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.TALOSRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(TALOSRestraint self) -> VersionInfo"""
        return _IMP_isd.TALOSRestraint_get_version_info(self)

    def __str__(self):
        """__str__(TALOSRestraint self) -> std::string"""
        return _IMP_isd.TALOSRestraint___str__(self)

    def __repr__(self):
        """__repr__(TALOSRestraint self) -> std::string"""
        return _IMP_isd.TALOSRestraint___repr__(self)

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

TALOSRestraint_swigregister = _IMP_isd.TALOSRestraint_swigregister
TALOSRestraint_swigregister(TALOSRestraint)

class RepulsiveDistancePairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::isd::RepulsiveDistancePairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RepulsiveDistancePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RepulsiveDistancePairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::RepulsiveDistancePairScore self, double d0, double k) -> RepulsiveDistancePairScore"""
        this = _IMP_isd.new_RepulsiveDistancePairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_rest_length(self):
        """get_rest_length(RepulsiveDistancePairScore self) -> double"""
        return _IMP_isd.RepulsiveDistancePairScore_get_rest_length(self)

    def get_stiffness(self):
        """get_stiffness(RepulsiveDistancePairScore self) -> double"""
        return _IMP_isd.RepulsiveDistancePairScore_get_stiffness(self)

    def do_get_inputs(self, *args):
        """do_get_inputs(RepulsiveDistancePairScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.RepulsiveDistancePairScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(RepulsiveDistancePairScore self) -> VersionInfo"""
        return _IMP_isd.RepulsiveDistancePairScore_get_version_info(self)

    def __str__(self):
        """__str__(RepulsiveDistancePairScore self) -> std::string"""
        return _IMP_isd.RepulsiveDistancePairScore___str__(self)

    def __repr__(self):
        """__repr__(RepulsiveDistancePairScore self) -> std::string"""
        return _IMP_isd.RepulsiveDistancePairScore___repr__(self)

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

RepulsiveDistancePairScore_swigregister = _IMP_isd.RepulsiveDistancePairScore_swigregister
RepulsiveDistancePairScore_swigregister(RepulsiveDistancePairScore)

class AmbiguousRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::AmbiguousRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AmbiguousRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AmbiguousRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::AmbiguousRestraint self, Model m, int d, Restraint r0, Restraint r1) -> AmbiguousRestraint
        __init__(IMP::isd::AmbiguousRestraint self, Model m, int d, IMP::kernel::Restraints rs) -> AmbiguousRestraint
        """
        this = _IMP_isd.new_AmbiguousRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(AmbiguousRestraint self) -> double"""
        return _IMP_isd.AmbiguousRestraint_get_probability(self)

    def do_get_inputs(self):
        """do_get_inputs(AmbiguousRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.AmbiguousRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(AmbiguousRestraint self) -> VersionInfo"""
        return _IMP_isd.AmbiguousRestraint_get_version_info(self)

    def __str__(self):
        """__str__(AmbiguousRestraint self) -> std::string"""
        return _IMP_isd.AmbiguousRestraint___str__(self)

    def __repr__(self):
        """__repr__(AmbiguousRestraint self) -> std::string"""
        return _IMP_isd.AmbiguousRestraint___repr__(self)

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

AmbiguousRestraint_swigregister = _IMP_isd.AmbiguousRestraint_swigregister
AmbiguousRestraint_swigregister(AmbiguousRestraint)

IMP_ISD_UNIVARIATE_FUNCTIONS_MINIMUM = _IMP_isd.IMP_ISD_UNIVARIATE_FUNCTIONS_MINIMUM
class UnivariateFunction(IMP.base.Object):
    """Proxy of C++ IMP::isd::UnivariateFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnivariateFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UnivariateFunction, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def __call__(self, *args):
        """
        __call__(UnivariateFunction self, IMP::Floats const & x) -> IMP::Floats
        __call__(UnivariateFunction self, IMP::FloatsList const & xlist) -> IMP_Eigen::VectorXd
        __call__(UnivariateFunction self, IMP::FloatsList const & xlist, bool stupid) -> IMP::FloatsList
        """
        return _IMP_isd.UnivariateFunction___call__(self, *args)

    def has_changed(self):
        """has_changed(UnivariateFunction self) -> bool"""
        return _IMP_isd.UnivariateFunction_has_changed(self)

    def update(self):
        """update(UnivariateFunction self)"""
        return _IMP_isd.UnivariateFunction_update(self)

    def add_to_derivatives(self, *args):
        """add_to_derivatives(UnivariateFunction self, IMP::Floats const & x, DerivativeAccumulator accum)"""
        return _IMP_isd.UnivariateFunction_add_to_derivatives(self, *args)

    def add_to_particle_derivative(self, *args):
        """add_to_particle_derivative(UnivariateFunction self, unsigned int particle_no, double value, DerivativeAccumulator accum)"""
        return _IMP_isd.UnivariateFunction_add_to_particle_derivative(self, *args)

    def get_derivative_vector(self, *args):
        """get_derivative_vector(UnivariateFunction self, unsigned int particle_no, IMP::FloatsList const & xlist) -> IMP_Eigen::VectorXd"""
        return _IMP_isd.UnivariateFunction_get_derivative_vector(self, *args)

    def get_derivative_matrix(self, *args):
        """get_derivative_matrix(UnivariateFunction self, IMP::FloatsList const & xlist, bool stupid) -> IMP::FloatsList"""
        return _IMP_isd.UnivariateFunction_get_derivative_matrix(self, *args)

    def get_second_derivative_vector(self, *args):
        """
        get_second_derivative_vector(UnivariateFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist) -> IMP_Eigen::VectorXd
        get_second_derivative_vector(UnivariateFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist, 
            bool stupid) -> IMP::FloatsList
        """
        return _IMP_isd.UnivariateFunction_get_second_derivative_vector(self, *args)

    def get_ndims_x(self):
        """get_ndims_x(UnivariateFunction self) -> unsigned int"""
        return _IMP_isd.UnivariateFunction_get_ndims_x(self)

    def get_ndims_y(self):
        """get_ndims_y(UnivariateFunction self) -> unsigned int"""
        return _IMP_isd.UnivariateFunction_get_ndims_y(self)

    def get_number_of_particles(self):
        """get_number_of_particles(UnivariateFunction self) -> unsigned int"""
        return _IMP_isd.UnivariateFunction_get_number_of_particles(self)

    def get_particle_is_optimized(self, *args):
        """get_particle_is_optimized(UnivariateFunction self, unsigned int particle_no) -> bool"""
        return _IMP_isd.UnivariateFunction_get_particle_is_optimized(self, *args)

    def get_number_of_optimized_particles(self):
        """get_number_of_optimized_particles(UnivariateFunction self) -> unsigned int"""
        return _IMP_isd.UnivariateFunction_get_number_of_optimized_particles(self)

    def get_input_particles(self):
        """get_input_particles(UnivariateFunction self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_isd.UnivariateFunction_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(UnivariateFunction self) -> IMP::kernel::ContainersTemp"""
        return _IMP_isd.UnivariateFunction_get_input_containers(self)

    __swig_destroy__ = _IMP_isd.delete_UnivariateFunction
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(UnivariateFunction self) -> std::string"""
        return _IMP_isd.UnivariateFunction___str__(self)

    def __repr__(self):
        """__repr__(UnivariateFunction self) -> std::string"""
        return _IMP_isd.UnivariateFunction___repr__(self)

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

UnivariateFunction_swigregister = _IMP_isd.UnivariateFunction_swigregister
UnivariateFunction_swigregister(UnivariateFunction)

class Linear1DFunction(UnivariateFunction):
    """Proxy of C++ IMP::isd::Linear1DFunction class"""
    __swig_setmethods__ = {}
    for _s in [UnivariateFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Linear1DFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [UnivariateFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Linear1DFunction, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::Linear1DFunction self, Particle a, Particle b) -> Linear1DFunction"""
        this = _IMP_isd.new_Linear1DFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args):
        """
        __call__(Linear1DFunction self, IMP::Floats const & x) -> IMP::Floats
        __call__(Linear1DFunction self, IMP::FloatsList const & xlist) -> IMP_Eigen::VectorXd
        __call__(Linear1DFunction self, IMP::FloatsList const & xlist, bool arg3) -> IMP::FloatsList
        """
        return _IMP_isd.Linear1DFunction___call__(self, *args)

    def get_second_derivative_vector(self, *args):
        """
        get_second_derivative_vector(Linear1DFunction self, unsigned int arg2, unsigned int arg3, IMP::FloatsList const & xlist) -> IMP_Eigen::VectorXd
        get_second_derivative_vector(Linear1DFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist, 
            bool arg5) -> IMP::FloatsList
        """
        return _IMP_isd.Linear1DFunction_get_second_derivative_vector(self, *args)

    def get_version_info(self):
        """get_version_info(Linear1DFunction self) -> VersionInfo"""
        return _IMP_isd.Linear1DFunction_get_version_info(self)

    def __str__(self):
        """__str__(Linear1DFunction self) -> std::string"""
        return _IMP_isd.Linear1DFunction___str__(self)

    def __repr__(self):
        """__repr__(Linear1DFunction self) -> std::string"""
        return _IMP_isd.Linear1DFunction___repr__(self)

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

Linear1DFunction_swigregister = _IMP_isd.Linear1DFunction_swigregister
Linear1DFunction_swigregister(Linear1DFunction)

class GeneralizedGuinierPorodFunction(UnivariateFunction):
    """Proxy of C++ IMP::isd::GeneralizedGuinierPorodFunction class"""
    __swig_setmethods__ = {}
    for _s in [UnivariateFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeneralizedGuinierPorodFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [UnivariateFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeneralizedGuinierPorodFunction, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::GeneralizedGuinierPorodFunction self, Particle G, Particle Rg, Particle d, Particle s, Particle A) -> GeneralizedGuinierPorodFunction"""
        this = _IMP_isd.new_GeneralizedGuinierPorodFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args):
        """
        __call__(GeneralizedGuinierPorodFunction self, IMP::Floats const & x) -> IMP::Floats
        __call__(GeneralizedGuinierPorodFunction self, IMP::FloatsList const & xlist) -> IMP_Eigen::VectorXd
        __call__(GeneralizedGuinierPorodFunction self, IMP::FloatsList const & xlist, bool arg3) -> IMP::FloatsList
        """
        return _IMP_isd.GeneralizedGuinierPorodFunction___call__(self, *args)

    def get_second_derivative_vector(self, *args):
        """
        get_second_derivative_vector(GeneralizedGuinierPorodFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist) -> IMP_Eigen::VectorXd
        get_second_derivative_vector(GeneralizedGuinierPorodFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist, 
            bool arg5) -> IMP::FloatsList
        """
        return _IMP_isd.GeneralizedGuinierPorodFunction_get_second_derivative_vector(self, *args)

    def get_version_info(self):
        """get_version_info(GeneralizedGuinierPorodFunction self) -> VersionInfo"""
        return _IMP_isd.GeneralizedGuinierPorodFunction_get_version_info(self)

    def __str__(self):
        """__str__(GeneralizedGuinierPorodFunction self) -> std::string"""
        return _IMP_isd.GeneralizedGuinierPorodFunction___str__(self)

    def __repr__(self):
        """__repr__(GeneralizedGuinierPorodFunction self) -> std::string"""
        return _IMP_isd.GeneralizedGuinierPorodFunction___repr__(self)

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

GeneralizedGuinierPorodFunction_swigregister = _IMP_isd.GeneralizedGuinierPorodFunction_swigregister
GeneralizedGuinierPorodFunction_swigregister(GeneralizedGuinierPorodFunction)

IMP_ISD_BIVARIATE_FUNCTIONS_MINIMUM = _IMP_isd.IMP_ISD_BIVARIATE_FUNCTIONS_MINIMUM
class BivariateFunction(IMP.base.Object):
    """Proxy of C++ IMP::isd::BivariateFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BivariateFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BivariateFunction, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def __call__(self, *args):
        """
        __call__(BivariateFunction self, IMP::Floats const & x1, IMP::Floats const & x2) -> IMP::Floats
        __call__(BivariateFunction self, IMP::FloatsList const & xlist) -> IMP_Eigen::MatrixXd
        __call__(BivariateFunction self, IMP::FloatsList const & xlist, bool stupid) -> IMP::FloatsList
        """
        return _IMP_isd.BivariateFunction___call__(self, *args)

    def has_changed(self):
        """has_changed(BivariateFunction self) -> bool"""
        return _IMP_isd.BivariateFunction_has_changed(self)

    def update(self):
        """update(BivariateFunction self)"""
        return _IMP_isd.BivariateFunction_update(self)

    def add_to_derivatives(self, *args):
        """add_to_derivatives(BivariateFunction self, IMP::Floats const & x1, IMP::Floats const & x2, DerivativeAccumulator accum)"""
        return _IMP_isd.BivariateFunction_add_to_derivatives(self, *args)

    def add_to_particle_derivative(self, *args):
        """add_to_particle_derivative(BivariateFunction self, unsigned int particle_no, double value, DerivativeAccumulator accum)"""
        return _IMP_isd.BivariateFunction_add_to_particle_derivative(self, *args)

    def get_derivative_matrix(self, *args):
        """
        get_derivative_matrix(BivariateFunction self, unsigned int particle_no, IMP::FloatsList const & xlist) -> IMP_Eigen::MatrixXd
        get_derivative_matrix(BivariateFunction self, unsigned int particle_no, IMP::FloatsList const & xlist, bool stupid) -> IMP::FloatsList
        """
        return _IMP_isd.BivariateFunction_get_derivative_matrix(self, *args)

    def get_second_derivative_matrix(self, *args):
        """
        get_second_derivative_matrix(BivariateFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist) -> IMP_Eigen::MatrixXd
        get_second_derivative_matrix(BivariateFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist, 
            bool stupid) -> IMP::FloatsList
        """
        return _IMP_isd.BivariateFunction_get_second_derivative_matrix(self, *args)

    def get_ndims_x1(self):
        """get_ndims_x1(BivariateFunction self) -> unsigned int"""
        return _IMP_isd.BivariateFunction_get_ndims_x1(self)

    def get_ndims_x2(self):
        """get_ndims_x2(BivariateFunction self) -> unsigned int"""
        return _IMP_isd.BivariateFunction_get_ndims_x2(self)

    def get_ndims_y(self):
        """get_ndims_y(BivariateFunction self) -> unsigned int"""
        return _IMP_isd.BivariateFunction_get_ndims_y(self)

    def get_number_of_particles(self):
        """get_number_of_particles(BivariateFunction self) -> unsigned int"""
        return _IMP_isd.BivariateFunction_get_number_of_particles(self)

    def get_particle_is_optimized(self, *args):
        """get_particle_is_optimized(BivariateFunction self, unsigned int particle_no) -> bool"""
        return _IMP_isd.BivariateFunction_get_particle_is_optimized(self, *args)

    def get_number_of_optimized_particles(self):
        """get_number_of_optimized_particles(BivariateFunction self) -> unsigned int"""
        return _IMP_isd.BivariateFunction_get_number_of_optimized_particles(self)

    def get_input_particles(self):
        """get_input_particles(BivariateFunction self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_isd.BivariateFunction_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(BivariateFunction self) -> IMP::kernel::ContainersTemp"""
        return _IMP_isd.BivariateFunction_get_input_containers(self)

    __swig_destroy__ = _IMP_isd.delete_BivariateFunction
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(BivariateFunction self) -> std::string"""
        return _IMP_isd.BivariateFunction___str__(self)

    def __repr__(self):
        """__repr__(BivariateFunction self) -> std::string"""
        return _IMP_isd.BivariateFunction___repr__(self)

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

BivariateFunction_swigregister = _IMP_isd.BivariateFunction_swigregister
BivariateFunction_swigregister(BivariateFunction)

class Covariance1DFunction(BivariateFunction):
    """Proxy of C++ IMP::isd::Covariance1DFunction class"""
    __swig_setmethods__ = {}
    for _s in [BivariateFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Covariance1DFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [BivariateFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Covariance1DFunction, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::Covariance1DFunction self, Particle tau, Particle ilambda, double alpha=2.0, double jitter=0.0, double cutoff=1e-7) -> Covariance1DFunction
        __init__(IMP::isd::Covariance1DFunction self, Particle tau, Particle ilambda, double alpha=2.0, double jitter=0.0) -> Covariance1DFunction
        __init__(IMP::isd::Covariance1DFunction self, Particle tau, Particle ilambda, double alpha=2.0) -> Covariance1DFunction
        __init__(IMP::isd::Covariance1DFunction self, Particle tau, Particle ilambda) -> Covariance1DFunction
        """
        this = _IMP_isd.new_Covariance1DFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args):
        """
        __call__(Covariance1DFunction self, IMP::Floats const & x1, IMP::Floats const & x2) -> IMP::Floats
        __call__(Covariance1DFunction self, IMP::FloatsList const & xlist) -> IMP_Eigen::MatrixXd
        __call__(Covariance1DFunction self, IMP::FloatsList const & xlist, bool arg3) -> IMP::FloatsList
        """
        return _IMP_isd.Covariance1DFunction___call__(self, *args)

    def get_derivative_matrix(self, *args):
        """
        get_derivative_matrix(Covariance1DFunction self, unsigned int particle_no, IMP::FloatsList const & xlist) -> IMP_Eigen::MatrixXd
        get_derivative_matrix(Covariance1DFunction self, unsigned int particle_no, IMP::FloatsList const & xlist, bool arg4) -> IMP::FloatsList
        """
        return _IMP_isd.Covariance1DFunction_get_derivative_matrix(self, *args)

    def get_second_derivative_matrix(self, *args):
        """
        get_second_derivative_matrix(Covariance1DFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist) -> IMP_Eigen::MatrixXd
        get_second_derivative_matrix(Covariance1DFunction self, unsigned int particle_a, unsigned int particle_b, IMP::FloatsList const & xlist, 
            bool arg5) -> IMP::FloatsList
        """
        return _IMP_isd.Covariance1DFunction_get_second_derivative_matrix(self, *args)

    def get_version_info(self):
        """get_version_info(Covariance1DFunction self) -> VersionInfo"""
        return _IMP_isd.Covariance1DFunction_get_version_info(self)

    def __str__(self):
        """__str__(Covariance1DFunction self) -> std::string"""
        return _IMP_isd.Covariance1DFunction___str__(self)

    def __repr__(self):
        """__repr__(Covariance1DFunction self) -> std::string"""
        return _IMP_isd.Covariance1DFunction___repr__(self)

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

Covariance1DFunction_swigregister = _IMP_isd.Covariance1DFunction_swigregister
Covariance1DFunction_swigregister(Covariance1DFunction)

class GaussianProcessInterpolation(IMP.base.Object):
    """Proxy of C++ IMP::isd::GaussianProcessInterpolation class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GaussianProcessInterpolation, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GaussianProcessInterpolation, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::GaussianProcessInterpolation self, IMP::FloatsList x, IMP::Floats sample_mean, IMP::Floats sample_std, unsigned int n_obs, 
            UnivariateFunction mean_function, BivariateFunction covariance_function, 
            Particle sigma, double sparse_cutoff=1e-7) -> GaussianProcessInterpolation
        __init__(IMP::isd::GaussianProcessInterpolation self, IMP::FloatsList x, IMP::Floats sample_mean, IMP::Floats sample_std, unsigned int n_obs, 
            UnivariateFunction mean_function, BivariateFunction covariance_function, 
            Particle sigma) -> GaussianProcessInterpolation
        """
        this = _IMP_isd.new_GaussianProcessInterpolation(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_posterior_mean(self, *args):
        """get_posterior_mean(GaussianProcessInterpolation self, IMP::Floats x) -> double"""
        return _IMP_isd.GaussianProcessInterpolation_get_posterior_mean(self, *args)

    def get_posterior_covariance(self, *args):
        """get_posterior_covariance(GaussianProcessInterpolation self, IMP::Floats x1, IMP::Floats x2) -> double"""
        return _IMP_isd.GaussianProcessInterpolation_get_posterior_covariance(self, *args)

    def get_posterior_covariance_matrix(self, *args):
        """get_posterior_covariance_matrix(GaussianProcessInterpolation self, IMP::FloatsList x, bool arg3) -> IMP::FloatsList"""
        return _IMP_isd.GaussianProcessInterpolation_get_posterior_covariance_matrix(self, *args)

    def get_posterior_covariance_derivative(self, *args):
        """get_posterior_covariance_derivative(GaussianProcessInterpolation self, IMP::Floats x, bool arg3) -> IMP::Floats"""
        return _IMP_isd.GaussianProcessInterpolation_get_posterior_covariance_derivative(self, *args)

    def get_posterior_covariance_hessian(self, *args):
        """get_posterior_covariance_hessian(GaussianProcessInterpolation self, IMP::Floats x, bool arg3) -> IMP::FloatsList"""
        return _IMP_isd.GaussianProcessInterpolation_get_posterior_covariance_hessian(self, *args)

    def get_input_particles(self):
        """get_input_particles(GaussianProcessInterpolation self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_isd.GaussianProcessInterpolation_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(GaussianProcessInterpolation self) -> IMP::kernel::ContainersTemp"""
        return _IMP_isd.GaussianProcessInterpolation_get_input_containers(self)

    def force_mean_update(self):
        """force_mean_update(GaussianProcessInterpolation self)"""
        return _IMP_isd.GaussianProcessInterpolation_force_mean_update(self)

    def force_covariance_update(self):
        """force_covariance_update(GaussianProcessInterpolation self)"""
        return _IMP_isd.GaussianProcessInterpolation_force_covariance_update(self)

    def get_number_of_m_particles(self):
        """get_number_of_m_particles(GaussianProcessInterpolation self) -> unsigned int"""
        return _IMP_isd.GaussianProcessInterpolation_get_number_of_m_particles(self)

    def get_m_particle_is_optimized(self, *args):
        """get_m_particle_is_optimized(GaussianProcessInterpolation self, unsigned int i) -> bool"""
        return _IMP_isd.GaussianProcessInterpolation_get_m_particle_is_optimized(self, *args)

    def get_number_of_Omega_particles(self):
        """get_number_of_Omega_particles(GaussianProcessInterpolation self) -> unsigned int"""
        return _IMP_isd.GaussianProcessInterpolation_get_number_of_Omega_particles(self)

    def get_Omega_particle_is_optimized(self, *args):
        """get_Omega_particle_is_optimized(GaussianProcessInterpolation self, unsigned int i) -> bool"""
        return _IMP_isd.GaussianProcessInterpolation_get_Omega_particle_is_optimized(self, *args)

    def get_data_abscissa(self):
        """get_data_abscissa(GaussianProcessInterpolation self) -> IMP::FloatsList"""
        return _IMP_isd.GaussianProcessInterpolation_get_data_abscissa(self)

    def get_data_mean(self):
        """get_data_mean(GaussianProcessInterpolation self) -> IMP::Floats"""
        return _IMP_isd.GaussianProcessInterpolation_get_data_mean(self)

    def get_data_variance(self):
        """get_data_variance(GaussianProcessInterpolation self) -> IMP::FloatsList"""
        return _IMP_isd.GaussianProcessInterpolation_get_data_variance(self)

    def get_version_info(self):
        """get_version_info(GaussianProcessInterpolation self) -> VersionInfo"""
        return _IMP_isd.GaussianProcessInterpolation_get_version_info(self)

    def __str__(self):
        """__str__(GaussianProcessInterpolation self) -> std::string"""
        return _IMP_isd.GaussianProcessInterpolation___str__(self)

    def __repr__(self):
        """__repr__(GaussianProcessInterpolation self) -> std::string"""
        return _IMP_isd.GaussianProcessInterpolation___repr__(self)

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

GaussianProcessInterpolation_swigregister = _IMP_isd.GaussianProcessInterpolation_swigregister
GaussianProcessInterpolation_swigregister(GaussianProcessInterpolation)

class GaussianProcessInterpolationRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::GaussianProcessInterpolationRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GaussianProcessInterpolationRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GaussianProcessInterpolationRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::GaussianProcessInterpolationRestraint self, Model m, GaussianProcessInterpolation gpi) -> GaussianProcessInterpolationRestraint"""
        this = _IMP_isd.new_GaussianProcessInterpolationRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(GaussianProcessInterpolationRestraint self) -> double"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_get_probability(self)

    def stats(self):
        """stats(GaussianProcessInterpolationRestraint self)"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_stats(self)

    def set_use_cg(self, *args):
        """set_use_cg(GaussianProcessInterpolationRestraint self, bool use, double tol)"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_set_use_cg(self, *args)

    def get_minus_log_normalization(self):
        """get_minus_log_normalization(GaussianProcessInterpolationRestraint self) -> double"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_get_minus_log_normalization(self)

    def get_minus_exponent(self):
        """get_minus_exponent(GaussianProcessInterpolationRestraint self) -> double"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_get_minus_exponent(self)

    def get_logdet_hessian(self):
        """get_logdet_hessian(GaussianProcessInterpolationRestraint self) -> double"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_get_logdet_hessian(self)

    def get_hessian(self, *args):
        """
        get_hessian(GaussianProcessInterpolationRestraint self) -> IMP_Eigen::MatrixXd
        get_hessian(GaussianProcessInterpolationRestraint self, bool unused) -> IMP::FloatsList
        """
        return _IMP_isd.GaussianProcessInterpolationRestraint_get_hessian(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(GaussianProcessInterpolationRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(GaussianProcessInterpolationRestraint self) -> VersionInfo"""
        return _IMP_isd.GaussianProcessInterpolationRestraint_get_version_info(self)

    def __str__(self):
        """__str__(GaussianProcessInterpolationRestraint self) -> std::string"""
        return _IMP_isd.GaussianProcessInterpolationRestraint___str__(self)

    def __repr__(self):
        """__repr__(GaussianProcessInterpolationRestraint self) -> std::string"""
        return _IMP_isd.GaussianProcessInterpolationRestraint___repr__(self)

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

GaussianProcessInterpolationRestraint_swigregister = _IMP_isd.GaussianProcessInterpolationRestraint_swigregister
GaussianProcessInterpolationRestraint_swigregister(GaussianProcessInterpolationRestraint)

class MolecularDynamics(IMP.atom.MolecularDynamics):
    """Proxy of C++ IMP::isd::MolecularDynamics class"""
    __swig_setmethods__ = {}
    for _s in [IMP.atom.MolecularDynamics]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolecularDynamics, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.atom.MolecularDynamics]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MolecularDynamics, name)
    def __init__(self, m=None): 
        """
        __init__(IMP::isd::MolecularDynamics self, Model m=None) -> MolecularDynamics
        __init__(IMP::isd::MolecularDynamics self) -> MolecularDynamics
        """
        this = _IMP_isd.new_MolecularDynamics(m)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(MolecularDynamics self) -> std::string"""
        return _IMP_isd.MolecularDynamics___str__(self)

    def __repr__(self):
        """__repr__(MolecularDynamics self) -> std::string"""
        return _IMP_isd.MolecularDynamics___repr__(self)

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

    __swig_destroy__ = _IMP_isd.delete_MolecularDynamics
    __del__ = lambda self : None;
MolecularDynamics_swigregister = _IMP_isd.MolecularDynamics_swigregister
MolecularDynamics_swigregister(MolecularDynamics)

class MolecularDynamicsMover(IMP.core.MonteCarloMover):
    """Proxy of C++ IMP::isd::MolecularDynamicsMover class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.MonteCarloMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolecularDynamicsMover, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.MonteCarloMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MolecularDynamicsMover, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::MolecularDynamicsMover self, Model m, unsigned int nsteps=100, IMP::Float timestep=1.) -> MolecularDynamicsMover
        __init__(IMP::isd::MolecularDynamicsMover self, Model m, unsigned int nsteps=100) -> MolecularDynamicsMover
        __init__(IMP::isd::MolecularDynamicsMover self, Model m) -> MolecularDynamicsMover
        """
        this = _IMP_isd.new_MolecularDynamicsMover(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_md(self):
        """get_md(MolecularDynamicsMover self) -> MolecularDynamics"""
        return _IMP_isd.MolecularDynamicsMover_get_md(self)

    def get_number_of_md_steps(self):
        """get_number_of_md_steps(MolecularDynamicsMover self) -> unsigned int"""
        return _IMP_isd.MolecularDynamicsMover_get_number_of_md_steps(self)

    def set_number_of_md_steps(self, *args):
        """set_number_of_md_steps(MolecularDynamicsMover self, unsigned int nsteps)"""
        return _IMP_isd.MolecularDynamicsMover_set_number_of_md_steps(self, *args)

    def get_version_info(self):
        """get_version_info(MolecularDynamicsMover self) -> VersionInfo"""
        return _IMP_isd.MolecularDynamicsMover_get_version_info(self)

    def __str__(self):
        """__str__(MolecularDynamicsMover self) -> std::string"""
        return _IMP_isd.MolecularDynamicsMover___str__(self)

    def __repr__(self):
        """__repr__(MolecularDynamicsMover self) -> std::string"""
        return _IMP_isd.MolecularDynamicsMover___repr__(self)

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

MolecularDynamicsMover_swigregister = _IMP_isd.MolecularDynamicsMover_swigregister
MolecularDynamicsMover_swigregister(MolecularDynamicsMover)

class HybridMonteCarlo(IMP.core.MonteCarlo):
    """Proxy of C++ IMP::isd::HybridMonteCarlo class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.MonteCarlo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HybridMonteCarlo, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.MonteCarlo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HybridMonteCarlo, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::HybridMonteCarlo self, Model m, IMP::Float kT=1.0, unsigned int steps=100, IMP::Float timestep=1.0, unsigned int persistence=1) -> HybridMonteCarlo
        __init__(IMP::isd::HybridMonteCarlo self, Model m, IMP::Float kT=1.0, unsigned int steps=100, IMP::Float timestep=1.0) -> HybridMonteCarlo
        __init__(IMP::isd::HybridMonteCarlo self, Model m, IMP::Float kT=1.0, unsigned int steps=100) -> HybridMonteCarlo
        __init__(IMP::isd::HybridMonteCarlo self, Model m, IMP::Float kT=1.0) -> HybridMonteCarlo
        __init__(IMP::isd::HybridMonteCarlo self, Model m) -> HybridMonteCarlo
        """
        this = _IMP_isd.new_HybridMonteCarlo(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_kinetic_energy(self):
        """get_kinetic_energy(HybridMonteCarlo self) -> IMP::Float"""
        return _IMP_isd.HybridMonteCarlo_get_kinetic_energy(self)

    def get_potential_energy(self):
        """get_potential_energy(HybridMonteCarlo self) -> IMP::Float"""
        return _IMP_isd.HybridMonteCarlo_get_potential_energy(self)

    def get_total_energy(self):
        """get_total_energy(HybridMonteCarlo self) -> IMP::Float"""
        return _IMP_isd.HybridMonteCarlo_get_total_energy(self)

    def set_timestep(self, *args):
        """set_timestep(HybridMonteCarlo self, IMP::Float ts)"""
        return _IMP_isd.HybridMonteCarlo_set_timestep(self, *args)

    def get_timestep(self):
        """get_timestep(HybridMonteCarlo self) -> double"""
        return _IMP_isd.HybridMonteCarlo_get_timestep(self)

    def set_number_of_md_steps(self, *args):
        """set_number_of_md_steps(HybridMonteCarlo self, unsigned int nsteps)"""
        return _IMP_isd.HybridMonteCarlo_set_number_of_md_steps(self, *args)

    def get_number_of_md_steps(self):
        """get_number_of_md_steps(HybridMonteCarlo self) -> unsigned int"""
        return _IMP_isd.HybridMonteCarlo_get_number_of_md_steps(self)

    def set_persistence(self, persistence=1):
        """
        set_persistence(HybridMonteCarlo self, unsigned int persistence=1)
        set_persistence(HybridMonteCarlo self)
        """
        return _IMP_isd.HybridMonteCarlo_set_persistence(self, persistence)

    def get_persistence(self):
        """get_persistence(HybridMonteCarlo self) -> unsigned int"""
        return _IMP_isd.HybridMonteCarlo_get_persistence(self)

    def get_md(self):
        """get_md(HybridMonteCarlo self) -> MolecularDynamics"""
        return _IMP_isd.HybridMonteCarlo_get_md(self)

    def do_evaluate(self, *args):
        """do_evaluate(HybridMonteCarlo self, IMP::kernel::ParticleIndexes const & arg2) -> double"""
        return _IMP_isd.HybridMonteCarlo_do_evaluate(self, *args)

    def do_step(self):
        """do_step(HybridMonteCarlo self)"""
        return _IMP_isd.HybridMonteCarlo_do_step(self)

    def __str__(self):
        """__str__(HybridMonteCarlo self) -> std::string"""
        return _IMP_isd.HybridMonteCarlo___str__(self)

    def __repr__(self):
        """__repr__(HybridMonteCarlo self) -> std::string"""
        return _IMP_isd.HybridMonteCarlo___repr__(self)

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

HybridMonteCarlo_swigregister = _IMP_isd.HybridMonteCarlo_swigregister
HybridMonteCarlo_swigregister(HybridMonteCarlo)

class FretData(IMP.base.Object):
    """Proxy of C++ IMP::isd::FretData class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FretData, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FretData, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::FretData self, IMP::Floats d_term, IMP::Floats d_center, IMP::Floats d_int, IMP::Floats s_grid, 
            IMP::Float R0, IMP::Float Rmin, IMP::Float Rmax, bool do_limit=True) -> FretData
        __init__(IMP::isd::FretData self, IMP::Floats d_term, IMP::Floats d_center, IMP::Floats d_int, IMP::Floats s_grid, 
            IMP::Float R0, IMP::Float Rmin, IMP::Float Rmax) -> FretData
        """
        this = _IMP_isd.new_FretData(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_closest(self, *args):
        """get_closest(FretData self, DistBase vec, double value) -> int"""
        return _IMP_isd.FretData_get_closest(self, *args)

    def get_probability(self, *args):
        """get_probability(FretData self, IMP::Float distn, IMP::Float dist, IMP::Float sigma) -> IMP::Float"""
        return _IMP_isd.FretData_get_probability(self, *args)

    def get_kernel(self, *args):
        """get_kernel(FretData self, IMP::Float dist, IMP::Float R0) -> IMP::Float"""
        return _IMP_isd.FretData_get_kernel(self, *args)

    def get_marginal_element(self, *args):
        """get_marginal_element(FretData self, IMP::Float d_term, IMP::Float d_center, IMP::Float sigma) -> IMP::FloatPair"""
        return _IMP_isd.FretData_get_marginal_element(self, *args)

    def get_version_info(self):
        """get_version_info(FretData self) -> VersionInfo"""
        return _IMP_isd.FretData_get_version_info(self)

    def __str__(self):
        """__str__(FretData self) -> std::string"""
        return _IMP_isd.FretData___str__(self)

    def __repr__(self):
        """__repr__(FretData self) -> std::string"""
        return _IMP_isd.FretData___repr__(self)

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

FretData_swigregister = _IMP_isd.FretData_swigregister
FretData_swigregister(FretData)

class FretRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::FretRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FretRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FretRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::FretRestraint self, IMP::kernel::Particles pd, IMP::kernel::Particles pa, Particle kda, Particle Ida, 
            Particle R0, Particle sigma0, Particle Pbl, double fexp, double m_d=1.0, double m_a=1.0) -> FretRestraint
        __init__(IMP::isd::FretRestraint self, IMP::kernel::Particles pd, IMP::kernel::Particles pa, Particle kda, Particle Ida, 
            Particle R0, Particle sigma0, Particle Pbl, double fexp, double m_d=1.0) -> FretRestraint
        __init__(IMP::isd::FretRestraint self, IMP::kernel::Particles pd, IMP::kernel::Particles pa, Particle kda, Particle Ida, 
            Particle R0, Particle sigma0, Particle Pbl, double fexp) -> FretRestraint
        __init__(IMP::isd::FretRestraint self, Particle kda, Particle Ida, Particle sumFi, Particle sigma0, Particle Pbl, double fexp) -> FretRestraint
        __init__(IMP::isd::FretRestraint self, Particle prd, Vector3D GMMterd, IMP::algebra::Vector3Ds GMMctrd, IMP::Floats GMMwd, 
            IMP::Floats GMMsigd, Particle pra, Vector3D GMMtera, IMP::algebra::Vector3Ds GMMctra, 
            IMP::Floats GMMwa, IMP::Floats GMMsiga, Particle kda, Particle Ida, 
            Particle sigma0, Particle Pbl, FretData data, double fexp) -> FretRestraint
        """
        this = _IMP_isd.new_FretRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_sumFi(self):
        """get_sumFi(FretRestraint self) -> double"""
        return _IMP_isd.FretRestraint_get_sumFi(self)

    def get_average_sigma(self, *args):
        """get_average_sigma(FretRestraint self, double fmod) -> double"""
        return _IMP_isd.FretRestraint_get_average_sigma(self, *args)

    def get_standard_error(self):
        """get_standard_error(FretRestraint self) -> double"""
        return _IMP_isd.FretRestraint_get_standard_error(self)

    def get_model_fretr(self):
        """get_model_fretr(FretRestraint self) -> double"""
        return _IMP_isd.FretRestraint_get_model_fretr(self)

    def get_probability(self):
        """get_probability(FretRestraint self) -> double"""
        return _IMP_isd.FretRestraint_get_probability(self)

    def get_experimental_value(self):
        """get_experimental_value(FretRestraint self) -> double"""
        return _IMP_isd.FretRestraint_get_experimental_value(self)

    def set_experimental_value(self, *args):
        """set_experimental_value(FretRestraint self, double fexp)"""
        return _IMP_isd.FretRestraint_set_experimental_value(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(FretRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.FretRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(FretRestraint self) -> VersionInfo"""
        return _IMP_isd.FretRestraint_get_version_info(self)

    def __str__(self):
        """__str__(FretRestraint self) -> std::string"""
        return _IMP_isd.FretRestraint___str__(self)

    def __repr__(self):
        """__repr__(FretRestraint self) -> std::string"""
        return _IMP_isd.FretRestraint___repr__(self)

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

FretRestraint_swigregister = _IMP_isd.FretRestraint_swigregister
FretRestraint_swigregister(FretRestraint)

class CysteineCrossLinkData(IMP.base.Object):
    """Proxy of C++ IMP::isd::CysteineCrossLinkData class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CysteineCrossLinkData, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CysteineCrossLinkData, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::CysteineCrossLinkData self, double fexp, IMP::Floats fmod_grid, IMP::Floats omega_grid, IMP::Floats omega0_grid, 
            int prior_type=3) -> CysteineCrossLinkData
        __init__(IMP::isd::CysteineCrossLinkData self, double fexp, IMP::Floats fmod_grid, IMP::Floats omega_grid, IMP::Floats omega0_grid) -> CysteineCrossLinkData
        """
        this = _IMP_isd.new_CysteineCrossLinkData(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_closest(self, *args):
        """get_closest(CysteineCrossLinkData self, DistBase vec, double value) -> int"""
        return _IMP_isd.CysteineCrossLinkData_get_closest(self, *args)

    def get_omegas(self, *args):
        """get_omegas(CysteineCrossLinkData self, IMP::Floats fmods, double omega0) -> IMP::Floats"""
        return _IMP_isd.CysteineCrossLinkData_get_omegas(self, *args)

    def get_nonmarginal_elements(self, *args):
        """get_nonmarginal_elements(CysteineCrossLinkData self, double fexp, IMP::Floats fmods, double omega) -> IMP::Floats"""
        return _IMP_isd.CysteineCrossLinkData_get_nonmarginal_elements(self, *args)

    def get_marginal_elements(self, *args):
        """get_marginal_elements(CysteineCrossLinkData self, IMP::Floats fmods, double omega0) -> IMP::Floats"""
        return _IMP_isd.CysteineCrossLinkData_get_marginal_elements(self, *args)

    def get_omega(self, *args):
        """get_omega(CysteineCrossLinkData self, double fmod, double omega0) -> double"""
        return _IMP_isd.CysteineCrossLinkData_get_omega(self, *args)

    def get_standard_deviation(self, *args):
        """get_standard_deviation(CysteineCrossLinkData self, double fmod, double omega0) -> double"""
        return _IMP_isd.CysteineCrossLinkData_get_standard_deviation(self, *args)

    def get_nonmarginal_element(self, *args):
        """get_nonmarginal_element(CysteineCrossLinkData self, double fexp, double fmod, double omega) -> double"""
        return _IMP_isd.CysteineCrossLinkData_get_nonmarginal_element(self, *args)

    def get_marginal_element(self, *args):
        """get_marginal_element(CysteineCrossLinkData self, double fmod, double omega0) -> double"""
        return _IMP_isd.CysteineCrossLinkData_get_marginal_element(self, *args)

    def get_version_info(self):
        """get_version_info(CysteineCrossLinkData self) -> VersionInfo"""
        return _IMP_isd.CysteineCrossLinkData_get_version_info(self)

    def __str__(self):
        """__str__(CysteineCrossLinkData self) -> std::string"""
        return _IMP_isd.CysteineCrossLinkData___str__(self)

    def __repr__(self):
        """__repr__(CysteineCrossLinkData self) -> std::string"""
        return _IMP_isd.CysteineCrossLinkData___repr__(self)

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

CysteineCrossLinkData_swigregister = _IMP_isd.CysteineCrossLinkData_swigregister
CysteineCrossLinkData_swigregister(CysteineCrossLinkData)

class CrossLinkData(IMP.base.Object):
    """Proxy of C++ IMP::isd::CrossLinkData class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CrossLinkData, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CrossLinkData, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, double lexp_, 
            double don=std::numeric_limits< double >::max(), double doff=std::numeric_limits< double >::max(), 
            int prior_type=0) -> CrossLinkData
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, double lexp_, 
            double don=std::numeric_limits< double >::max(), double doff=std::numeric_limits< double >::max()) -> CrossLinkData
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, double lexp_, 
            double don=std::numeric_limits< double >::max()) -> CrossLinkData
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, double lexp_) -> CrossLinkData
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, IMP::Floats pot_x_grid, 
            IMP::Floats pot_value_grid, double don=std::numeric_limits< double >::max(), 
            double doff=std::numeric_limits< double >::max(), int prior_type=0) -> CrossLinkData
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, IMP::Floats pot_x_grid, 
            IMP::Floats pot_value_grid, double don=std::numeric_limits< double >::max(), 
            double doff=std::numeric_limits< double >::max()) -> CrossLinkData
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, IMP::Floats pot_x_grid, 
            IMP::Floats pot_value_grid, double don=std::numeric_limits< double >::max()) -> CrossLinkData
        __init__(IMP::isd::CrossLinkData self, IMP::Floats dist_grid, IMP::Floats omega_grid, IMP::Floats sigma_grid, IMP::Floats pot_x_grid, 
            IMP::Floats pot_value_grid) -> CrossLinkData
        """
        this = _IMP_isd.new_CrossLinkData(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_closest(self, *args):
        """get_closest(CrossLinkData self, DistBase vec, double value) -> int"""
        return _IMP_isd.CrossLinkData_get_closest(self, *args)

    def get_omegas(self, *args):
        """get_omegas(CrossLinkData self, double sigma, IMP::Floats dists) -> IMP::Floats"""
        return _IMP_isd.CrossLinkData_get_omegas(self, *args)

    def get_omega_prior(self, *args):
        """get_omega_prior(CrossLinkData self, double omega, double omega0) -> double"""
        return _IMP_isd.CrossLinkData_get_omega_prior(self, *args)

    def get_nonmarginal_elements(self, *args):
        """get_nonmarginal_elements(CrossLinkData self, double sigmai, IMP::Floats dists) -> IMP::Floats"""
        return _IMP_isd.CrossLinkData_get_nonmarginal_elements(self, *args)

    def get_marginal_elements(self, *args):
        """get_marginal_elements(CrossLinkData self, double sigma, IMP::Floats dists) -> IMP::Floats"""
        return _IMP_isd.CrossLinkData_get_marginal_elements(self, *args)

    def get_marginal_maximum(self, *args):
        """
        get_marginal_maximum(CrossLinkData self, double sigma) -> double
        get_marginal_maximum(CrossLinkData self) -> double
        """
        return _IMP_isd.CrossLinkData_get_marginal_maximum(self, *args)

    def get_version_info(self):
        """get_version_info(CrossLinkData self) -> VersionInfo"""
        return _IMP_isd.CrossLinkData_get_version_info(self)

    def __str__(self):
        """__str__(CrossLinkData self) -> std::string"""
        return _IMP_isd.CrossLinkData___str__(self)

    def __repr__(self):
        """__repr__(CrossLinkData self) -> std::string"""
        return _IMP_isd.CrossLinkData___repr__(self)

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

CrossLinkData_swigregister = _IMP_isd.CrossLinkData_swigregister
CrossLinkData_swigregister(CrossLinkData)

class CysteineCrossLinkRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::CysteineCrossLinkRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CysteineCrossLinkRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CysteineCrossLinkRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::CysteineCrossLinkRestraint self, Particle beta, Particle sigma, Particle epsilon, Particle weight, CrossLinkData data, 
            double fexp) -> CysteineCrossLinkRestraint
        __init__(IMP::isd::CysteineCrossLinkRestraint self, Particle beta, Particle sigma, Particle epsilon, Particle weight, CrossLinkData data, 
            CysteineCrossLinkData ccldata) -> CysteineCrossLinkRestraint
        """
        this = _IMP_isd.new_CysteineCrossLinkRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(CysteineCrossLinkRestraint self) -> double"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_probability(self)

    def get_standard_error(self):
        """get_standard_error(CysteineCrossLinkRestraint self) -> double"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_standard_error(self)

    def get_frequencies(self):
        """get_frequencies(CysteineCrossLinkRestraint self) -> IMP::Floats"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_frequencies(self)

    def get_model_frequency(self):
        """get_model_frequency(CysteineCrossLinkRestraint self) -> double"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_model_frequency(self)

    def get_distances(self):
        """get_distances(CysteineCrossLinkRestraint self) -> IMP::Floats"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_distances(self)

    def get_truncated_normalization(self, *args):
        """get_truncated_normalization(CysteineCrossLinkRestraint self, double mean, double sigma) -> double"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_truncated_normalization(self, *args)

    def get_normal_pdf(self, *args):
        """get_normal_pdf(CysteineCrossLinkRestraint self, double mean, double sigma, double x) -> double"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_normal_pdf(self, *args)

    def add_contribution(self, *args):
        """
        add_contribution(CysteineCrossLinkRestraint self, Particle p1, Particle p2)
        add_contribution(CysteineCrossLinkRestraint self, IMP::kernel::Particles p1, IMP::kernel::Particles p2)
        """
        return _IMP_isd.CysteineCrossLinkRestraint_add_contribution(self, *args)

    def get_CB_coordinates(self, *args):
        """get_CB_coordinates(CysteineCrossLinkRestraint self, IMP::kernel::Particles const & ps) -> Vector3D"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_CB_coordinates(self, *args)

    def get_number_of_contributions(self):
        """get_number_of_contributions(CysteineCrossLinkRestraint self) -> unsigned int"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_number_of_contributions(self)

    def do_get_inputs(self):
        """do_get_inputs(CysteineCrossLinkRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.CysteineCrossLinkRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(CysteineCrossLinkRestraint self) -> VersionInfo"""
        return _IMP_isd.CysteineCrossLinkRestraint_get_version_info(self)

    def __str__(self):
        """__str__(CysteineCrossLinkRestraint self) -> std::string"""
        return _IMP_isd.CysteineCrossLinkRestraint___str__(self)

    def __repr__(self):
        """__repr__(CysteineCrossLinkRestraint self) -> std::string"""
        return _IMP_isd.CysteineCrossLinkRestraint___repr__(self)

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

CysteineCrossLinkRestraint_swigregister = _IMP_isd.CysteineCrossLinkRestraint_swigregister
CysteineCrossLinkRestraint_swigregister(CysteineCrossLinkRestraint)

class WeightMover(IMP.core.MonteCarloMover):
    """Proxy of C++ IMP::isd::WeightMover class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.MonteCarloMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WeightMover, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.MonteCarloMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WeightMover, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::WeightMover self, Particle w, IMP::Float radius) -> WeightMover"""
        this = _IMP_isd.new_WeightMover(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_radius(self, *args):
        """set_radius(WeightMover self, IMP::Float radius)"""
        return _IMP_isd.WeightMover_set_radius(self, *args)

    def get_radius(self):
        """get_radius(WeightMover self) -> IMP::Float"""
        return _IMP_isd.WeightMover_get_radius(self)

    def get_version_info(self):
        """get_version_info(WeightMover self) -> VersionInfo"""
        return _IMP_isd.WeightMover_get_version_info(self)

    def __str__(self):
        """__str__(WeightMover self) -> std::string"""
        return _IMP_isd.WeightMover___str__(self)

    def __repr__(self):
        """__repr__(WeightMover self) -> std::string"""
        return _IMP_isd.WeightMover___repr__(self)

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

WeightMover_swigregister = _IMP_isd.WeightMover_swigregister
WeightMover_swigregister(WeightMover)

class WeightRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::WeightRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WeightRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WeightRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::isd::WeightRestraint self, Particle w, IMP::Float wmin, IMP::Float wmax, IMP::Float kappa) -> WeightRestraint"""
        this = _IMP_isd.new_WeightRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(WeightRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.WeightRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(WeightRestraint self) -> VersionInfo"""
        return _IMP_isd.WeightRestraint_get_version_info(self)

    def __str__(self):
        """__str__(WeightRestraint self) -> std::string"""
        return _IMP_isd.WeightRestraint___str__(self)

    def __repr__(self):
        """__repr__(WeightRestraint self) -> std::string"""
        return _IMP_isd.WeightRestraint___repr__(self)

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

WeightRestraint_swigregister = _IMP_isd.WeightRestraint_swigregister
WeightRestraint_swigregister(WeightRestraint)

class AtomicCrossLinkMSRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::AtomicCrossLinkMSRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomicCrossLinkMSRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AtomicCrossLinkMSRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::AtomicCrossLinkMSRestraint self, Model m, double length, IMP::Float slope=0.0, bool i_am_part_of_log_score=False, 
            std::string name="AtomicCrossLinkMSRestraint%1%") -> AtomicCrossLinkMSRestraint
        __init__(IMP::isd::AtomicCrossLinkMSRestraint self, Model m, double length, IMP::Float slope=0.0, bool i_am_part_of_log_score=False) -> AtomicCrossLinkMSRestraint
        __init__(IMP::isd::AtomicCrossLinkMSRestraint self, Model m, double length, IMP::Float slope=0.0) -> AtomicCrossLinkMSRestraint
        __init__(IMP::isd::AtomicCrossLinkMSRestraint self, Model m, double length) -> AtomicCrossLinkMSRestraint
        """
        this = _IMP_isd.new_AtomicCrossLinkMSRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_contribution(self, *args):
        """
        add_contribution(AtomicCrossLinkMSRestraint self, IMP::kernel::ParticleIndexPair const & ppi, IMP::kernel::ParticleIndexPair const & sigmas, 
            IMP::kernel::ParticleIndex const & psi)
        """
        return _IMP_isd.AtomicCrossLinkMSRestraint_add_contribution(self, *args)

    def evaluate_for_contributions(self, *args):
        """evaluate_for_contributions(AtomicCrossLinkMSRestraint self, IMP::Ints c, DerivativeAccumulator accum) -> IMP::Float"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_evaluate_for_contributions(self, *args)

    def get_contribution_scores(self, *args):
        """get_contribution_scores(AtomicCrossLinkMSRestraint self, int index) -> IMP::Floats"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_get_contribution_scores(self, *args)

    def get_number_of_contributions(self):
        """get_number_of_contributions(AtomicCrossLinkMSRestraint self) -> unsigned int"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_get_number_of_contributions(self)

    def get_contribution(self, *args):
        """get_contribution(AtomicCrossLinkMSRestraint self, int i) -> IMP::kernel::ParticleIndexPair"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_get_contribution(self, *args)

    def get_contribution_sigmas(self, *args):
        """get_contribution_sigmas(AtomicCrossLinkMSRestraint self, int i) -> IMP::kernel::ParticleIndexPair"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_get_contribution_sigmas(self, *args)

    def get_contribution_psi(self, *args):
        """get_contribution_psi(AtomicCrossLinkMSRestraint self, int i) -> IMP::kernel::ParticleIndex"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_get_contribution_psi(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(AtomicCrossLinkMSRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_do_get_inputs(self)

    def show(self, *args):
        """show(AtomicCrossLinkMSRestraint self, _ostream out)"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_show(self, *args)

    def set_slope(self, *args):
        """set_slope(AtomicCrossLinkMSRestraint self, IMP::Float slope)"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_set_slope(self, *args)

    def set_part_of_log_score(self, *args):
        """set_part_of_log_score(AtomicCrossLinkMSRestraint self, bool hey)"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_set_part_of_log_score(self, *args)

    def get_version_info(self):
        """get_version_info(AtomicCrossLinkMSRestraint self) -> VersionInfo"""
        return _IMP_isd.AtomicCrossLinkMSRestraint_get_version_info(self)

    def __str__(self):
        """__str__(AtomicCrossLinkMSRestraint self) -> std::string"""
        return _IMP_isd.AtomicCrossLinkMSRestraint___str__(self)

    def __repr__(self):
        """__repr__(AtomicCrossLinkMSRestraint self) -> std::string"""
        return _IMP_isd.AtomicCrossLinkMSRestraint___repr__(self)

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

AtomicCrossLinkMSRestraint_swigregister = _IMP_isd.AtomicCrossLinkMSRestraint_swigregister
AtomicCrossLinkMSRestraint_swigregister(AtomicCrossLinkMSRestraint)

class GaussianEMRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::isd::GaussianEMRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GaussianEMRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GaussianEMRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::isd::GaussianEMRestraint self, Model mdl, IMP::kernel::ParticleIndexes model_ps, IMP::kernel::ParticleIndexes density_ps, 
            IMP::kernel::ParticleIndex global_sigma, IMP::Float model_cutoff_dist, 
            IMP::Float density_cutoff_dist, IMP::Float slope, bool update_model=True, 
            bool backbone_slope=False, std::string name="GaussianEMRestraint%1%") -> GaussianEMRestraint
        __init__(IMP::isd::GaussianEMRestraint self, Model mdl, IMP::kernel::ParticleIndexes model_ps, IMP::kernel::ParticleIndexes density_ps, 
            IMP::kernel::ParticleIndex global_sigma, IMP::Float model_cutoff_dist, 
            IMP::Float density_cutoff_dist, IMP::Float slope, bool update_model=True, 
            bool backbone_slope=False) -> GaussianEMRestraint
        __init__(IMP::isd::GaussianEMRestraint self, Model mdl, IMP::kernel::ParticleIndexes model_ps, IMP::kernel::ParticleIndexes density_ps, 
            IMP::kernel::ParticleIndex global_sigma, IMP::Float model_cutoff_dist, 
            IMP::Float density_cutoff_dist, IMP::Float slope, bool update_model=True) -> GaussianEMRestraint
        __init__(IMP::isd::GaussianEMRestraint self, Model mdl, IMP::kernel::ParticleIndexes model_ps, IMP::kernel::ParticleIndexes density_ps, 
            IMP::kernel::ParticleIndex global_sigma, IMP::Float model_cutoff_dist, 
            IMP::Float density_cutoff_dist, IMP::Float slope) -> GaussianEMRestraint
        """
        this = _IMP_isd.new_GaussianEMRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_probability(self):
        """get_probability(GaussianEMRestraint self) -> double"""
        return _IMP_isd.GaussianEMRestraint_get_probability(self)

    def compute_initial_scores(self):
        """compute_initial_scores(GaussianEMRestraint self)"""
        return _IMP_isd.GaussianEMRestraint_compute_initial_scores(self)

    def set_slope(self, *args):
        """set_slope(GaussianEMRestraint self, IMP::Float s)"""
        return _IMP_isd.GaussianEMRestraint_set_slope(self, *args)

    def get_slope(self):
        """get_slope(GaussianEMRestraint self) -> IMP::Float"""
        return _IMP_isd.GaussianEMRestraint_get_slope(self)

    def do_get_inputs(self):
        """do_get_inputs(GaussianEMRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_isd.GaussianEMRestraint_do_get_inputs(self)

    def show(self, *args):
        """show(GaussianEMRestraint self, _ostream out)"""
        return _IMP_isd.GaussianEMRestraint_show(self, *args)

    def get_version_info(self):
        """get_version_info(GaussianEMRestraint self) -> VersionInfo"""
        return _IMP_isd.GaussianEMRestraint_get_version_info(self)

    def __str__(self):
        """__str__(GaussianEMRestraint self) -> std::string"""
        return _IMP_isd.GaussianEMRestraint___str__(self)

    def __repr__(self):
        """__repr__(GaussianEMRestraint self) -> std::string"""
        return _IMP_isd.GaussianEMRestraint___repr__(self)

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

GaussianEMRestraint_swigregister = _IMP_isd.GaussianEMRestraint_swigregister
GaussianEMRestraint_swigregister(GaussianEMRestraint)


def sample_points_from_density(*args):
  """
    sample_points_from_density(DensityMap dmap_orig, int npoints, IMP::Float threshold=0.0) -> IMP::FloatsList
    sample_points_from_density(DensityMap dmap_orig, int npoints) -> IMP::FloatsList
    """
  return _IMP_isd.sample_points_from_density(*args)

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

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

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_isd.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.