__init__.py

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

# This wrapper is part of IMP,
# Copyright 2007-2016 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import




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_kernel', [dirname(__file__)])
        except ImportError:
            import _IMP_kernel
            return _IMP_kernel
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_kernel', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_kernel = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_kernel
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):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


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


class IMP_KERNEL_SwigPyIterator(object):
    """Proxy of C++ swig::IMP_KERNEL_SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def value(self):
        """value(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
        incr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
        """
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(IMP_KERNEL_SwigPyIterator self, size_t n=1) -> IMP_KERNEL_SwigPyIterator
        decr(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator
        """
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(IMP_KERNEL_SwigPyIterator self) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_copy(self)


    def next(self):
        """next(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_next(self)


    def __next__(self):
        """__next__(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___next__(self)


    def previous(self):
        """previous(IMP_KERNEL_SwigPyIterator self) -> PyObject *"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> bool"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator"""
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(IMP_KERNEL_SwigPyIterator self, ptrdiff_t n) -> IMP_KERNEL_SwigPyIterator
        __sub__(IMP_KERNEL_SwigPyIterator self, IMP_KERNEL_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_kernel.IMP_KERNEL_SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
IMP_KERNEL_SwigPyIterator_swigregister = _IMP_kernel.IMP_KERNEL_SwigPyIterator_swigregister
IMP_KERNEL_SwigPyIterator_swigregister(IMP_KERNEL_SwigPyIterator)


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


_IMP_kernel.IMP_DEBUG_swigconstant(_IMP_kernel)
IMP_DEBUG = _IMP_kernel.IMP_DEBUG

_IMP_kernel.IMP_RELEASE_swigconstant(_IMP_kernel)
IMP_RELEASE = _IMP_kernel.IMP_RELEASE

_IMP_kernel.IMP_SILENT_swigconstant(_IMP_kernel)
IMP_SILENT = _IMP_kernel.IMP_SILENT

_IMP_kernel.IMP_PROGRESS_swigconstant(_IMP_kernel)
IMP_PROGRESS = _IMP_kernel.IMP_PROGRESS

_IMP_kernel.IMP_TERSE_swigconstant(_IMP_kernel)
IMP_TERSE = _IMP_kernel.IMP_TERSE

_IMP_kernel.IMP_VERBOSE_swigconstant(_IMP_kernel)
IMP_VERBOSE = _IMP_kernel.IMP_VERBOSE

_IMP_kernel.IMP_MEMORY_swigconstant(_IMP_kernel)
IMP_MEMORY = _IMP_kernel.IMP_MEMORY

_IMP_kernel.IMP_NONE_swigconstant(_IMP_kernel)
IMP_NONE = _IMP_kernel.IMP_NONE

_IMP_kernel.IMP_USAGE_swigconstant(_IMP_kernel)
IMP_USAGE = _IMP_kernel.IMP_USAGE

_IMP_kernel.IMP_INTERNAL_swigconstant(_IMP_kernel)
IMP_INTERNAL = _IMP_kernel.IMP_INTERNAL

_IMP_kernel.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_kernel)
IMP_KERNEL_HAS_LOG4CXX = _IMP_kernel.IMP_KERNEL_HAS_LOG4CXX

_IMP_kernel.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_kernel)
IMP_COMPILER_HAS_AUTO = _IMP_kernel.IMP_COMPILER_HAS_AUTO

_IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_kernel)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kernel.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_kernel)
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kernel.IMP_COMPILER_HAS_UNIQUE_PTR

_IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_kernel)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kernel.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_kernel)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kernel.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_kernel)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_kernel)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kernel.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_kernel.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_kernel)
IMPKERNEL_SHOW_WARNINGS = _IMP_kernel.IMPKERNEL_SHOW_WARNINGS

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


_IMP_kernel.DEFAULT_CHECK_swigconstant(_IMP_kernel)
DEFAULT_CHECK = _IMP_kernel.DEFAULT_CHECK

_IMP_kernel.NONE_swigconstant(_IMP_kernel)
NONE = _IMP_kernel.NONE

_IMP_kernel.USAGE_swigconstant(_IMP_kernel)
USAGE = _IMP_kernel.USAGE

_IMP_kernel.USAGE_AND_INTERNAL_swigconstant(_IMP_kernel)
USAGE_AND_INTERNAL = _IMP_kernel.USAGE_AND_INTERNAL

def set_check_level(tf):
    """set_check_level(IMP::CheckLevel tf)"""
    return _IMP_kernel.set_check_level(tf)

def get_check_level():
    """get_check_level() -> IMP::CheckLevel"""
    return _IMP_kernel.get_check_level()

from _IMP_kernel import Exception, InternalException, ModelException, EventException
from _IMP_kernel import UsageException, IndexException, IOException, ValueException
from _IMP_kernel import TypeException

class _ostream(object):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

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

_ostream_swigregister = _IMP_kernel._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_kernel.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_kernel)
IMP_COMPILER_HAS_OVERRIDE = _IMP_kernel.IMP_COMPILER_HAS_OVERRIDE

_IMP_kernel.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_kernel)
IMP_COMPILER_HAS_FINAL = _IMP_kernel.IMP_COMPILER_HAS_FINAL

_IMP_kernel.IMP_HAS_NOEXCEPT_swigconstant(_IMP_kernel)
IMP_HAS_NOEXCEPT = _IMP_kernel.IMP_HAS_NOEXCEPT

_raii_types.append("SetLogState")


_raii_types.append("SetNumberOfThreads")


_raii_types.append("SetCheckState")


_object_types.append("Object")


def _object_cast_to_Object(o):
    """_object_cast_to_Object(Object * o) -> Object"""
    return _IMP_kernel._object_cast_to_Object(o)

_object_types.append("_TestObject")


def _object_cast_to__TestObject(o):
    """_object_cast_to__TestObject(Object * o) -> _TestObject"""
    return _IMP_kernel._object_cast_to__TestObject(o)

VersionInfos=list
_plural_types.append("VersionInfos")
_value_types.append("VersionInfo")


_raii_types.append("CreateLogContext")


_raii_types.append("WarningContext")


_raii_types.append("SetLogTarget")


_TestValues=list
_plural_types.append("_TestValues")
_value_types.append("_TestValue")


Floats=list
_plural_types.append("Floats")
_value_types.append("Float")


Ints=list
_plural_types.append("Ints")
_value_types.append("Int")


Strings=list
_plural_types.append("Strings")
_value_types.append("String")


_Protections=list
_plural_types.append("_Protections")
_value_types.append("_Protection")

class _InputAdaptor(object):
    """Proxy of C++ IMP::InputAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_kernel.delete__InputAdaptor
    __del__ = lambda self: None
_InputAdaptor_swigregister = _IMP_kernel._InputAdaptor_swigregister
_InputAdaptor_swigregister(_InputAdaptor)

class _NonCopyable(object):
    """Proxy of C++ IMP::NonCopyable class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_kernel.delete__NonCopyable
    __del__ = lambda self: None
_NonCopyable_swigregister = _IMP_kernel._NonCopyable_swigregister
_NonCopyable_swigregister(_NonCopyable)

class _RAII(_NonCopyable):
    """Proxy of C++ IMP::RAII class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_kernel.delete__RAII
    __del__ = lambda self: None
_RAII_swigregister = _IMP_kernel._RAII_swigregister
_RAII_swigregister(_RAII)

class _Value(object):
    """Proxy of C++ IMP::Value class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_kernel.delete__Value
    __del__ = lambda self: None
_Value_swigregister = _IMP_kernel._Value_swigregister
_Value_swigregister(_Value)


def get_executable_name():
    """get_executable_name() -> std::string"""
    return _IMP_kernel.get_executable_name()

def setup_from_argv(*args):
    """
    setup_from_argv(IMP::Strings const & argv, std::string description)
    setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, int num_positional) -> IMP::Strings
    """
    return _IMP_kernel.setup_from_argv(*args)

def add_string_flag(name, default_value, description):
    """add_string_flag(std::string name, std::string default_value, std::string description)"""
    return _IMP_kernel.add_string_flag(name, default_value, description)

def get_string_flag(name):
    """get_string_flag(std::string name) -> std::string"""
    return _IMP_kernel.get_string_flag(name)

def add_int_flag(name, default_value, description):
    """add_int_flag(std::string name, size_t default_value, std::string description)"""
    return _IMP_kernel.add_int_flag(name, default_value, description)

def get_int_flag(name):
    """get_int_flag(std::string name) -> size_t"""
    return _IMP_kernel.get_int_flag(name)

def add_bool_flag(name, description):
    """add_bool_flag(std::string name, std::string description)"""
    return _IMP_kernel.add_bool_flag(name, description)

def get_bool_flag(name):
    """get_bool_flag(std::string name) -> bool"""
    return _IMP_kernel.get_bool_flag(name)

def add_float_flag(name, default_value, description):
    """add_float_flag(std::string name, double default_value, std::string description)"""
    return _IMP_kernel.add_float_flag(name, default_value, description)

def get_float_flag(name):
    """get_float_flag(std::string name) -> double"""
    return _IMP_kernel.get_float_flag(name)

def write_help(*args):
    """
    write_help(_ostream out)
    write_help()
    """
    return _IMP_kernel.write_help(*args)

def get_is_quick_test():
    """get_is_quick_test() -> bool"""
    return _IMP_kernel.get_is_quick_test()

_IMP_kernel.DEFAULT_swigconstant(_IMP_kernel)
DEFAULT = _IMP_kernel.DEFAULT

_IMP_kernel.SILENT_swigconstant(_IMP_kernel)
SILENT = _IMP_kernel.SILENT

_IMP_kernel.WARNING_swigconstant(_IMP_kernel)
WARNING = _IMP_kernel.WARNING

_IMP_kernel.PROGRESS_swigconstant(_IMP_kernel)
PROGRESS = _IMP_kernel.PROGRESS

_IMP_kernel.TERSE_swigconstant(_IMP_kernel)
TERSE = _IMP_kernel.TERSE

_IMP_kernel.VERBOSE_swigconstant(_IMP_kernel)
VERBOSE = _IMP_kernel.VERBOSE

_IMP_kernel.MEMORY_swigconstant(_IMP_kernel)
MEMORY = _IMP_kernel.MEMORY

_IMP_kernel.ALL_LOG_swigconstant(_IMP_kernel)
ALL_LOG = _IMP_kernel.ALL_LOG

_IMP_kernel.NO_STATISTICS_swigconstant(_IMP_kernel)
NO_STATISTICS = _IMP_kernel.NO_STATISTICS

_IMP_kernel.ALL_STATISTICS_swigconstant(_IMP_kernel)
ALL_STATISTICS = _IMP_kernel.ALL_STATISTICS
class VersionInfo(_Value):
    """Proxy of C++ IMP::VersionInfo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::VersionInfo self, std::string module, std::string version) -> VersionInfo
        __init__(IMP::VersionInfo self) -> VersionInfo
        """
        this = _IMP_kernel.new_VersionInfo(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_module(self):
        """get_module(VersionInfo self) -> std::string"""
        return _IMP_kernel.VersionInfo_get_module(self)


    def get_version(self):
        """get_version(VersionInfo self) -> std::string"""
        return _IMP_kernel.VersionInfo_get_version(self)


    def show(self, *args):
        """
        show(VersionInfo self, _ostream out)
        show(VersionInfo self)
        """
        return _IMP_kernel.VersionInfo_show(self, *args)


    def __cmp__(self, o):
        """__cmp__(VersionInfo self, VersionInfo o) -> int"""
        return _IMP_kernel.VersionInfo___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_kernel.VersionInfo___eq__(self, o)


    def __ne__(self, o):
        """__ne__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_kernel.VersionInfo___ne__(self, o)


    def __lt__(self, o):
        """__lt__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_kernel.VersionInfo___lt__(self, o)


    def __gt__(self, o):
        """__gt__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_kernel.VersionInfo___gt__(self, o)


    def __ge__(self, o):
        """__ge__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_kernel.VersionInfo___ge__(self, o)


    def __le__(self, o):
        """__le__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_kernel.VersionInfo___le__(self, o)


    def __str__(self):
        """__str__(VersionInfo self) -> std::string"""
        return _IMP_kernel.VersionInfo___str__(self)


    def __repr__(self):
        """__repr__(VersionInfo self) -> std::string"""
        return _IMP_kernel.VersionInfo___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_VersionInfo
    __del__ = lambda self: None
VersionInfo_swigregister = _IMP_kernel.VersionInfo_swigregister
VersionInfo_swigregister(VersionInfo)

class TextOutput(_InputAdaptor):
    """Proxy of C++ IMP::TextOutput class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::TextOutput self, int arg2) -> TextOutput
        __init__(IMP::TextOutput self, double arg2) -> TextOutput
        __init__(IMP::TextOutput self, char const * c, bool append=False) -> TextOutput
        __init__(IMP::TextOutput self, char const * c) -> TextOutput
        __init__(IMP::TextOutput self, IMP::TextProxy< std::ostream > p) -> TextOutput
        __init__(IMP::TextOutput self) -> TextOutput
        __init__(IMP::TextOutput self, std::string file_name, bool append=False) -> TextOutput
        __init__(IMP::TextOutput self, std::string file_name) -> TextOutput
        """
        this = _IMP_kernel.new_TextOutput(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(TextOutput self, _ostream out)
        show(TextOutput self)
        """
        return _IMP_kernel.TextOutput_show(self, *args)


    def get_name(self):
        """get_name(TextOutput self) -> std::string"""
        return _IMP_kernel.TextOutput_get_name(self)

    __swig_destroy__ = _IMP_kernel.delete_TextOutput
    __del__ = lambda self: None
TextOutput_swigregister = _IMP_kernel.TextOutput_swigregister
TextOutput_swigregister(TextOutput)

class TextInput(_InputAdaptor):
    """Proxy of C++ IMP::TextInput class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::TextInput self, int arg2) -> TextInput
        __init__(IMP::TextInput self, double arg2) -> TextInput
        __init__(IMP::TextInput self, char const * c) -> TextInput
        __init__(IMP::TextInput self, IMP::TextProxy< std::istream > p) -> TextInput
        __init__(IMP::TextInput self) -> TextInput
        __init__(IMP::TextInput self, std::string file_name) -> TextInput
        """
        this = _IMP_kernel.new_TextInput(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(TextInput self, _ostream out)
        show(TextInput self)
        """
        return _IMP_kernel.TextInput_show(self, *args)


    def get_name(self):
        """get_name(TextInput self) -> std::string"""
        return _IMP_kernel.TextInput_get_name(self)

    __swig_destroy__ = _IMP_kernel.delete_TextInput
    __del__ = lambda self: None
TextInput_swigregister = _IMP_kernel.TextInput_swigregister
TextInput_swigregister(TextInput)

class SetLogTarget(_RAII):
    """Proxy of C++ IMP::SetLogTarget class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::SetLogTarget self) -> SetLogTarget
        __init__(IMP::SetLogTarget self, TextOutput to) -> SetLogTarget
        """
        this = _IMP_kernel.new_SetLogTarget(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set(self, to):
        """set(SetLogTarget self, TextOutput to)"""
        return _IMP_kernel.SetLogTarget_set(self, to)


    def reset(self):
        """reset(SetLogTarget self)"""
        return _IMP_kernel.SetLogTarget_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_SetLogTarget
    __del__ = lambda self: None

    def show(self, *args):
        """
        show(SetLogTarget self, _ostream out)
        show(SetLogTarget self)
        """
        return _IMP_kernel.SetLogTarget_show(self, *args)


    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.reset()
        return False


    def __str__(self):
        """__str__(SetLogTarget self) -> std::string"""
        return _IMP_kernel.SetLogTarget___str__(self)


    def __repr__(self):
        """__repr__(SetLogTarget self) -> std::string"""
        return _IMP_kernel.SetLogTarget___repr__(self)

SetLogTarget_swigregister = _IMP_kernel.SetLogTarget_swigregister
SetLogTarget_swigregister(SetLogTarget)


def create_temporary_file(*args):
    """
    create_temporary_file(std::string prefix, std::string suffix) -> TextOutput
    create_temporary_file(std::string prefix) -> TextOutput
    create_temporary_file() -> TextOutput
    """
    return _IMP_kernel.create_temporary_file(*args)

def create_temporary_file_name(*args):
    """
    create_temporary_file_name(std::string prefix, std::string suffix) -> std::string
    create_temporary_file_name(std::string prefix) -> std::string
    create_temporary_file_name() -> std::string
    """
    return _IMP_kernel.create_temporary_file_name(*args)

def get_relative_path(base, relative):
    """get_relative_path(std::string base, std::string relative) -> std::string"""
    return _IMP_kernel.get_relative_path(base, relative)

def push_log_context(functionname, object):
    """push_log_context(char const * functionname, void const * object)"""
    return _IMP_kernel.push_log_context(functionname, object)

def pop_log_context():
    """pop_log_context()"""
    return _IMP_kernel.pop_log_context()

def add_to_log(*args):
    """
    add_to_log(std::string to_write)
    add_to_log(IMP::LogLevel level, std::string to_write)
    """
    return _IMP_kernel.add_to_log(*args)

def set_log_level(l):
    """set_log_level(IMP::LogLevel l)"""
    return _IMP_kernel.set_log_level(l)

def set_log_timer(tb):
    """set_log_timer(bool tb)"""
    return _IMP_kernel.set_log_timer(tb)

def reset_log_timer():
    """reset_log_timer()"""
    return _IMP_kernel.reset_log_timer()

def get_log_level():
    """get_log_level() -> IMP::LogLevel"""
    return _IMP_kernel.get_log_level()

def set_progress_display(description, steps):
    """set_progress_display(std::string description, unsigned int steps)"""
    return _IMP_kernel.set_progress_display(description, steps)

def add_to_progress_display(step=1):
    """
    add_to_progress_display(unsigned int step=1)
    add_to_progress_display()
    """
    return _IMP_kernel.add_to_progress_display(step)
class Object(_NonCopyable):
    """Proxy of C++ IMP::Object class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, name):
        """__init__(IMP::Object self, std::string name) -> Object"""
        if self.__class__ == Object:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Object(_self, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Object:
            _director_objects.register(self)



    __swig_destroy__ = _IMP_kernel.delete_Object
    __del__ = lambda self: None

    def __hash__(self):
        """__hash__(Object self) -> std::size_t"""
        return _IMP_kernel.Object___hash__(self)


    def set_log_level(self, l):
        """set_log_level(Object self, IMP::LogLevel l)"""
        return _IMP_kernel.Object_set_log_level(self, l)


    def set_check_level(self, l):
        """set_check_level(Object self, IMP::CheckLevel l)"""
        return _IMP_kernel.Object_set_check_level(self, l)


    def get_log_level(self):
        """get_log_level(Object self) -> IMP::LogLevel"""
        return _IMP_kernel.Object_get_log_level(self)


    def get_check_level(self):
        """get_check_level(Object self) -> IMP::CheckLevel"""
        return _IMP_kernel.Object_get_check_level(self)


    def get_version_info(self):
        """get_version_info(Object self) -> VersionInfo"""
        return _IMP_kernel.Object_get_version_info(self)


    def get_name(self):
        """get_name(Object self) -> std::string const &"""
        return _IMP_kernel.Object_get_name(self)


    def set_name(self, name):
        """set_name(Object self, std::string name)"""
        return _IMP_kernel.Object_set_name(self, name)


    def get_type_name(self):
        """get_type_name(Object self) -> std::string"""
        return _IMP_kernel.Object_get_type_name(self)


    def set_was_used(self, tf):
        """set_was_used(Object self, bool tf)"""
        return _IMP_kernel.Object_set_was_used(self, tf)


    def show(self, *args):
        """
        show(Object self, _ostream out)
        show(Object self)
        """
        return _IMP_kernel.Object_show(self, *args)


    def get_string(self):
        """get_string(Object self) -> std::string"""
        return _IMP_kernel.Object_get_string(self)


    def _on_destruction(self):
        """_on_destruction(Object self)"""
        return _IMP_kernel.Object__on_destruction(self)


    def get_is_valid(self):
        """get_is_valid(Object self) -> bool"""
        return _IMP_kernel.Object_get_is_valid(self)


    def get_ref_count(self):
        """get_ref_count(Object self) -> unsigned int"""
        return _IMP_kernel.Object_get_ref_count(self)


    def get_number_of_live_objects():
        """get_number_of_live_objects() -> unsigned int"""
        return _IMP_kernel.Object_get_number_of_live_objects()

    get_number_of_live_objects = staticmethod(get_number_of_live_objects)

    def get_is_shared(self):
        """get_is_shared(Object self) -> bool"""
        return _IMP_kernel.Object_get_is_shared(self)


    def clear_caches(self):
        """clear_caches(Object self)"""
        return _IMP_kernel.Object_clear_caches(self)


    def do_destroy(self):
        """do_destroy(Object self)"""
        return _IMP_kernel.Object_do_destroy(self)


    def __eq__(self, o):
        """__eq__(Object self, Object o) -> bool"""
        return _IMP_kernel.Object___eq__(self, o)


    def __ne__(self, o):
        """__ne__(Object self, Object o) -> bool"""
        return _IMP_kernel.Object___ne__(self, o)


    def __le__(self, o):
        """__le__(Object self, Object o) -> bool"""
        return _IMP_kernel.Object___le__(self, o)


    def __lt__(self, o):
        """__lt__(Object self, Object o) -> bool"""
        return _IMP_kernel.Object___lt__(self, o)


    def __ge__(self, o):
        """__ge__(Object self, Object o) -> bool"""
        return _IMP_kernel.Object___ge__(self, o)


    def __gt__(self, o):
        """__gt__(Object self, Object o) -> bool"""
        return _IMP_kernel.Object___gt__(self, o)


    def __str__(self):
        """__str__(Object self) -> std::string"""
        return _IMP_kernel.Object___str__(self)


    def __repr__(self):
        """__repr__(Object self) -> std::string"""
        return _IMP_kernel.Object___repr__(self)


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

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Object(self)
        return weakref_proxy(self)
Object_swigregister = _IMP_kernel.Object_swigregister
Object_swigregister(Object)

def Object_get_number_of_live_objects():
    """Object_get_number_of_live_objects() -> unsigned int"""
    return _IMP_kernel.Object_get_number_of_live_objects()

class SetLogState(_RAII):
    """Proxy of C++ IMP::SetLogState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def reset(self):
        """reset(SetLogState self)"""
        return _IMP_kernel.SetLogState_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_SetLogState
    __del__ = lambda self: None

    def show(self, *args):
        """
        show(SetLogState self, _ostream out)
        show(SetLogState self)
        """
        return _IMP_kernel.SetLogState_show(self, *args)


    def __init__(self, *args):
        """
        __init__(IMP::SetLogState self) -> SetLogState
        __init__(IMP::SetLogState self, Object o, IMP::LogLevel l) -> SetLogState
        __init__(IMP::SetLogState self, IMP::LogLevel l) -> SetLogState
        """
        this = _IMP_kernel.new_SetLogState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set(self, *args):
        """
        set(SetLogState self, Object o, IMP::LogLevel l)
        set(SetLogState self, IMP::LogLevel l)
        """
        return _IMP_kernel.SetLogState_set(self, *args)


    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.reset()
        return False


    def __str__(self):
        """__str__(SetLogState self) -> std::string"""
        return _IMP_kernel.SetLogState___str__(self)


    def __repr__(self):
        """__repr__(SetLogState self) -> std::string"""
        return _IMP_kernel.SetLogState___repr__(self)

SetLogState_swigregister = _IMP_kernel.SetLogState_swigregister
SetLogState_swigregister(SetLogState)

class WarningContext(object):
    """Proxy of C++ IMP::WarningContext class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    data_ = _swig_property(_IMP_kernel.WarningContext_data__get, _IMP_kernel.WarningContext_data__set)

    def add_warning(self, key, warning):
        """add_warning(WarningContext self, std::string key, std::string warning)"""
        return _IMP_kernel.WarningContext_add_warning(self, key, warning)


    def clear_warnings(self):
        """clear_warnings(WarningContext self)"""
        return _IMP_kernel.WarningContext_clear_warnings(self)


    def dump_warnings(self):
        """dump_warnings(WarningContext self)"""
        return _IMP_kernel.WarningContext_dump_warnings(self)

    __swig_destroy__ = _IMP_kernel.delete_WarningContext
    __del__ = lambda self: None

    def show(self, *args):
        """
        show(WarningContext self, _ostream out)
        show(WarningContext self)
        """
        return _IMP_kernel.WarningContext_show(self, *args)


    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.reset()
        return False


    def __str__(self):
        """__str__(WarningContext self) -> std::string"""
        return _IMP_kernel.WarningContext___str__(self)


    def __repr__(self):
        """__repr__(WarningContext self) -> std::string"""
        return _IMP_kernel.WarningContext___repr__(self)


    def __init__(self):
        """__init__(IMP::WarningContext self) -> WarningContext"""
        this = _IMP_kernel.new_WarningContext()
        try:
            self.this.append(this)
        except:
            self.this = this
WarningContext_swigregister = _IMP_kernel.WarningContext_swigregister
WarningContext_swigregister(WarningContext)

class CreateLogContext(_RAII):
    """Proxy of C++ IMP::CreateLogContext class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
        __init__(IMP::CreateLogContext self, std::string fname) -> CreateLogContext
        __init__(IMP::CreateLogContext self) -> CreateLogContext
        __init__(IMP::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
        __init__(IMP::CreateLogContext self, char const * fname) -> CreateLogContext
        """
        this = _IMP_kernel.new_CreateLogContext(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set(self, fname, object=None):
        """
        set(CreateLogContext self, char const * fname, Object object=None)
        set(CreateLogContext self, char const * fname)
        """
        return _IMP_kernel.CreateLogContext_set(self, fname, object)


    def reset(self):
        """reset(CreateLogContext self)"""
        return _IMP_kernel.CreateLogContext_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_CreateLogContext
    __del__ = lambda self: None

    def show(self, *args):
        """
        show(CreateLogContext self, _ostream out)
        show(CreateLogContext self)
        """
        return _IMP_kernel.CreateLogContext_show(self, *args)


    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.reset()
        return False


    def __str__(self):
        """__str__(CreateLogContext self) -> std::string"""
        return _IMP_kernel.CreateLogContext___str__(self)


    def __repr__(self):
        """__repr__(CreateLogContext self) -> std::string"""
        return _IMP_kernel.CreateLogContext___repr__(self)

CreateLogContext_swigregister = _IMP_kernel.CreateLogContext_swigregister
CreateLogContext_swigregister(CreateLogContext)

class SetCheckState(_RAII):
    """Proxy of C++ IMP::SetCheckState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def reset(self):
        """reset(SetCheckState self)"""
        return _IMP_kernel.SetCheckState_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_SetCheckState
    __del__ = lambda self: None

    def show(self, *args):
        """
        show(SetCheckState self, _ostream out)
        show(SetCheckState self)
        """
        return _IMP_kernel.SetCheckState_show(self, *args)


    def __init__(self, *args):
        """
        __init__(IMP::SetCheckState self) -> SetCheckState
        __init__(IMP::SetCheckState self, Object o, IMP::CheckLevel l) -> SetCheckState
        __init__(IMP::SetCheckState self, IMP::CheckLevel l) -> SetCheckState
        """
        this = _IMP_kernel.new_SetCheckState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set(self, *args):
        """
        set(SetCheckState self, Object o, IMP::CheckLevel l)
        set(SetCheckState self, IMP::CheckLevel l)
        """
        return _IMP_kernel.SetCheckState_set(self, *args)


    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.reset()
        return False


    def __str__(self):
        """__str__(SetCheckState self) -> std::string"""
        return _IMP_kernel.SetCheckState___str__(self)


    def __repr__(self):
        """__repr__(SetCheckState self) -> std::string"""
        return _IMP_kernel.SetCheckState___repr__(self)

SetCheckState_swigregister = _IMP_kernel.SetCheckState_swigregister
SetCheckState_swigregister(SetCheckState)


def get_unique_name(templ):
    """get_unique_name(std::string templ) -> std::string"""
    return _IMP_kernel.get_unique_name(templ)
class _Protection(object):
    """Proxy of C++ IMP::internal::_Protection class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def show(self, *args):
        """
        show(_Protection self, _ostream out)
        show(_Protection self)
        """
        return _IMP_kernel._Protection_show(self, *args)


    def __str__(self):
        """__str__(_Protection self) -> std::string"""
        return _IMP_kernel._Protection___str__(self)


    def __repr__(self):
        """__repr__(_Protection self) -> std::string"""
        return _IMP_kernel._Protection___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__Protection
    __del__ = lambda self: None
_Protection_swigregister = _IMP_kernel._Protection_swigregister
_Protection_swigregister(_Protection)


def _test_log():
    """_test_log()"""
    return _IMP_kernel._test_log()

def _test_intranges(ips):
    """_test_intranges(IMP::IntRanges const & ips) -> int"""
    return _IMP_kernel._test_intranges(ips)

def _test_intrange(*args):
    """
    _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
    _test_intrange() -> IMP::IntRange
    """
    return _IMP_kernel._test_intrange(*args)

def _test_ifile(a):
    """_test_ifile(TextInput a) -> std::string"""
    return _IMP_kernel._test_ifile(a)

def _test_ofile(a):
    """_test_ofile(TextOutput a) -> std::string"""
    return _IMP_kernel._test_ofile(a)

def _test_ifile_overloaded(*args):
    """
    _test_ifile_overloaded(TextInput a, int i) -> std::string
    _test_ifile_overloaded(TextInput a, std::string st) -> std::string
    """
    return _IMP_kernel._test_ifile_overloaded(*args)

def _test_ofile_overloaded(*args):
    """
    _test_ofile_overloaded(TextOutput a, int i) -> std::string
    _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
    """
    return _IMP_kernel._test_ofile_overloaded(*args)
class _TestValue(object):
    """Proxy of C++ IMP::internal::_TestValue class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, i):
        """__init__(IMP::internal::_TestValue self, int i) -> _TestValue"""
        this = _IMP_kernel.new__TestValue(i)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(_TestValue self, _ostream out)
        show(_TestValue self)
        """
        return _IMP_kernel._TestValue_show(self, *args)


    def __cmp__(self, o):
        """__cmp__(_TestValue self, _TestValue o) -> int"""
        return _IMP_kernel._TestValue___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_kernel._TestValue___eq__(self, o)


    def __ne__(self, o):
        """__ne__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_kernel._TestValue___ne__(self, o)


    def __lt__(self, o):
        """__lt__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_kernel._TestValue___lt__(self, o)


    def __gt__(self, o):
        """__gt__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_kernel._TestValue___gt__(self, o)


    def __ge__(self, o):
        """__ge__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_kernel._TestValue___ge__(self, o)


    def __le__(self, o):
        """__le__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_kernel._TestValue___le__(self, o)


    def get(self):
        """get(_TestValue self) -> int"""
        return _IMP_kernel._TestValue_get(self)


    def get_float(self):
        """get_float(_TestValue self) -> float const &"""
        return _IMP_kernel._TestValue_get_float(self)


    def get_double(self):
        """get_double(_TestValue self) -> double const &"""
        return _IMP_kernel._TestValue_get_double(self)


    def get_Float(self):
        """get_Float(_TestValue self) -> IMP::Float const &"""
        return _IMP_kernel._TestValue_get_Float(self)


    def get_int(self):
        """get_int(_TestValue self) -> int const &"""
        return _IMP_kernel._TestValue_get_int(self)


    def get_Int(self):
        """get_Int(_TestValue self) -> IMP::Int const &"""
        return _IMP_kernel._TestValue_get_Int(self)


    def get_string(self):
        """get_string(_TestValue self) -> std::string const &"""
        return _IMP_kernel._TestValue_get_string(self)


    def get_String(self):
        """get_String(_TestValue self) -> IMP::String const &"""
        return _IMP_kernel._TestValue_get_String(self)


    def __str__(self):
        """__str__(_TestValue self) -> std::string"""
        return _IMP_kernel._TestValue___str__(self)


    def __repr__(self):
        """__repr__(_TestValue self) -> std::string"""
        return _IMP_kernel._TestValue___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__TestValue
    __del__ = lambda self: None
_TestValue_swigregister = _IMP_kernel._TestValue_swigregister
_TestValue_swigregister(_TestValue)


def _pass_plain_pair(p):
    """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
    return _IMP_kernel._pass_plain_pair(p)

def _pass_overloaded_strings(*args):
    """
    _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
    _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
    """
    return _IMP_kernel._pass_overloaded_strings(*args)

def _pass_pair(p):
    """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
    return _IMP_kernel._pass_pair(p)

def _pass_floats(input):
    """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
    return _IMP_kernel._pass_floats(input)

def _pass_ints(input):
    """_pass_ints(IMP::Ints input) -> IMP::Ints"""
    return _IMP_kernel._pass_ints(input)

def _pass_ints_list(input):
    """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
    return _IMP_kernel._pass_ints_list(input)

def _pass_ints_lists(input):
    """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
    return _IMP_kernel._pass_ints_lists(input)

def _pass_strings(input):
    """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
    return _IMP_kernel._pass_strings(input)
class _TestObject(Object):
    """Proxy of C++ IMP::internal::_TestObject class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self):
        """__init__(IMP::internal::_TestObject self) -> _TestObject"""
        this = _IMP_kernel.new__TestObject()
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(_TestObject self) -> VersionInfo"""
        return _IMP_kernel._TestObject_get_version_info(self)


    def __str__(self):
        """__str__(_TestObject self) -> std::string"""
        return _IMP_kernel._TestObject___str__(self)


    def __repr__(self):
        """__repr__(_TestObject self) -> std::string"""
        return _IMP_kernel._TestObject___repr__(self)


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

_TestObject_swigregister = _IMP_kernel._TestObject_swigregister
_TestObject_swigregister(_TestObject)


def get_live_object_names():
    """get_live_object_names() -> IMP::Strings"""
    return _IMP_kernel.get_live_object_names()

def get_live_objects():
    """get_live_objects() -> IMP::Objects"""
    return _IMP_kernel.get_live_objects()

def set_show_leaked_objects(tf):
    """set_show_leaked_objects(bool tf)"""
    return _IMP_kernel.set_show_leaked_objects(tf)

def set_deprecation_warnings(tf):
    """set_deprecation_warnings(bool tf)"""
    return _IMP_kernel.set_deprecation_warnings(tf)

def set_deprecation_exceptions(tf):
    """set_deprecation_exceptions(bool tf)"""
    return _IMP_kernel.set_deprecation_exceptions(tf)

def get_deprecation_exceptions():
    """get_deprecation_exceptions() -> bool"""
    return _IMP_kernel.get_deprecation_exceptions()

def handle_use_deprecated(message):
    """handle_use_deprecated(std::string message)"""
    return _IMP_kernel.handle_use_deprecated(message)

def get_number_of_threads():
    """get_number_of_threads() -> unsigned int"""
    return _IMP_kernel.get_number_of_threads()

def set_number_of_threads(n):
    """set_number_of_threads(unsigned int n)"""
    return _IMP_kernel.set_number_of_threads(n)
class SetNumberOfThreads(_RAII):
    """Proxy of C++ IMP::SetNumberOfThreads class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::SetNumberOfThreads self) -> SetNumberOfThreads
        __init__(IMP::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
        """
        this = _IMP_kernel.new_SetNumberOfThreads(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set(self, n):
        """set(SetNumberOfThreads self, unsigned int n)"""
        return _IMP_kernel.SetNumberOfThreads_set(self, n)


    def reset(self):
        """reset(SetNumberOfThreads self)"""
        return _IMP_kernel.SetNumberOfThreads_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_SetNumberOfThreads
    __del__ = lambda self: None

    def show(self, *args):
        """
        show(SetNumberOfThreads self, _ostream out)
        show(SetNumberOfThreads self)
        """
        return _IMP_kernel.SetNumberOfThreads_show(self, *args)


    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.reset()
        return False


    def __str__(self):
        """__str__(SetNumberOfThreads self) -> std::string"""
        return _IMP_kernel.SetNumberOfThreads___str__(self)


    def __repr__(self):
        """__repr__(SetNumberOfThreads self) -> std::string"""
        return _IMP_kernel.SetNumberOfThreads___repr__(self)

SetNumberOfThreads_swigregister = _IMP_kernel.SetNumberOfThreads_swigregister
SetNumberOfThreads_swigregister(SetNumberOfThreads)


def clear_statistics():
    """clear_statistics()"""
    return _IMP_kernel.clear_statistics()

def show_timings(out):
    """show_timings(TextOutput out)"""
    return _IMP_kernel.show_timings(out)
class Timer(_RAII):
    """Proxy of C++ IMP::Timer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::Timer self, Object object, std::string const & operation) -> Timer
        __init__(IMP::Timer self, Object object, char const * operation) -> Timer
        __init__(IMP::Timer self, std::string operation) -> Timer
        """
        this = _IMP_kernel.new_Timer(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete_Timer
    __del__ = lambda self: None
Timer_swigregister = _IMP_kernel.Timer_swigregister
Timer_swigregister(Timer)


def set_statistics_level(l):
    """set_statistics_level(IMP::StatisticsLevel l)"""
    return _IMP_kernel.set_statistics_level(l)

import os
i_m_p="IMP_MODULE_PATH"
if i_m_p in os.environ.keys():
  __path__.insert(0, os.environ[i_m_p])

def _forward_add_attribute(self, name, value, opt=None):
    if opt is not None:
        self.get_particle().add_attribute(name, value, opt)
    else:
        self.get_particle().add_attribute(name, value)
def _forward_get_value(self, name):
    self.get_particle().get_value(name)
def _forward_set_value(self, name, value):
    self.get_particle().set_value(name, value)


build="release"


_object_types.append("Constraint")


def _object_cast_to_Constraint(o):
    """_object_cast_to_Constraint(Object o) -> Constraint"""
    return _IMP_kernel._object_cast_to_Constraint(o)

_object_types.append("Undecorator")


def _object_cast_to_Undecorator(o):
    """_object_cast_to_Undecorator(Object o) -> Undecorator"""
    return _IMP_kernel._object_cast_to_Undecorator(o)

_object_types.append("Container")


def _object_cast_to_Container(o):
    """_object_cast_to_Container(Object o) -> Container"""
    return _IMP_kernel._object_cast_to_Container(o)

_object_types.append("Optimizer")


def _object_cast_to_Optimizer(o):
    """_object_cast_to_Optimizer(Object o) -> Optimizer"""
    return _IMP_kernel._object_cast_to_Optimizer(o)

_object_types.append("AttributeOptimizer")


def _object_cast_to_AttributeOptimizer(o):
    """_object_cast_to_AttributeOptimizer(Object o) -> AttributeOptimizer"""
    return _IMP_kernel._object_cast_to_AttributeOptimizer(o)

_object_types.append("OptimizerState")


def _object_cast_to_OptimizerState(o):
    """_object_cast_to_OptimizerState(Object o) -> OptimizerState"""
    return _IMP_kernel._object_cast_to_OptimizerState(o)

_object_types.append("PairContainer")


def _object_cast_to_PairContainer(o):
    """_object_cast_to_PairContainer(Object o) -> PairContainer"""
    return _IMP_kernel._object_cast_to_PairContainer(o)

_object_types.append("PairModifier")


def _object_cast_to_PairModifier(o):
    """_object_cast_to_PairModifier(Object o) -> PairModifier"""
    return _IMP_kernel._object_cast_to_PairModifier(o)

_object_types.append("PairScore")


def _object_cast_to_PairScore(o):
    """_object_cast_to_PairScore(Object o) -> PairScore"""
    return _IMP_kernel._object_cast_to_PairScore(o)

_object_types.append("QuadContainer")


def _object_cast_to_QuadContainer(o):
    """_object_cast_to_QuadContainer(Object o) -> QuadContainer"""
    return _IMP_kernel._object_cast_to_QuadContainer(o)

_object_types.append("QuadModifier")


def _object_cast_to_QuadModifier(o):
    """_object_cast_to_QuadModifier(Object o) -> QuadModifier"""
    return _IMP_kernel._object_cast_to_QuadModifier(o)

_object_types.append("QuadScore")


def _object_cast_to_QuadScore(o):
    """_object_cast_to_QuadScore(Object o) -> QuadScore"""
    return _IMP_kernel._object_cast_to_QuadScore(o)

_object_types.append("Refiner")


def _object_cast_to_Refiner(o):
    """_object_cast_to_Refiner(Object o) -> Refiner"""
    return _IMP_kernel._object_cast_to_Refiner(o)

_object_types.append("Restraint")


def _object_cast_to_Restraint(o):
    """_object_cast_to_Restraint(Object o) -> Restraint"""
    return _IMP_kernel._object_cast_to_Restraint(o)

_object_types.append("Sampler")


def _object_cast_to_Sampler(o):
    """_object_cast_to_Sampler(Object o) -> Sampler"""
    return _IMP_kernel._object_cast_to_Sampler(o)

_object_types.append("ScoreState")


def _object_cast_to_ScoreState(o):
    """_object_cast_to_ScoreState(Object o) -> ScoreState"""
    return _IMP_kernel._object_cast_to_ScoreState(o)

_object_types.append("SingletonContainer")


def _object_cast_to_SingletonContainer(o):
    """_object_cast_to_SingletonContainer(Object o) -> SingletonContainer"""
    return _IMP_kernel._object_cast_to_SingletonContainer(o)

_object_types.append("SingletonModifier")


def _object_cast_to_SingletonModifier(o):
    """_object_cast_to_SingletonModifier(Object o) -> SingletonModifier"""
    return _IMP_kernel._object_cast_to_SingletonModifier(o)

_object_types.append("SingletonScore")


def _object_cast_to_SingletonScore(o):
    """_object_cast_to_SingletonScore(Object o) -> SingletonScore"""
    return _IMP_kernel._object_cast_to_SingletonScore(o)

_object_types.append("TripletContainer")


def _object_cast_to_TripletContainer(o):
    """_object_cast_to_TripletContainer(Object o) -> TripletContainer"""
    return _IMP_kernel._object_cast_to_TripletContainer(o)

_object_types.append("TripletModifier")


def _object_cast_to_TripletModifier(o):
    """_object_cast_to_TripletModifier(Object o) -> TripletModifier"""
    return _IMP_kernel._object_cast_to_TripletModifier(o)

_object_types.append("TripletScore")


def _object_cast_to_TripletScore(o):
    """_object_cast_to_TripletScore(Object o) -> TripletScore"""
    return _IMP_kernel._object_cast_to_TripletScore(o)

_object_types.append("UnaryFunction")


def _object_cast_to_UnaryFunction(o):
    """_object_cast_to_UnaryFunction(Object o) -> UnaryFunction"""
    return _IMP_kernel._object_cast_to_UnaryFunction(o)

_object_types.append("ConfigurationSet")


def _object_cast_to_ConfigurationSet(o):
    """_object_cast_to_ConfigurationSet(Object o) -> ConfigurationSet"""
    return _IMP_kernel._object_cast_to_ConfigurationSet(o)

_object_types.append("Configuration")


def _object_cast_to_Configuration(o):
    """_object_cast_to_Configuration(Object o) -> Configuration"""
    return _IMP_kernel._object_cast_to_Configuration(o)

_object_types.append("Model")


def _object_cast_to_Model(o):
    """_object_cast_to_Model(Object o) -> Model"""
    return _IMP_kernel._object_cast_to_Model(o)

_object_types.append("Particle")


def _object_cast_to_Particle(o):
    """_object_cast_to_Particle(Object o) -> Particle"""
    return _IMP_kernel._object_cast_to_Particle(o)

_object_types.append("RestraintSet")


def _object_cast_to_RestraintSet(o):
    """_object_cast_to_RestraintSet(Object o) -> RestraintSet"""
    return _IMP_kernel._object_cast_to_RestraintSet(o)

ParticlePairsTemp=list
_plural_types.append("ParticlePairsTemp")
_value_types.append("ParticlePair")


ParticleTripletsTemp=list
_plural_types.append("ParticleTripletsTemp")
_value_types.append("ParticleTriplet")


ParticleQuadsTemp=list
_plural_types.append("ParticleQuadsTemp")
_value_types.append("ParticleQuad")


ParticleIndexPairs=list
_plural_types.append("ParticleIndexPairs")
_value_types.append("ParticleIndexPair")


ParticleIndexTriplets=list
_plural_types.append("ParticleIndexTriplets")
_value_types.append("ParticleIndexTriplet")


ParticleIndexQuads=list
_plural_types.append("ParticleIndexQuads")
_value_types.append("ParticleIndexQuad")


_object_types.append("SingletonPredicate")


def _object_cast_to_SingletonPredicate(o):
    """_object_cast_to_SingletonPredicate(Object o) -> SingletonPredicate"""
    return _IMP_kernel._object_cast_to_SingletonPredicate(o)

_object_types.append("PairPredicate")


def _object_cast_to_PairPredicate(o):
    """_object_cast_to_PairPredicate(Object o) -> PairPredicate"""
    return _IMP_kernel._object_cast_to_PairPredicate(o)

_object_types.append("TripletPredicate")


def _object_cast_to_TripletPredicate(o):
    """_object_cast_to_TripletPredicate(Object o) -> TripletPredicate"""
    return _IMP_kernel._object_cast_to_TripletPredicate(o)

_object_types.append("QuadPredicate")


def _object_cast_to_QuadPredicate(o):
    """_object_cast_to_QuadPredicate(Object o) -> QuadPredicate"""
    return _IMP_kernel._object_cast_to_QuadPredicate(o)

_object_types.append("SaveToConfigurationSetOptimizerState")


def _object_cast_to_SaveToConfigurationSetOptimizerState(o):
    """_object_cast_to_SaveToConfigurationSetOptimizerState(Object o) -> SaveToConfigurationSetOptimizerState"""
    return _IMP_kernel._object_cast_to_SaveToConfigurationSetOptimizerState(o)

EvaluationStates=list
_plural_types.append("EvaluationStates")
_value_types.append("EvaluationState")


ScoreAccumulators=list
_plural_types.append("ScoreAccumulators")
_value_types.append("ScoreAccumulator")


ParticleIndexes=list
_plural_types.append("ParticleIndexes")
_value_types.append("ParticleIndex")


FloatIndexes=list
_plural_types.append("FloatIndexes")
_value_types.append("FloatIndex")


FloatKeys=list
_plural_types.append("FloatKeys")
_value_types.append("FloatKey")


IntKeys=list
_plural_types.append("IntKeys")
_value_types.append("IntKey")


StringKeys=list
_plural_types.append("StringKeys")
_value_types.append("StringKey")


ParticleIndexKeys=list
_plural_types.append("ParticleIndexKeys")
_value_types.append("ParticleIndexKey")


ParticleIndexesKeys=list
_plural_types.append("ParticleIndexesKeys")
_value_types.append("ParticleIndexesKey")


ObjectKeys=list
_plural_types.append("ObjectKeys")
_value_types.append("ObjectKey")


ModelKeys=list
_plural_types.append("ModelKeys")
_value_types.append("ModelKey")


_raii_types.append("ScopedSetFloatAttribute")


_object_types.append("ScoringFunction")


def _object_cast_to_ScoringFunction(o):
    """_object_cast_to_ScoringFunction(Object o) -> ScoringFunction"""
    return _IMP_kernel._object_cast_to_ScoringFunction(o)

_object_types.append("ModelObject")


def _object_cast_to_ModelObject(o):
    """_object_cast_to_ModelObject(Object o) -> ModelObject"""
    return _IMP_kernel._object_cast_to_ModelObject(o)

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


_value_types.append("_TrivialDecorator")


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


_value_types.append("_TrivialDerivedDecorator")


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


_value_types.append("_TrivialTraitsDecorator")


_object_types.append("_ConstRestraint")


def _object_cast_to__ConstRestraint(o):
    """_object_cast_to__ConstRestraint(Object o) -> _ConstRestraint"""
    return _IMP_kernel._object_cast_to__ConstRestraint(o)

_object_types.append("_ConstOptimizer")


def _object_cast_to__ConstOptimizer(o):
    """_object_cast_to__ConstOptimizer(Object o) -> _ConstOptimizer"""
    return _IMP_kernel._object_cast_to__ConstOptimizer(o)
class DependencyGraph(Object):
    """Proxy of C++ IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(IMP::internal::BoostDigraph<(IMP::DependencyGraph,p.IMP::ModelObject,IMP::ShowDependencyGraphVertex)> self) -> DependencyGraph"""
        this = _IMP_kernel.new_DependencyGraph()
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_graph(self):
        """get_graph(DependencyGraph self) -> IMP::DependencyGraph const &"""
        return _IMP_kernel.DependencyGraph_get_graph(self)


    def get_vertices(self):
        """get_vertices(DependencyGraph self) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
        return _IMP_kernel.DependencyGraph_get_vertices(self)


    def get_vertex_name(self, i):
        """get_vertex_name(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor i) -> ModelObject"""
        return _IMP_kernel.DependencyGraph_get_vertex_name(self, i)


    def get_in_neighbors(self, v):
        """get_in_neighbors(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
        return _IMP_kernel.DependencyGraph_get_in_neighbors(self, v)


    def get_out_neighbors(self, v):
        """get_out_neighbors(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptors"""
        return _IMP_kernel.DependencyGraph_get_out_neighbors(self, v)


    def show_graphviz(self, *args):
        """
        show_graphviz(DependencyGraph self, _ostream out)
        show_graphviz(DependencyGraph self)
        """
        return _IMP_kernel.DependencyGraph_show_graphviz(self, *args)


    def get_graphviz_string(self):
        """get_graphviz_string(DependencyGraph self) -> std::string"""
        return _IMP_kernel.DependencyGraph_get_graphviz_string(self)


    def add_edge(self, v0, v1):
        """add_edge(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v0, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor v1)"""
        return _IMP_kernel.DependencyGraph_add_edge(self, v0, v1)


    def add_vertex(self, l):
        """add_vertex(DependencyGraph self, ModelObject l) -> IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor"""
        return _IMP_kernel.DependencyGraph_add_vertex(self, l)


    def remove_vertex(self, l):
        """remove_vertex(DependencyGraph self, IMP::internal::BoostDigraph< IMP::DependencyGraph,IMP::ModelObject *,IMP::ShowDependencyGraphVertex >::VertexDescriptor l)"""
        return _IMP_kernel.DependencyGraph_remove_vertex(self, l)

    __swig_destroy__ = _IMP_kernel.delete_DependencyGraph
    __del__ = lambda self: None
DependencyGraph_swigregister = _IMP_kernel.DependencyGraph_swigregister
DependencyGraph_swigregister(DependencyGraph)


_value_types.append("DependencyGraph")

class FloatKey(_Value):
    """Proxy of C++ IMP::Key<(0,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Key<(0,true)> self) -> FloatKey
        __init__(IMP::Key<(0,true)> self, std::string c) -> FloatKey
        __init__(IMP::Key<(0,true)> self, unsigned int i) -> FloatKey
        """
        this = _IMP_kernel.new_FloatKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.FloatKey_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.FloatKey_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(FloatKey self) -> std::string const"""
        return _IMP_kernel.FloatKey_get_string(self)


    def __cmp__(self, o):
        """__cmp__(FloatKey self, FloatKey o) -> int"""
        return _IMP_kernel.FloatKey___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___eq__(self, o)


    def __ne__(self, o):
        """__ne__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___ne__(self, o)


    def __lt__(self, o):
        """__lt__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___lt__(self, o)


    def __gt__(self, o):
        """__gt__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___gt__(self, o)


    def __ge__(self, o):
        """__ge__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___ge__(self, o)


    def __le__(self, o):
        """__le__(FloatKey self, FloatKey o) -> bool"""
        return _IMP_kernel.FloatKey___le__(self, o)


    def __hash__(self):
        """__hash__(FloatKey self) -> std::size_t"""
        return _IMP_kernel.FloatKey___hash__(self)


    def show(self, *args):
        """
        show(FloatKey self, _ostream out)
        show(FloatKey self)
        """
        return _IMP_kernel.FloatKey_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
        return _IMP_kernel.FloatKey_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(FloatKey self) -> unsigned int"""
        return _IMP_kernel.FloatKey_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_kernel.FloatKey_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_kernel.FloatKey_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.FloatKey_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(FloatKey self) -> std::string"""
        return _IMP_kernel.FloatKey___str__(self)


    def __repr__(self):
        """__repr__(FloatKey self) -> std::string"""
        return _IMP_kernel.FloatKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_FloatKey
    __del__ = lambda self: None
FloatKey_swigregister = _IMP_kernel.FloatKey_swigregister
FloatKey_swigregister(FloatKey)

def FloatKey_add_key(sc):
    """FloatKey_add_key(std::string sc) -> unsigned int"""
    return _IMP_kernel.FloatKey_add_key(sc)

def FloatKey_get_key_exists(sc):
    """FloatKey_get_key_exists(std::string sc) -> bool"""
    return _IMP_kernel.FloatKey_get_key_exists(sc)

def FloatKey_add_alias(old_key, new_name):
    """FloatKey_add_alias(FloatKey old_key, std::string new_name) -> FloatKey"""
    return _IMP_kernel.FloatKey_add_alias(old_key, new_name)

def FloatKey_show_all(out):
    """FloatKey_show_all(_ostream out)"""
    return _IMP_kernel.FloatKey_show_all(out)

def FloatKey_get_all_strings():
    """FloatKey_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_kernel.FloatKey_get_all_strings()

def FloatKey_get_number_unique():
    """FloatKey_get_number_unique() -> unsigned int"""
    return _IMP_kernel.FloatKey_get_number_unique()

class IntKey(_Value):
    """Proxy of C++ IMP::Key<(1,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Key<(1,true)> self) -> IntKey
        __init__(IMP::Key<(1,true)> self, std::string c) -> IntKey
        __init__(IMP::Key<(1,true)> self, unsigned int i) -> IntKey
        """
        this = _IMP_kernel.new_IntKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.IntKey_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.IntKey_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(IntKey self) -> std::string const"""
        return _IMP_kernel.IntKey_get_string(self)


    def __cmp__(self, o):
        """__cmp__(IntKey self, IntKey o) -> int"""
        return _IMP_kernel.IntKey___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___eq__(self, o)


    def __ne__(self, o):
        """__ne__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___ne__(self, o)


    def __lt__(self, o):
        """__lt__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___lt__(self, o)


    def __gt__(self, o):
        """__gt__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___gt__(self, o)


    def __ge__(self, o):
        """__ge__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___ge__(self, o)


    def __le__(self, o):
        """__le__(IntKey self, IntKey o) -> bool"""
        return _IMP_kernel.IntKey___le__(self, o)


    def __hash__(self):
        """__hash__(IntKey self) -> std::size_t"""
        return _IMP_kernel.IntKey___hash__(self)


    def show(self, *args):
        """
        show(IntKey self, _ostream out)
        show(IntKey self)
        """
        return _IMP_kernel.IntKey_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(IntKey old_key, std::string new_name) -> IntKey"""
        return _IMP_kernel.IntKey_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(IntKey self) -> unsigned int"""
        return _IMP_kernel.IntKey_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_kernel.IntKey_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_kernel.IntKey_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.IntKey_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(IntKey self) -> std::string"""
        return _IMP_kernel.IntKey___str__(self)


    def __repr__(self):
        """__repr__(IntKey self) -> std::string"""
        return _IMP_kernel.IntKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_IntKey
    __del__ = lambda self: None
IntKey_swigregister = _IMP_kernel.IntKey_swigregister
IntKey_swigregister(IntKey)

def IntKey_add_key(sc):
    """IntKey_add_key(std::string sc) -> unsigned int"""
    return _IMP_kernel.IntKey_add_key(sc)

def IntKey_get_key_exists(sc):
    """IntKey_get_key_exists(std::string sc) -> bool"""
    return _IMP_kernel.IntKey_get_key_exists(sc)

def IntKey_add_alias(old_key, new_name):
    """IntKey_add_alias(IntKey old_key, std::string new_name) -> IntKey"""
    return _IMP_kernel.IntKey_add_alias(old_key, new_name)

def IntKey_show_all(out):
    """IntKey_show_all(_ostream out)"""
    return _IMP_kernel.IntKey_show_all(out)

def IntKey_get_all_strings():
    """IntKey_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_kernel.IntKey_get_all_strings()

def IntKey_get_number_unique():
    """IntKey_get_number_unique() -> unsigned int"""
    return _IMP_kernel.IntKey_get_number_unique()

class StringKey(_Value):
    """Proxy of C++ IMP::Key<(2,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Key<(2,true)> self) -> StringKey
        __init__(IMP::Key<(2,true)> self, std::string c) -> StringKey
        __init__(IMP::Key<(2,true)> self, unsigned int i) -> StringKey
        """
        this = _IMP_kernel.new_StringKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.StringKey_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.StringKey_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(StringKey self) -> std::string const"""
        return _IMP_kernel.StringKey_get_string(self)


    def __cmp__(self, o):
        """__cmp__(StringKey self, StringKey o) -> int"""
        return _IMP_kernel.StringKey___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___eq__(self, o)


    def __ne__(self, o):
        """__ne__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___ne__(self, o)


    def __lt__(self, o):
        """__lt__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___lt__(self, o)


    def __gt__(self, o):
        """__gt__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___gt__(self, o)


    def __ge__(self, o):
        """__ge__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___ge__(self, o)


    def __le__(self, o):
        """__le__(StringKey self, StringKey o) -> bool"""
        return _IMP_kernel.StringKey___le__(self, o)


    def __hash__(self):
        """__hash__(StringKey self) -> std::size_t"""
        return _IMP_kernel.StringKey___hash__(self)


    def show(self, *args):
        """
        show(StringKey self, _ostream out)
        show(StringKey self)
        """
        return _IMP_kernel.StringKey_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(StringKey old_key, std::string new_name) -> StringKey"""
        return _IMP_kernel.StringKey_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(StringKey self) -> unsigned int"""
        return _IMP_kernel.StringKey_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_kernel.StringKey_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_kernel.StringKey_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.StringKey_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(StringKey self) -> std::string"""
        return _IMP_kernel.StringKey___str__(self)


    def __repr__(self):
        """__repr__(StringKey self) -> std::string"""
        return _IMP_kernel.StringKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_StringKey
    __del__ = lambda self: None
StringKey_swigregister = _IMP_kernel.StringKey_swigregister
StringKey_swigregister(StringKey)

def StringKey_add_key(sc):
    """StringKey_add_key(std::string sc) -> unsigned int"""
    return _IMP_kernel.StringKey_add_key(sc)

def StringKey_get_key_exists(sc):
    """StringKey_get_key_exists(std::string sc) -> bool"""
    return _IMP_kernel.StringKey_get_key_exists(sc)

def StringKey_add_alias(old_key, new_name):
    """StringKey_add_alias(StringKey old_key, std::string new_name) -> StringKey"""
    return _IMP_kernel.StringKey_add_alias(old_key, new_name)

def StringKey_show_all(out):
    """StringKey_show_all(_ostream out)"""
    return _IMP_kernel.StringKey_show_all(out)

def StringKey_get_all_strings():
    """StringKey_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_kernel.StringKey_get_all_strings()

def StringKey_get_number_unique():
    """StringKey_get_number_unique() -> unsigned int"""
    return _IMP_kernel.StringKey_get_number_unique()

class ParticleIndexKey(_Value):
    """Proxy of C++ IMP::Key<(3,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Key<(3,true)> self) -> ParticleIndexKey
        __init__(IMP::Key<(3,true)> self, std::string c) -> ParticleIndexKey
        __init__(IMP::Key<(3,true)> self, unsigned int i) -> ParticleIndexKey
        """
        this = _IMP_kernel.new_ParticleIndexKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.ParticleIndexKey_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(ParticleIndexKey self) -> std::string const"""
        return _IMP_kernel.ParticleIndexKey_get_string(self)


    def __cmp__(self, o):
        """__cmp__(ParticleIndexKey self, ParticleIndexKey o) -> int"""
        return _IMP_kernel.ParticleIndexKey___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___eq__(self, o)


    def __ne__(self, o):
        """__ne__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___ne__(self, o)


    def __lt__(self, o):
        """__lt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___lt__(self, o)


    def __gt__(self, o):
        """__gt__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___gt__(self, o)


    def __ge__(self, o):
        """__ge__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___ge__(self, o)


    def __le__(self, o):
        """__le__(ParticleIndexKey self, ParticleIndexKey o) -> bool"""
        return _IMP_kernel.ParticleIndexKey___le__(self, o)


    def __hash__(self):
        """__hash__(ParticleIndexKey self) -> std::size_t"""
        return _IMP_kernel.ParticleIndexKey___hash__(self)


    def show(self, *args):
        """
        show(ParticleIndexKey self, _ostream out)
        show(ParticleIndexKey self)
        """
        return _IMP_kernel.ParticleIndexKey_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
        return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(ParticleIndexKey self) -> unsigned int"""
        return _IMP_kernel.ParticleIndexKey_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_kernel.ParticleIndexKey_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_kernel.ParticleIndexKey_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.ParticleIndexKey_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(ParticleIndexKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexKey___str__(self)


    def __repr__(self):
        """__repr__(ParticleIndexKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ParticleIndexKey
    __del__ = lambda self: None
ParticleIndexKey_swigregister = _IMP_kernel.ParticleIndexKey_swigregister
ParticleIndexKey_swigregister(ParticleIndexKey)

def ParticleIndexKey_add_key(sc):
    """ParticleIndexKey_add_key(std::string sc) -> unsigned int"""
    return _IMP_kernel.ParticleIndexKey_add_key(sc)

def ParticleIndexKey_get_key_exists(sc):
    """ParticleIndexKey_get_key_exists(std::string sc) -> bool"""
    return _IMP_kernel.ParticleIndexKey_get_key_exists(sc)

def ParticleIndexKey_add_alias(old_key, new_name):
    """ParticleIndexKey_add_alias(ParticleIndexKey old_key, std::string new_name) -> ParticleIndexKey"""
    return _IMP_kernel.ParticleIndexKey_add_alias(old_key, new_name)

def ParticleIndexKey_show_all(out):
    """ParticleIndexKey_show_all(_ostream out)"""
    return _IMP_kernel.ParticleIndexKey_show_all(out)

def ParticleIndexKey_get_all_strings():
    """ParticleIndexKey_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_kernel.ParticleIndexKey_get_all_strings()

def ParticleIndexKey_get_number_unique():
    """ParticleIndexKey_get_number_unique() -> unsigned int"""
    return _IMP_kernel.ParticleIndexKey_get_number_unique()

class ObjectKey(_Value):
    """Proxy of C++ IMP::Key<(4,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Key<(4,true)> self) -> ObjectKey
        __init__(IMP::Key<(4,true)> self, std::string c) -> ObjectKey
        __init__(IMP::Key<(4,true)> self, unsigned int i) -> ObjectKey
        """
        this = _IMP_kernel.new_ObjectKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.ObjectKey_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.ObjectKey_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(ObjectKey self) -> std::string const"""
        return _IMP_kernel.ObjectKey_get_string(self)


    def __cmp__(self, o):
        """__cmp__(ObjectKey self, ObjectKey o) -> int"""
        return _IMP_kernel.ObjectKey___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___eq__(self, o)


    def __ne__(self, o):
        """__ne__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___ne__(self, o)


    def __lt__(self, o):
        """__lt__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___lt__(self, o)


    def __gt__(self, o):
        """__gt__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___gt__(self, o)


    def __ge__(self, o):
        """__ge__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___ge__(self, o)


    def __le__(self, o):
        """__le__(ObjectKey self, ObjectKey o) -> bool"""
        return _IMP_kernel.ObjectKey___le__(self, o)


    def __hash__(self):
        """__hash__(ObjectKey self) -> std::size_t"""
        return _IMP_kernel.ObjectKey___hash__(self)


    def show(self, *args):
        """
        show(ObjectKey self, _ostream out)
        show(ObjectKey self)
        """
        return _IMP_kernel.ObjectKey_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
        return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(ObjectKey self) -> unsigned int"""
        return _IMP_kernel.ObjectKey_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_kernel.ObjectKey_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_kernel.ObjectKey_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.ObjectKey_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(ObjectKey self) -> std::string"""
        return _IMP_kernel.ObjectKey___str__(self)


    def __repr__(self):
        """__repr__(ObjectKey self) -> std::string"""
        return _IMP_kernel.ObjectKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ObjectKey
    __del__ = lambda self: None
ObjectKey_swigregister = _IMP_kernel.ObjectKey_swigregister
ObjectKey_swigregister(ObjectKey)

def ObjectKey_add_key(sc):
    """ObjectKey_add_key(std::string sc) -> unsigned int"""
    return _IMP_kernel.ObjectKey_add_key(sc)

def ObjectKey_get_key_exists(sc):
    """ObjectKey_get_key_exists(std::string sc) -> bool"""
    return _IMP_kernel.ObjectKey_get_key_exists(sc)

def ObjectKey_add_alias(old_key, new_name):
    """ObjectKey_add_alias(ObjectKey old_key, std::string new_name) -> ObjectKey"""
    return _IMP_kernel.ObjectKey_add_alias(old_key, new_name)

def ObjectKey_show_all(out):
    """ObjectKey_show_all(_ostream out)"""
    return _IMP_kernel.ObjectKey_show_all(out)

def ObjectKey_get_all_strings():
    """ObjectKey_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_kernel.ObjectKey_get_all_strings()

def ObjectKey_get_number_unique():
    """ObjectKey_get_number_unique() -> unsigned int"""
    return _IMP_kernel.ObjectKey_get_number_unique()

class ParticleIndexesKey(_Value):
    """Proxy of C++ IMP::Key<(6,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Key<(6,true)> self) -> ParticleIndexesKey
        __init__(IMP::Key<(6,true)> self, std::string c) -> ParticleIndexesKey
        __init__(IMP::Key<(6,true)> self, unsigned int i) -> ParticleIndexesKey
        """
        this = _IMP_kernel.new_ParticleIndexesKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.ParticleIndexesKey_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(ParticleIndexesKey self) -> std::string const"""
        return _IMP_kernel.ParticleIndexesKey_get_string(self)


    def __cmp__(self, o):
        """__cmp__(ParticleIndexesKey self, ParticleIndexesKey o) -> int"""
        return _IMP_kernel.ParticleIndexesKey___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___eq__(self, o)


    def __ne__(self, o):
        """__ne__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___ne__(self, o)


    def __lt__(self, o):
        """__lt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___lt__(self, o)


    def __gt__(self, o):
        """__gt__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___gt__(self, o)


    def __ge__(self, o):
        """__ge__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___ge__(self, o)


    def __le__(self, o):
        """__le__(ParticleIndexesKey self, ParticleIndexesKey o) -> bool"""
        return _IMP_kernel.ParticleIndexesKey___le__(self, o)


    def __hash__(self):
        """__hash__(ParticleIndexesKey self) -> std::size_t"""
        return _IMP_kernel.ParticleIndexesKey___hash__(self)


    def show(self, *args):
        """
        show(ParticleIndexesKey self, _ostream out)
        show(ParticleIndexesKey self)
        """
        return _IMP_kernel.ParticleIndexesKey_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
        return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(ParticleIndexesKey self) -> unsigned int"""
        return _IMP_kernel.ParticleIndexesKey_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_kernel.ParticleIndexesKey_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_kernel.ParticleIndexesKey_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.ParticleIndexesKey_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(ParticleIndexesKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexesKey___str__(self)


    def __repr__(self):
        """__repr__(ParticleIndexesKey self) -> std::string"""
        return _IMP_kernel.ParticleIndexesKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ParticleIndexesKey
    __del__ = lambda self: None
ParticleIndexesKey_swigregister = _IMP_kernel.ParticleIndexesKey_swigregister
ParticleIndexesKey_swigregister(ParticleIndexesKey)

def ParticleIndexesKey_add_key(sc):
    """ParticleIndexesKey_add_key(std::string sc) -> unsigned int"""
    return _IMP_kernel.ParticleIndexesKey_add_key(sc)

def ParticleIndexesKey_get_key_exists(sc):
    """ParticleIndexesKey_get_key_exists(std::string sc) -> bool"""
    return _IMP_kernel.ParticleIndexesKey_get_key_exists(sc)

def ParticleIndexesKey_add_alias(old_key, new_name):
    """ParticleIndexesKey_add_alias(ParticleIndexesKey old_key, std::string new_name) -> ParticleIndexesKey"""
    return _IMP_kernel.ParticleIndexesKey_add_alias(old_key, new_name)

def ParticleIndexesKey_show_all(out):
    """ParticleIndexesKey_show_all(_ostream out)"""
    return _IMP_kernel.ParticleIndexesKey_show_all(out)

def ParticleIndexesKey_get_all_strings():
    """ParticleIndexesKey_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_kernel.ParticleIndexesKey_get_all_strings()

def ParticleIndexesKey_get_number_unique():
    """ParticleIndexesKey_get_number_unique() -> unsigned int"""
    return _IMP_kernel.ParticleIndexesKey_get_number_unique()

class ModelKey(_Value):
    """Proxy of C++ IMP::Key<(8,true)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Key<(8,true)> self) -> ModelKey
        __init__(IMP::Key<(8,true)> self, std::string c) -> ModelKey
        __init__(IMP::Key<(8,true)> self, unsigned int i) -> ModelKey
        """
        this = _IMP_kernel.new_ModelKey(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_kernel.ModelKey_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_kernel.ModelKey_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(ModelKey self) -> std::string const"""
        return _IMP_kernel.ModelKey_get_string(self)


    def __cmp__(self, o):
        """__cmp__(ModelKey self, ModelKey o) -> int"""
        return _IMP_kernel.ModelKey___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(ModelKey self, ModelKey o) -> bool"""
        return _IMP_kernel.ModelKey___eq__(self, o)


    def __ne__(self, o):
        """__ne__(ModelKey self, ModelKey o) -> bool"""
        return _IMP_kernel.ModelKey___ne__(self, o)


    def __lt__(self, o):
        """__lt__(ModelKey self, ModelKey o) -> bool"""
        return _IMP_kernel.ModelKey___lt__(self, o)


    def __gt__(self, o):
        """__gt__(ModelKey self, ModelKey o) -> bool"""
        return _IMP_kernel.ModelKey___gt__(self, o)


    def __ge__(self, o):
        """__ge__(ModelKey self, ModelKey o) -> bool"""
        return _IMP_kernel.ModelKey___ge__(self, o)


    def __le__(self, o):
        """__le__(ModelKey self, ModelKey o) -> bool"""
        return _IMP_kernel.ModelKey___le__(self, o)


    def __hash__(self):
        """__hash__(ModelKey self) -> std::size_t"""
        return _IMP_kernel.ModelKey___hash__(self)


    def show(self, *args):
        """
        show(ModelKey self, _ostream out)
        show(ModelKey self)
        """
        return _IMP_kernel.ModelKey_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
        return _IMP_kernel.ModelKey_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(ModelKey self) -> unsigned int"""
        return _IMP_kernel.ModelKey_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_kernel.ModelKey_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_kernel.ModelKey_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_kernel.ModelKey_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(ModelKey self) -> std::string"""
        return _IMP_kernel.ModelKey___str__(self)


    def __repr__(self):
        """__repr__(ModelKey self) -> std::string"""
        return _IMP_kernel.ModelKey___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ModelKey
    __del__ = lambda self: None
ModelKey_swigregister = _IMP_kernel.ModelKey_swigregister
ModelKey_swigregister(ModelKey)

def ModelKey_add_key(sc):
    """ModelKey_add_key(std::string sc) -> unsigned int"""
    return _IMP_kernel.ModelKey_add_key(sc)

def ModelKey_get_key_exists(sc):
    """ModelKey_get_key_exists(std::string sc) -> bool"""
    return _IMP_kernel.ModelKey_get_key_exists(sc)

def ModelKey_add_alias(old_key, new_name):
    """ModelKey_add_alias(ModelKey old_key, std::string new_name) -> ModelKey"""
    return _IMP_kernel.ModelKey_add_alias(old_key, new_name)

def ModelKey_show_all(out):
    """ModelKey_show_all(_ostream out)"""
    return _IMP_kernel.ModelKey_show_all(out)

def ModelKey_get_all_strings():
    """ModelKey_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_kernel.ModelKey_get_all_strings()

def ModelKey_get_number_unique():
    """ModelKey_get_number_unique() -> unsigned int"""
    return _IMP_kernel.ModelKey_get_number_unique()

class ParticleIndex(_Value):
    """Proxy of C++ IMP::Index<(IMP::ParticleIndexTag)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Index<(IMP::ParticleIndexTag)> self, int i) -> ParticleIndex
        __init__(IMP::Index<(IMP::ParticleIndexTag)> self) -> ParticleIndex
        """
        this = _IMP_kernel.new_ParticleIndex(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_index(self):
        """get_index(ParticleIndex self) -> int"""
        return _IMP_kernel.ParticleIndex_get_index(self)


    def __cmp__(self, o):
        """__cmp__(ParticleIndex self, ParticleIndex o) -> int"""
        return _IMP_kernel.ParticleIndex___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___eq__(self, o)


    def __ne__(self, o):
        """__ne__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___ne__(self, o)


    def __lt__(self, o):
        """__lt__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___lt__(self, o)


    def __gt__(self, o):
        """__gt__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___gt__(self, o)


    def __ge__(self, o):
        """__ge__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___ge__(self, o)


    def __le__(self, o):
        """__le__(ParticleIndex self, ParticleIndex o) -> bool"""
        return _IMP_kernel.ParticleIndex___le__(self, o)


    def show(self, *args):
        """
        show(ParticleIndex self, _ostream out)
        show(ParticleIndex self)
        """
        return _IMP_kernel.ParticleIndex_show(self, *args)


    def __hash__(self):
        """__hash__(ParticleIndex self) -> std::size_t"""
        return _IMP_kernel.ParticleIndex___hash__(self)


    def __str__(self):
        """__str__(ParticleIndex self) -> std::string"""
        return _IMP_kernel.ParticleIndex___str__(self)


    def __repr__(self):
        """__repr__(ParticleIndex self) -> std::string"""
        return _IMP_kernel.ParticleIndex___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ParticleIndex
    __del__ = lambda self: None
ParticleIndex_swigregister = _IMP_kernel.ParticleIndex_swigregister
ParticleIndex_swigregister(ParticleIndex)


def ParticlePair(a, b):
  return (a,b)
def ParticleTriplet(a, b, c):
  return (a,b,c)
def ParticleQuad(a, b, c, d):
  return (a,b,c,d)

class FloatIndex(_Value):
    """Proxy of C++ IMP::FloatIndex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::FloatIndex self, ParticleIndex i0, FloatKey i1) -> FloatIndex
        __init__(IMP::FloatIndex self, ParticleIndex i0) -> FloatIndex
        __init__(IMP::FloatIndex self) -> FloatIndex
        """
        this = _IMP_kernel.new_FloatIndex(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __hash__(self):
        """__hash__(FloatIndex self) -> std::size_t"""
        return _IMP_kernel.FloatIndex___hash__(self)


    def show(self, *args):
        """
        show(FloatIndex self, _ostream out)
        show(FloatIndex self)
        """
        return _IMP_kernel.FloatIndex_show(self, *args)


    def __cmp__(self, o):
        """__cmp__(FloatIndex self, FloatIndex o) -> int"""
        return _IMP_kernel.FloatIndex___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___eq__(self, o)


    def __ne__(self, o):
        """__ne__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___ne__(self, o)


    def __lt__(self, o):
        """__lt__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___lt__(self, o)


    def __gt__(self, o):
        """__gt__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___gt__(self, o)


    def __ge__(self, o):
        """__ge__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___ge__(self, o)


    def __le__(self, o):
        """__le__(FloatIndex self, FloatIndex o) -> bool"""
        return _IMP_kernel.FloatIndex___le__(self, o)


    def get_particle(self):
        """get_particle(FloatIndex self) -> ParticleIndex const &"""
        return _IMP_kernel.FloatIndex_get_particle(self)


    def set_particle(self, v):
        """set_particle(FloatIndex self, ParticleIndex const & v)"""
        return _IMP_kernel.FloatIndex_set_particle(self, v)


    def get_key(self):
        """get_key(FloatIndex self) -> FloatKey const &"""
        return _IMP_kernel.FloatIndex_get_key(self)


    def set_key(self, v):
        """set_key(FloatIndex self, FloatKey const & v)"""
        return _IMP_kernel.FloatIndex_set_key(self, v)


    def __str__(self):
        """__str__(FloatIndex self) -> std::string"""
        return _IMP_kernel.FloatIndex___str__(self)


    def __repr__(self):
        """__repr__(FloatIndex self) -> std::string"""
        return _IMP_kernel.FloatIndex___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_FloatIndex
    __del__ = lambda self: None
FloatIndex_swigregister = _IMP_kernel.FloatIndex_swigregister
FloatIndex_swigregister(FloatIndex)

class _ParticleIndexTag(object):
    """Proxy of C++ IMP::ParticleIndexTag class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(IMP::ParticleIndexTag self) -> _ParticleIndexTag"""
        this = _IMP_kernel.new__ParticleIndexTag()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexTag
    __del__ = lambda self: None
_ParticleIndexTag_swigregister = _IMP_kernel._ParticleIndexTag_swigregister
_ParticleIndexTag_swigregister(_ParticleIndexTag)

class ModelObject(Object):
    """Proxy of C++ IMP::ModelObject class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, name):
        """__init__(IMP::ModelObject self, Model m, std::string name) -> ModelObject"""
        if self.__class__ == ModelObject:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_ModelObject(_self, m, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != ModelObject:
            _director_objects.register(self)



    __swig_destroy__ = _IMP_kernel.delete_ModelObject
    __del__ = lambda self: None

    def get_model(self):
        """get_model(ModelObject self) -> Model"""
        return _IMP_kernel.ModelObject_get_model(self)


    def get_inputs(self):
        """get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_get_inputs(self)


    def get_outputs(self):
        """get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_get_outputs(self)


    def get_interactions(self):
        """get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.ModelObject_get_interactions(self)


    def get_has_dependencies(self):
        """get_has_dependencies(ModelObject self) -> bool"""
        return _IMP_kernel.ModelObject_get_has_dependencies(self)


    def set_has_dependencies(self, tf):
        """set_has_dependencies(ModelObject self, bool tf)"""
        return _IMP_kernel.ModelObject_set_has_dependencies(self, tf)


    def set_has_required_score_states(self, tf):
        """set_has_required_score_states(ModelObject self, bool tf)"""
        return _IMP_kernel.ModelObject_set_has_required_score_states(self, tf)


    def get_has_required_score_states(self):
        """get_has_required_score_states(ModelObject self) -> bool"""
        return _IMP_kernel.ModelObject_get_has_required_score_states(self)


    def get_required_score_states(self):
        """get_required_score_states(ModelObject self) -> IMP::ScoreStatesTemp const &"""
        return _IMP_kernel.ModelObject_get_required_score_states(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(ModelObject self, bool arg0)"""
        return _IMP_kernel.ModelObject_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(ModelObject self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(ModelObject self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ModelObject_do_get_outputs(self)


    def do_get_interactions(self):
        """do_get_interactions(ModelObject self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.ModelObject_do_get_interactions(self)


    def __str__(self):
        """__str__(ModelObject self) -> std::string"""
        return _IMP_kernel.ModelObject___str__(self)


    def __repr__(self):
        """__repr__(ModelObject self) -> std::string"""
        return _IMP_kernel.ModelObject___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_ModelObject(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_ModelObject(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(ModelObject self)"""
        return _IMP_kernel.ModelObject_do_destroy(self)

ModelObject_swigregister = _IMP_kernel.ModelObject_swigregister
ModelObject_swigregister(ModelObject)
cvar = _IMP_kernel.cvar
NO_MAX = cvar.NO_MAX
BAD_SCORE = cvar.BAD_SCORE

class _ParticleInputs(object):
    """Proxy of C++ IMP::ParticleInputs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def get_inputs(self, m, pis):
        """get_inputs(_ParticleInputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel._ParticleInputs_get_inputs(self, m, pis)

_ParticleInputs_swigregister = _IMP_kernel._ParticleInputs_swigregister
_ParticleInputs_swigregister(_ParticleInputs)

class _ParticleOutputs(object):
    """Proxy of C++ IMP::ParticleOutputs class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def get_outputs(self, m, pis):
        """get_outputs(_ParticleOutputs self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel._ParticleOutputs_get_outputs(self, m, pis)

_ParticleOutputs_swigregister = _IMP_kernel._ParticleOutputs_swigregister
_ParticleOutputs_swigregister(_ParticleOutputs)


def get_input_particles(mos):
    """get_input_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
    return _IMP_kernel.get_input_particles(mos)

def get_input_containers(mos):
    """get_input_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
    return _IMP_kernel.get_input_containers(mos)

def get_output_particles(mos):
    """get_output_particles(IMP::ModelObjectsTemp const & mos) -> IMP::ParticlesTemp"""
    return _IMP_kernel.get_output_particles(mos)

def get_output_containers(mos):
    """get_output_containers(IMP::ModelObjectsTemp const & mos) -> IMP::ContainersTemp"""
    return _IMP_kernel.get_output_containers(mos)
class DerivativeAccumulator(object):
    """Proxy of C++ IMP::DerivativeAccumulator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::DerivativeAccumulator self, double weight=1.0) -> DerivativeAccumulator
        __init__(IMP::DerivativeAccumulator self) -> DerivativeAccumulator
        __init__(IMP::DerivativeAccumulator self, DerivativeAccumulator copy, double weight) -> DerivativeAccumulator
        """
        this = _IMP_kernel.new_DerivativeAccumulator(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, value):
        """__call__(DerivativeAccumulator self, double const value) -> double"""
        return _IMP_kernel.DerivativeAccumulator___call__(self, value)


    def get_weight(self):
        """get_weight(DerivativeAccumulator self) -> double"""
        return _IMP_kernel.DerivativeAccumulator_get_weight(self)


    def show(self, *args):
        """
        show(DerivativeAccumulator self, _ostream out)
        show(DerivativeAccumulator self)
        """
        return _IMP_kernel.DerivativeAccumulator_show(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_DerivativeAccumulator
    __del__ = lambda self: None
DerivativeAccumulator_swigregister = _IMP_kernel.DerivativeAccumulator_swigregister
DerivativeAccumulator_swigregister(DerivativeAccumulator)

class EvaluationState(object):
    """Proxy of C++ IMP::EvaluationState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    score = _swig_property(_IMP_kernel.EvaluationState_score_get, _IMP_kernel.EvaluationState_score_set)
    good = _swig_property(_IMP_kernel.EvaluationState_good_get, _IMP_kernel.EvaluationState_good_set)

    def __init__(self, *args):
        """
        __init__(IMP::EvaluationState self, double oscore, bool ogood) -> EvaluationState
        __init__(IMP::EvaluationState self) -> EvaluationState
        """
        this = _IMP_kernel.new_EvaluationState(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(EvaluationState self, _ostream out)
        show(EvaluationState self)
        """
        return _IMP_kernel.EvaluationState_show(self, *args)


    def __str__(self):
        """__str__(EvaluationState self) -> std::string"""
        return _IMP_kernel.EvaluationState___str__(self)


    def __repr__(self):
        """__repr__(EvaluationState self) -> std::string"""
        return _IMP_kernel.EvaluationState___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_EvaluationState
    __del__ = lambda self: None
EvaluationState_swigregister = _IMP_kernel.EvaluationState_swigregister
EvaluationState_swigregister(EvaluationState)

class ScoreAccumulator(_Value):
    """Proxy of C++ IMP::ScoreAccumulator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::ScoreAccumulator self) -> ScoreAccumulator
        __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, Restraint r) -> ScoreAccumulator
        __init__(IMP::ScoreAccumulator self, ScoreAccumulator o, double weight, double local_max) -> ScoreAccumulator
        """
        this = _IMP_kernel.new_ScoreAccumulator(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_score(self, score):
        """add_score(ScoreAccumulator self, double score)"""
        return _IMP_kernel.ScoreAccumulator_add_score(self, score)


    def get_abort_evaluation(self):
        """get_abort_evaluation(ScoreAccumulator self) -> bool"""
        return _IMP_kernel.ScoreAccumulator_get_abort_evaluation(self)


    def get_is_evaluate_if_below(self):
        """get_is_evaluate_if_below(ScoreAccumulator self) -> bool"""
        return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_below(self)


    def get_is_evaluate_if_good(self):
        """get_is_evaluate_if_good(ScoreAccumulator self) -> bool"""
        return _IMP_kernel.ScoreAccumulator_get_is_evaluate_if_good(self)


    def get_maximum(self):
        """get_maximum(ScoreAccumulator self) -> double"""
        return _IMP_kernel.ScoreAccumulator_get_maximum(self)


    def get_derivative_accumulator(self):
        """get_derivative_accumulator(ScoreAccumulator self) -> DerivativeAccumulator"""
        return _IMP_kernel.ScoreAccumulator_get_derivative_accumulator(self)


    def show(self, *args):
        """
        show(ScoreAccumulator self, _ostream out)
        show(ScoreAccumulator self)
        """
        return _IMP_kernel.ScoreAccumulator_show(self, *args)


    def __str__(self):
        """__str__(ScoreAccumulator self) -> std::string"""
        return _IMP_kernel.ScoreAccumulator___str__(self)


    def __repr__(self):
        """__repr__(ScoreAccumulator self) -> std::string"""
        return _IMP_kernel.ScoreAccumulator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete_ScoreAccumulator
    __del__ = lambda self: None
ScoreAccumulator_swigregister = _IMP_kernel.ScoreAccumulator_swigregister
ScoreAccumulator_swigregister(ScoreAccumulator)

class ScoreState(ModelObject):
    """Proxy of C++ IMP::ScoreState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, name):
        """__init__(IMP::ScoreState self, Model m, std::string name) -> ScoreState"""
        if self.__class__ == ScoreState:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_ScoreState(_self, m, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != ScoreState:
            _director_objects.register(self)




    def before_evaluate(self):
        """before_evaluate(ScoreState self)"""
        return _IMP_kernel.ScoreState_before_evaluate(self)


    def after_evaluate(self, accpt):
        """after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
        return _IMP_kernel.ScoreState_after_evaluate(self, accpt)


    def get_has_update_order(self):
        """get_has_update_order(ScoreState self) -> bool"""
        return _IMP_kernel.ScoreState_get_has_update_order(self)


    def get_update_order(self):
        """get_update_order(ScoreState self) -> unsigned int"""
        return _IMP_kernel.ScoreState_get_update_order(self)


    def handle_set_has_required_score_states(self, tf):
        """handle_set_has_required_score_states(ScoreState self, bool tf)"""
        return _IMP_kernel.ScoreState_handle_set_has_required_score_states(self, tf)


    def do_before_evaluate(self):
        """do_before_evaluate(ScoreState self)"""
        return _IMP_kernel.ScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, accpt):
        """do_after_evaluate(ScoreState self, DerivativeAccumulator accpt)"""
        return _IMP_kernel.ScoreState_do_after_evaluate(self, accpt)

    __swig_destroy__ = _IMP_kernel.delete_ScoreState
    __del__ = lambda self: None

    def __str__(self):
        """__str__(ScoreState self) -> std::string"""
        return _IMP_kernel.ScoreState___str__(self)


    def __repr__(self):
        """__repr__(ScoreState self) -> std::string"""
        return _IMP_kernel.ScoreState___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_ScoreState(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_ScoreState(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(ScoreState self)"""
        return _IMP_kernel.ScoreState_do_destroy(self)


    def do_get_inputs(self):
        """do_get_inputs(ScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(ScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ScoreState_do_get_outputs(self)


    def do_get_interactions(self):
        """do_get_interactions(ScoreState self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.ScoreState_do_get_interactions(self)

ScoreState_swigregister = _IMP_kernel.ScoreState_swigregister
ScoreState_swigregister(ScoreState)


def get_update_order(input):
    """get_update_order(IMP::ScoreStatesTemp input) -> IMP::ScoreStatesTemp"""
    return _IMP_kernel.get_update_order(input)
class Constraint(ScoreState):
    """Proxy of C++ IMP::Constraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Constraint self, Model m, std::string name) -> Constraint
        __init__(IMP::Constraint self, Model m) -> Constraint
        """
        if self.__class__ == Constraint:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Constraint(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Constraint:
            _director_objects.register(self)




    def do_update_attributes(self):
        """do_update_attributes(Constraint self)"""
        return _IMP_kernel.Constraint_do_update_attributes(self)


    def do_update_derivatives(self, da):
        """do_update_derivatives(Constraint self, DerivativeAccumulator da)"""
        return _IMP_kernel.Constraint_do_update_derivatives(self, da)


    def do_before_evaluate(self):
        """do_before_evaluate(Constraint self)"""
        return _IMP_kernel.Constraint_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(Constraint self, DerivativeAccumulator da)"""
        return _IMP_kernel.Constraint_do_after_evaluate(self, da)

    __swig_destroy__ = _IMP_kernel.delete_Constraint
    __del__ = lambda self: None

    def __str__(self):
        """__str__(Constraint self) -> std::string"""
        return _IMP_kernel.Constraint___str__(self)


    def __repr__(self):
        """__repr__(Constraint self) -> std::string"""
        return _IMP_kernel.Constraint___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Constraint(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Constraint(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(Constraint self)"""
        return _IMP_kernel.Constraint_do_destroy(self)


    def do_get_inputs(self):
        """do_get_inputs(Constraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Constraint_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(Constraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Constraint_do_get_outputs(self)


    def do_get_interactions(self):
        """do_get_interactions(Constraint self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.Constraint_do_get_interactions(self)

Constraint_swigregister = _IMP_kernel.Constraint_swigregister
Constraint_swigregister(Constraint)

class Container(ModelObject):
    """Proxy of C++ IMP::Container class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Container self, Model m, std::string name) -> Container
        __init__(IMP::Container self, Model m) -> Container
        """
        if self.__class__ == Container:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Container(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Container:
            _director_objects.register(self)




    def do_get_contents_hash(self):
        """do_get_contents_hash(Container self) -> std::size_t"""
        return _IMP_kernel.Container_do_get_contents_hash(self)


    def get_all_possible_indexes(self):
        """get_all_possible_indexes(Container self) -> IMP::ParticleIndexes"""
        return _IMP_kernel.Container_get_all_possible_indexes(self)


    def get_contents_hash(self):
        """get_contents_hash(Container self) -> std::size_t"""
        return _IMP_kernel.Container_get_contents_hash(self)


    def do_get_outputs(self):
        """do_get_outputs(Container self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Container_do_get_outputs(self)


    def get_is_decomposable(self):
        """get_is_decomposable(Container self) -> bool"""
        return _IMP_kernel.Container_get_is_decomposable(self)


    def validate_readable(self):
        """validate_readable(Container self)"""
        return _IMP_kernel.Container_validate_readable(self)


    def validate_writable(self):
        """validate_writable(Container self)"""
        return _IMP_kernel.Container_validate_writable(self)


    def set_is_readable(self, tf):
        """set_is_readable(Container self, bool tf)"""
        return _IMP_kernel.Container_set_is_readable(self, tf)


    def set_is_writable(self, tf):
        """set_is_writable(Container self, bool tf)"""
        return _IMP_kernel.Container_set_is_writable(self, tf)

    __swig_destroy__ = _IMP_kernel.delete_Container
    __del__ = lambda self: None

    def __str__(self):
        """__str__(Container self) -> std::string"""
        return _IMP_kernel.Container___str__(self)


    def __repr__(self):
        """__repr__(Container self) -> std::string"""
        return _IMP_kernel.Container___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Container(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Container(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(Container self)"""
        return _IMP_kernel.Container_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(Container self, bool arg0)"""
        return _IMP_kernel.Container_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(Container self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Container_do_get_inputs(self)


    def do_get_interactions(self):
        """do_get_interactions(Container self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.Container_do_get_interactions(self)

Container_swigregister = _IMP_kernel.Container_swigregister
Container_swigregister(Container)

class Restraint(ModelObject):
    """Proxy of C++ IMP::Restraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, name):
        """__init__(IMP::Restraint self, Model m, std::string name) -> Restraint"""
        if self.__class__ == Restraint:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Restraint(_self, m, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Restraint:
            _director_objects.register(self)




    def get_score(self):
        """get_score(Restraint self) -> double"""
        return _IMP_kernel.Restraint_get_score(self)


    def evaluate(self, calc_derivs):
        """evaluate(Restraint self, bool calc_derivs) -> double"""
        return _IMP_kernel.Restraint_evaluate(self, calc_derivs)


    def evaluate_if_good(self, calc_derivatives):
        """evaluate_if_good(Restraint self, bool calc_derivatives) -> double"""
        return _IMP_kernel.Restraint_evaluate_if_good(self, calc_derivatives)


    def evaluate_if_below(self, calc_derivatives, max):
        """evaluate_if_below(Restraint self, bool calc_derivatives, double max) -> double"""
        return _IMP_kernel.Restraint_evaluate_if_below(self, calc_derivatives, max)


    def unprotected_evaluate(self, da):
        """unprotected_evaluate(Restraint self, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.Restraint_unprotected_evaluate(self, da)


    def unprotected_evaluate_if_good(self, da, max):
        """unprotected_evaluate_if_good(Restraint self, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.Restraint_unprotected_evaluate_if_good(self, da, max)


    def unprotected_evaluate_if_below(self, da, max):
        """unprotected_evaluate_if_below(Restraint self, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.Restraint_unprotected_evaluate_if_below(self, da, max)


    def add_score_and_derivatives(self, sa):
        """add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
        return _IMP_kernel.Restraint_add_score_and_derivatives(self, sa)


    def create_decomposition(self):
        """create_decomposition(Restraint self) -> Restraint"""
        return _IMP_kernel.Restraint_create_decomposition(self)


    def create_current_decomposition(self):
        """create_current_decomposition(Restraint self) -> Restraint"""
        return _IMP_kernel.Restraint_create_current_decomposition(self)


    def set_weight(self, weight):
        """set_weight(Restraint self, IMP::Float weight)"""
        return _IMP_kernel.Restraint_set_weight(self, weight)


    def get_weight(self):
        """get_weight(Restraint self) -> IMP::Float"""
        return _IMP_kernel.Restraint_get_weight(self)


    def get_maximum_score(self):
        """get_maximum_score(Restraint self) -> double"""
        return _IMP_kernel.Restraint_get_maximum_score(self)


    def set_maximum_score(self, s):
        """set_maximum_score(Restraint self, double s)"""
        return _IMP_kernel.Restraint_set_maximum_score(self, s)


    def create_scoring_function(self, *args):
        """
        create_scoring_function(Restraint self, double weight=1.0, double max) -> ScoringFunction
        create_scoring_function(Restraint self, double weight=1.0) -> ScoringFunction
        create_scoring_function(Restraint self) -> ScoringFunction
        """
        return _IMP_kernel.Restraint_create_scoring_function(self, *args)


    def set_last_score(self, s):
        """set_last_score(Restraint self, double s)"""
        return _IMP_kernel.Restraint_set_last_score(self, s)


    def get_last_score(self):
        """get_last_score(Restraint self) -> double"""
        return _IMP_kernel.Restraint_get_last_score(self)


    def get_was_good(self):
        """get_was_good(Restraint self) -> bool"""
        return _IMP_kernel.Restraint_get_was_good(self)

    __swig_destroy__ = _IMP_kernel.delete_Restraint
    __del__ = lambda self: None

    def do_create_decomposition(self):
        """do_create_decomposition(Restraint self) -> IMP::Restraints"""
        return _IMP_kernel.Restraint_do_create_decomposition(self)


    def do_create_current_decomposition(self):
        """do_create_current_decomposition(Restraint self) -> IMP::Restraints"""
        return _IMP_kernel.Restraint_do_create_current_decomposition(self)


    def do_add_score_and_derivatives(self, sa):
        """do_add_score_and_derivatives(Restraint self, ScoreAccumulator sa)"""
        return _IMP_kernel.Restraint_do_add_score_and_derivatives(self, sa)


    def do_get_outputs(self):
        """do_get_outputs(Restraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Restraint_do_get_outputs(self)


    def __str__(self):
        """__str__(Restraint self) -> std::string"""
        return _IMP_kernel.Restraint___str__(self)


    def __repr__(self):
        """__repr__(Restraint self) -> std::string"""
        return _IMP_kernel.Restraint___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Restraint(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Restraint(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(Restraint self)"""
        return _IMP_kernel.Restraint_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(Restraint self, bool arg0)"""
        return _IMP_kernel.Restraint_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(Restraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Restraint_do_get_inputs(self)


    def do_get_interactions(self):
        """do_get_interactions(Restraint self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.Restraint_do_get_interactions(self)

Restraint_swigregister = _IMP_kernel.Restraint_swigregister
Restraint_swigregister(Restraint)

class _RestraintsAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::RestraintsAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::RestraintsAdaptor self) -> _RestraintsAdaptor
        __init__(IMP::RestraintsAdaptor self, IMP::Restraints const & sf) -> _RestraintsAdaptor
        __init__(IMP::RestraintsAdaptor self, IMP::RestraintsTemp const & sf) -> _RestraintsAdaptor
        __init__(IMP::RestraintsAdaptor self, Restraint sf) -> _RestraintsAdaptor
        """
        this = _IMP_kernel.new__RestraintsAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__RestraintsAdaptor
    __del__ = lambda self: None
_RestraintsAdaptor_swigregister = _IMP_kernel._RestraintsAdaptor_swigregister
_RestraintsAdaptor_swigregister(_RestraintsAdaptor)

class RestraintSet(Restraint):
    """Proxy of C++ IMP::RestraintSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::RestraintSet self, Model m, double weight, std::string const & name) -> RestraintSet
        __init__(IMP::RestraintSet self, Model m, double weight) -> RestraintSet
        __init__(IMP::RestraintSet self, Model m, std::string const & name) -> RestraintSet
        __init__(IMP::RestraintSet self, Model m) -> RestraintSet
        __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight, std::string const & name) -> RestraintSet
        __init__(IMP::RestraintSet self, IMP::RestraintsTemp const & rs, double weight) -> RestraintSet
        """
        this = _IMP_kernel.new_RestraintSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(RestraintSet self) -> VersionInfo"""
        return _IMP_kernel.RestraintSet_get_version_info(self)


    def remove_restraint(self, d):
        """remove_restraint(RestraintSet self, Restraint d)"""
        return _IMP_kernel.RestraintSet_remove_restraint(self, d)


    def remove_restraints(self, d):
        """remove_restraints(RestraintSet self, IMP::Restraints const & d)"""
        return _IMP_kernel.RestraintSet_remove_restraints(self, d)


    def set_restraints(self, ps):
        """set_restraints(RestraintSet self, IMP::Restraints const & ps)"""
        return _IMP_kernel.RestraintSet_set_restraints(self, ps)


    def set_restraints_order(self, objs):
        """set_restraints_order(RestraintSet self, IMP::Restraints const & objs)"""
        return _IMP_kernel.RestraintSet_set_restraints_order(self, objs)


    def add_restraint(self, obj):
        """add_restraint(RestraintSet self, Restraint obj) -> unsigned int"""
        return _IMP_kernel.RestraintSet_add_restraint(self, obj)


    def add_restraints(self, objs):
        """add_restraints(RestraintSet self, IMP::Restraints const & objs)"""
        return _IMP_kernel.RestraintSet_add_restraints(self, objs)


    def clear_restraints(self):
        """clear_restraints(RestraintSet self)"""
        return _IMP_kernel.RestraintSet_clear_restraints(self)


    def get_number_of_restraints(self):
        """get_number_of_restraints(RestraintSet self) -> unsigned int"""
        return _IMP_kernel.RestraintSet_get_number_of_restraints(self)


    def get_has_restraints(self):
        """get_has_restraints(RestraintSet self) -> bool"""
        return _IMP_kernel.RestraintSet_get_has_restraints(self)


    def get_restraint(self, i):
        """get_restraint(RestraintSet self, unsigned int i) -> Restraint"""
        return _IMP_kernel.RestraintSet_get_restraint(self, i)


    def get_restraints(self):
        """get_restraints(RestraintSet self) -> IMP::Restraints"""
        return _IMP_kernel.RestraintSet_get_restraints(self)


    def reserve_restraints(self, sz):
        """reserve_restraints(RestraintSet self, unsigned int sz)"""
        return _IMP_kernel.RestraintSet_reserve_restraints(self, sz)


    def get_non_sets_and_sets(self):
        """get_non_sets_and_sets(RestraintSet self) -> std::pair< IMP::RestraintsTemp,IMP::RestraintSetsTemp >"""
        return _IMP_kernel.RestraintSet_get_non_sets_and_sets(self)


    def do_get_inputs(self):
        """do_get_inputs(RestraintSet self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.RestraintSet_do_get_inputs(self)


    def create_scoring_function(self, *args):
        """
        create_scoring_function(RestraintSet self, double weight=1.0, double max) -> ScoringFunction
        create_scoring_function(RestraintSet self, double weight=1.0) -> ScoringFunction
        create_scoring_function(RestraintSet self) -> ScoringFunction
        """
        return _IMP_kernel.RestraintSet_create_scoring_function(self, *args)


    def __str__(self):
        """__str__(RestraintSet self) -> std::string"""
        return _IMP_kernel.RestraintSet___str__(self)


    def __repr__(self):
        """__repr__(RestraintSet self) -> std::string"""
        return _IMP_kernel.RestraintSet___repr__(self)


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

RestraintSet_swigregister = _IMP_kernel.RestraintSet_swigregister
RestraintSet_swigregister(RestraintSet)


def get_restraints(rs):
    """get_restraints(IMP::RestraintsTemp const & rs) -> IMP::RestraintsTemp"""
    return _IMP_kernel.get_restraints(rs)

def _check_particle(p, a):
   if (not p.get_is_active()):
      raise ValueError("Inactive Particle")
   if (type(a)() == a):
      raise IndexError("Cannot use default Index")
   if (not p.has_attribute(a)):
      raise IndexError("Particle does not have attribute")

class Particle(ModelObject):
    """Proxy of C++ IMP::Particle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def get_version_info(self):
        """get_version_info(Particle self) -> VersionInfo"""
        return _IMP_kernel.Particle_get_version_info(self)


    def __init__(self, *args):
        """
        __init__(IMP::Particle self, Model m, std::string name) -> Particle
        __init__(IMP::Particle self, Model m) -> Particle
        """
        this = _IMP_kernel.new_Particle(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_float_keys(self):
        """get_float_keys(Particle self) -> IMP::FloatKeys"""
        return _IMP_kernel.Particle_get_float_keys(self)


    def get_int_keys(self):
        """get_int_keys(Particle self) -> IMP::IntKeys"""
        return _IMP_kernel.Particle_get_int_keys(self)


    def get_string_keys(self):
        """get_string_keys(Particle self) -> IMP::StringKeys"""
        return _IMP_kernel.Particle_get_string_keys(self)


    def get_object_keys(self):
        """get_object_keys(Particle self) -> IMP::ObjectKeys"""
        return _IMP_kernel.Particle_get_object_keys(self)


    def add_cache_attribute(self, *args):
        """
        add_cache_attribute(Particle self, FloatKey name, IMP::Float value)
        add_cache_attribute(Particle self, IntKey name, IMP::Int value)
        add_cache_attribute(Particle self, StringKey name, IMP::String value)
        add_cache_attribute(Particle self, ObjectKey name, Object value)
        add_cache_attribute(Particle self, IMP::WeakObjectKey name, Object value)
        """
        return _IMP_kernel.Particle_add_cache_attribute(self, *args)


    def get_weak_object_keys(self):
        """get_weak_object_keys(Particle self) -> IMP::WeakObjectKeys"""
        return _IMP_kernel.Particle_get_weak_object_keys(self)


    def add_to_derivative(self, key, value, da):
        """add_to_derivative(Particle self, FloatKey key, IMP::Float value, DerivativeAccumulator da)"""
        return _IMP_kernel.Particle_add_to_derivative(self, key, value, da)


    def set_is_optimized(self, k, tf):
        """set_is_optimized(Particle self, FloatKey k, bool tf)"""
        return _IMP_kernel.Particle_set_is_optimized(self, k, tf)


    def get_is_optimized(self, k):
        """get_is_optimized(Particle self, FloatKey k) -> bool"""
        return _IMP_kernel.Particle_get_is_optimized(self, k)


    def get_derivative(self, name):
        """get_derivative(Particle self, FloatKey name) -> IMP::Float"""
        return _IMP_kernel.Particle_get_derivative(self, name)


    def add_attribute(self, *args):
        """
        add_attribute(Particle self, FloatKey name, IMP::Float initial_value)
        add_attribute(Particle self, IntKey name, IMP::Int initial_value)
        add_attribute(Particle self, StringKey name, IMP::String initial_value)
        add_attribute(Particle self, ObjectKey name, Object initial_value)
        add_attribute(Particle self, IMP::WeakObjectKey name, Object initial_value)
        add_attribute(Particle self, FloatKey name, IMP::Float const initial_value, bool optimized)
        add_attribute(Particle self, ParticleIndexKey k, Particle v)
        """
        return _IMP_kernel.Particle_add_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Particle self, FloatKey name) -> bool
        has_attribute(Particle self, IntKey name) -> bool
        has_attribute(Particle self, StringKey name) -> bool
        has_attribute(Particle self, ObjectKey name) -> bool
        has_attribute(Particle self, IMP::WeakObjectKey name) -> bool
        has_attribute(Particle self, ParticleIndexKey k) -> bool
        """
        return _IMP_kernel.Particle_has_attribute(self, *args)


    def set_value(self, *args):
        """
        set_value(Particle self, FloatKey name, IMP::Float value)
        set_value(Particle self, IntKey name, IMP::Int value)
        set_value(Particle self, StringKey name, IMP::String value)
        set_value(Particle self, ObjectKey name, Object value)
        set_value(Particle self, IMP::WeakObjectKey name, Object value)
        set_value(Particle self, ParticleIndexKey k, Particle v)
        """
        return _IMP_kernel.Particle_set_value(self, *args)


    def get_value(self, *args):
        """
        get_value(Particle self, FloatKey name) -> IMP::Float
        get_value(Particle self, IntKey name) -> IMP::Int
        get_value(Particle self, StringKey name) -> IMP::String
        get_value(Particle self, ObjectKey name) -> Object
        get_value(Particle self, IMP::WeakObjectKey name) -> Object
        get_value(Particle self, ParticleIndexKey k) -> Particle
        """
        return _IMP_kernel.Particle_get_value(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(Particle self, FloatKey name)
        remove_attribute(Particle self, IntKey name)
        remove_attribute(Particle self, StringKey name)
        remove_attribute(Particle self, ObjectKey name)
        remove_attribute(Particle self, IMP::WeakObjectKey name)
        remove_attribute(Particle self, ParticleIndexKey k)
        """
        return _IMP_kernel.Particle_remove_attribute(self, *args)


    def get_particle_keys(self):
        """get_particle_keys(Particle self) -> IMP::ParticleIndexKeys"""
        return _IMP_kernel.Particle_get_particle_keys(self)


    def show(self, *args):
        """
        show(Particle self, _ostream out)
        show(Particle self)
        """
        return _IMP_kernel.Particle_show(self, *args)


    def get_is_active(self):
        """get_is_active(Particle self) -> bool"""
        return _IMP_kernel.Particle_get_is_active(self)


    def get_index(self):
        """get_index(Particle self) -> ParticleIndex"""
        return _IMP_kernel.Particle_get_index(self)


    def __eq__(self, *args):
        """
        __eq__(Particle self, Particle o) -> bool
        __eq__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Particle self, Particle o) -> bool
        __ne__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Particle self, Particle o) -> bool
        __le__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Particle self, Particle o) -> bool
        __lt__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Particle self, Particle o) -> bool
        __ge__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Particle self, Particle o) -> bool
        __gt__(Particle self, Decorator d) -> bool
        """
        return _IMP_kernel.Particle___gt__(self, *args)


    __hash__ = ModelObject.__hash__


    def __str__(self):
        """__str__(Particle self) -> std::string"""
        return _IMP_kernel.Particle___str__(self)


    def __repr__(self):
        """__repr__(Particle self) -> std::string"""
        return _IMP_kernel.Particle___repr__(self)


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

Particle_swigregister = _IMP_kernel.Particle_swigregister
Particle_swigregister(Particle)

class _ParticleAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::ParticleAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::ParticleAdaptor self) -> _ParticleAdaptor
        __init__(IMP::ParticleAdaptor self, Particle p) -> _ParticleAdaptor
        __init__(IMP::ParticleAdaptor self, Decorator d) -> _ParticleAdaptor
        """
        this = _IMP_kernel.new__ParticleAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_model(self):
        """get_model(_ParticleAdaptor self) -> Model"""
        return _IMP_kernel._ParticleAdaptor_get_model(self)


    def get_particle_index(self):
        """get_particle_index(_ParticleAdaptor self) -> ParticleIndex"""
        return _IMP_kernel._ParticleAdaptor_get_particle_index(self)

    __swig_destroy__ = _IMP_kernel.delete__ParticleAdaptor
    __del__ = lambda self: None
_ParticleAdaptor_swigregister = _IMP_kernel._ParticleAdaptor_swigregister
_ParticleAdaptor_swigregister(_ParticleAdaptor)

class _DependencyGraphVertexIndex(object):
    """Proxy of C++ IMP::DependencyGraphVertexIndex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(IMP::DependencyGraphVertexIndex self) -> _DependencyGraphVertexIndex"""
        this = _IMP_kernel.new__DependencyGraphVertexIndex()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__DependencyGraphVertexIndex
    __del__ = lambda self: None
_DependencyGraphVertexIndex_swigregister = _IMP_kernel._DependencyGraphVertexIndex_swigregister
_DependencyGraphVertexIndex_swigregister(_DependencyGraphVertexIndex)


def show_as_graphviz(name, out):
    """show_as_graphviz(IMP::DependencyGraph const & name, TextOutput out)"""
    return _IMP_kernel.show_as_graphviz(name, out)

def get_vertex_index(g):
    """get_vertex_index(IMP::DependencyGraph const & g) -> _DependencyGraphVertexIndex"""
    return _IMP_kernel.get_vertex_index(g)

def get_dependency_graph(m):
    """get_dependency_graph(Model m) -> IMP::DependencyGraph"""
    return _IMP_kernel.get_dependency_graph(m)

def get_pruned_dependency_graph(m):
    """get_pruned_dependency_graph(Model m) -> IMP::DependencyGraph"""
    return _IMP_kernel.get_pruned_dependency_graph(m)

def get_required_score_states(*args):
    """
    get_required_score_states(IMP::ModelObjectsTemp const & mos, IMP::ScoreStatesTemp exclude) -> IMP::ScoreStatesTemp
    get_required_score_states(IMP::ModelObjectsTemp const & mos) -> IMP::ScoreStatesTemp
    get_required_score_states(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ScoreStatesTemp
    """
    return _IMP_kernel.get_required_score_states(*args)

def get_dependent_particles(p, all, dg, index):
    """get_dependent_particles(ModelObject p, IMP::ModelObjectsTemp const & all, IMP::DependencyGraph const & dg, _DependencyGraphVertexIndex index) -> IMP::ParticlesTemp"""
    return _IMP_kernel.get_dependent_particles(p, all, dg, index)

def get_dependent_restraints(m, pi):
    """get_dependent_restraints(Model m, ParticleIndex pi) -> IMP::RestraintsTemp"""
    return _IMP_kernel.get_dependent_restraints(m, pi)
class ScoringFunction(ModelObject):
    """Proxy of C++ IMP::ScoringFunction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def do_add_score_and_derivatives(self, sa, ss):
        """do_add_score_and_derivatives(ScoringFunction self, ScoreAccumulator sa, IMP::ScoreStatesTemp const & ss)"""
        return _IMP_kernel.ScoringFunction_do_add_score_and_derivatives(self, sa, ss)


    def get_score_accumulator_if_below(self, deriv, max):
        """get_score_accumulator_if_below(ScoringFunction self, bool deriv, double max) -> ScoreAccumulator"""
        return _IMP_kernel.ScoringFunction_get_score_accumulator_if_below(self, deriv, max)


    def get_score_accumulator_if_good(self, deriv):
        """get_score_accumulator_if_good(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
        return _IMP_kernel.ScoringFunction_get_score_accumulator_if_good(self, deriv)


    def get_score_accumulator(self, deriv):
        """get_score_accumulator(ScoringFunction self, bool deriv) -> ScoreAccumulator"""
        return _IMP_kernel.ScoringFunction_get_score_accumulator(self, deriv)


    def __init__(self, m, name):
        """__init__(IMP::ScoringFunction self, Model m, std::string name) -> ScoringFunction"""
        if self.__class__ == ScoringFunction:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_ScoringFunction(_self, m, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != ScoringFunction:
            _director_objects.register(self)




    def do_get_outputs(self):
        """do_get_outputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ScoringFunction_do_get_outputs(self)


    def evaluate_if_good(self, derivatives):
        """evaluate_if_good(ScoringFunction self, bool derivatives) -> double"""
        return _IMP_kernel.ScoringFunction_evaluate_if_good(self, derivatives)


    def evaluate(self, derivatives):
        """evaluate(ScoringFunction self, bool derivatives) -> double"""
        return _IMP_kernel.ScoringFunction_evaluate(self, derivatives)


    def evaluate_if_below(self, derivatives, max):
        """evaluate_if_below(ScoringFunction self, bool derivatives, double max) -> double"""
        return _IMP_kernel.ScoringFunction_evaluate_if_below(self, derivatives, max)


    def get_had_good_score(self):
        """get_had_good_score(ScoringFunction self) -> bool"""
        return _IMP_kernel.ScoringFunction_get_had_good_score(self)


    def get_last_score(self):
        """get_last_score(ScoringFunction self) -> double"""
        return _IMP_kernel.ScoringFunction_get_last_score(self)


    def create_restraints(self):
        """create_restraints(ScoringFunction self) -> IMP::Restraints"""
        return _IMP_kernel.ScoringFunction_create_restraints(self)


    def __str__(self):
        """__str__(ScoringFunction self) -> std::string"""
        return _IMP_kernel.ScoringFunction___str__(self)


    def __repr__(self):
        """__repr__(ScoringFunction self) -> std::string"""
        return _IMP_kernel.ScoringFunction___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_ScoringFunction(o)

    __swig_destroy__ = _IMP_kernel.delete_ScoringFunction
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_ScoringFunction(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(ScoringFunction self)"""
        return _IMP_kernel.ScoringFunction_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(ScoringFunction self, bool arg0)"""
        return _IMP_kernel.ScoringFunction_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(ScoringFunction self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.ScoringFunction_do_get_inputs(self)


    def do_get_interactions(self):
        """do_get_interactions(ScoringFunction self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.ScoringFunction_do_get_interactions(self)

ScoringFunction_swigregister = _IMP_kernel.ScoringFunction_swigregister
ScoringFunction_swigregister(ScoringFunction)


def create_decomposition(*args):
    """
    create_decomposition(IMP::RestraintsTemp const & rs) -> IMP::Restraints
    create_decomposition(ScoringFunction sf) -> IMP::ScoringFunctions
    """
    return _IMP_kernel.create_decomposition(*args)
class _ScoringFunctionAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::ScoringFunctionAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::ScoringFunctionAdaptor self) -> _ScoringFunctionAdaptor
        __init__(IMP::ScoringFunctionAdaptor self, ScoringFunction sf) -> _ScoringFunctionAdaptor
        __init__(IMP::ScoringFunctionAdaptor self, IMP::RestraintsTemp const & sf) -> _ScoringFunctionAdaptor
        __init__(IMP::ScoringFunctionAdaptor self, IMP::Restraints const & sf) -> _ScoringFunctionAdaptor
        __init__(IMP::ScoringFunctionAdaptor self, Restraint sf) -> _ScoringFunctionAdaptor
        """
        this = _IMP_kernel.new__ScoringFunctionAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ScoringFunctionAdaptor
    __del__ = lambda self: None
_ScoringFunctionAdaptor_swigregister = _IMP_kernel._ScoringFunctionAdaptor_swigregister
_ScoringFunctionAdaptor_swigregister(_ScoringFunctionAdaptor)


def show_restraint_hierarchy(*args):
    """
    show_restraint_hierarchy(_ScoringFunctionAdaptor rs, _ostream out)
    show_restraint_hierarchy(_ScoringFunctionAdaptor rs)
    """
    return _IMP_kernel.show_restraint_hierarchy(*args)
class Undecorator(Object):
    """Proxy of C++ IMP::Undecorator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, name):
        """__init__(IMP::Undecorator self, Model m, std::string name) -> Undecorator"""
        if self.__class__ == Undecorator:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Undecorator(_self, m, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Undecorator:
            _director_objects.register(self)




    def teardown(self, pi):
        """teardown(Undecorator self, ParticleIndex pi)"""
        return _IMP_kernel.Undecorator_teardown(self, pi)


    def __str__(self):
        """__str__(Undecorator self) -> std::string"""
        return _IMP_kernel.Undecorator___str__(self)


    def __repr__(self):
        """__repr__(Undecorator self) -> std::string"""
        return _IMP_kernel.Undecorator___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Undecorator(o)

    __swig_destroy__ = _IMP_kernel.delete_Undecorator
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Undecorator(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(Undecorator self)"""
        return _IMP_kernel.Undecorator_do_destroy(self)

Undecorator_swigregister = _IMP_kernel.Undecorator_swigregister
Undecorator_swigregister(Undecorator)

class Model(Object):
    """Proxy of C++ IMP::Model class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Model self, std::string name) -> Model
        __init__(IMP::Model self) -> Model
        """
        this = _IMP_kernel.new_Model(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def clear_particle_caches(self, pi):
        """clear_particle_caches(Model self, ParticleIndex pi)"""
        return _IMP_kernel.Model_clear_particle_caches(self, pi)


    def add_particle(self, name):
        """add_particle(Model self, std::string name) -> ParticleIndex"""
        return _IMP_kernel.Model_add_particle(self, name)


    def get_particle_name(self, pi):
        """get_particle_name(Model self, ParticleIndex pi) -> std::string"""
        return _IMP_kernel.Model_get_particle_name(self, pi)


    def add_undecorator(self, pi, d):
        """add_undecorator(Model self, ParticleIndex pi, Undecorator d)"""
        return _IMP_kernel.Model_add_undecorator(self, pi, d)


    def remove_score_state(self, d):
        """remove_score_state(Model self, ScoreState d)"""
        return _IMP_kernel.Model_remove_score_state(self, d)


    def remove_score_states(self, d):
        """remove_score_states(Model self, IMP::ScoreStates const & d)"""
        return _IMP_kernel.Model_remove_score_states(self, d)


    def set_score_states(self, ps):
        """set_score_states(Model self, IMP::ScoreStates const & ps)"""
        return _IMP_kernel.Model_set_score_states(self, ps)


    def set_score_states_order(self, objs):
        """set_score_states_order(Model self, IMP::ScoreStates const & objs)"""
        return _IMP_kernel.Model_set_score_states_order(self, objs)


    def add_score_state(self, obj):
        """add_score_state(Model self, ScoreState obj) -> unsigned int"""
        return _IMP_kernel.Model_add_score_state(self, obj)


    def add_score_states(self, objs):
        """add_score_states(Model self, IMP::ScoreStates const & objs)"""
        return _IMP_kernel.Model_add_score_states(self, objs)


    def clear_score_states(self):
        """clear_score_states(Model self)"""
        return _IMP_kernel.Model_clear_score_states(self)


    def get_number_of_score_states(self):
        """get_number_of_score_states(Model self) -> unsigned int"""
        return _IMP_kernel.Model_get_number_of_score_states(self)


    def get_has_score_states(self):
        """get_has_score_states(Model self) -> bool"""
        return _IMP_kernel.Model_get_has_score_states(self)


    def get_score_state(self, i):
        """get_score_state(Model self, unsigned int i) -> ScoreState"""
        return _IMP_kernel.Model_get_score_state(self, i)


    def get_score_states(self):
        """get_score_states(Model self) -> IMP::ScoreStates"""
        return _IMP_kernel.Model_get_score_states(self)


    def reserve_score_states(self, sz):
        """reserve_score_states(Model self, unsigned int sz)"""
        return _IMP_kernel.Model_reserve_score_states(self, sz)


    def update(self):
        """update(Model self)"""
        return _IMP_kernel.Model_update(self)


    def add_attribute(self, *args):
        """
        add_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
        add_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
        add_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
        add_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
        add_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
        add_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
        add_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
        add_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
        """
        return _IMP_kernel.Model_add_attribute(self, *args)


    def remove_attribute(self, *args):
        """
        remove_attribute(Model self, FloatKey attribute_key, ParticleIndex particle)
        remove_attribute(Model self, IntKey attribute_key, ParticleIndex particle)
        remove_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle)
        remove_attribute(Model self, StringKey attribute_key, ParticleIndex particle)
        remove_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle)
        remove_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle)
        remove_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle)
        remove_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle)
        """
        return _IMP_kernel.Model_remove_attribute(self, *args)


    def get_has_attribute(self, *args):
        """
        get_has_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> bool
        get_has_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> bool
        get_has_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> bool
        get_has_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> bool
        get_has_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> bool
        get_has_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> bool
        get_has_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> bool
        get_has_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> bool
        """
        return _IMP_kernel.Model_get_has_attribute(self, *args)


    def set_attribute(self, *args):
        """
        set_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
        set_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
        set_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
        set_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
        set_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
        set_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
        set_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
        set_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
        """
        return _IMP_kernel.Model_set_attribute(self, *args)


    def get_attribute(self, *args):
        """
        get_attribute(Model self, FloatKey attribute_key, ParticleIndex particle) -> IMP::Float
        get_attribute(Model self, IntKey attribute_key, ParticleIndex particle) -> IMP::Int
        get_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle) -> IMP::Ints
        get_attribute(Model self, StringKey attribute_key, ParticleIndex particle) -> IMP::String
        get_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle) -> IMP::ParticleIndexes
        get_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle) -> ParticleIndex
        get_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle) -> Object
        get_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle) -> Object
        """
        return _IMP_kernel.Model_get_attribute(self, *args)


    def add_cache_attribute(self, *args):
        """
        add_cache_attribute(Model self, FloatKey attribute_key, ParticleIndex particle, IMP::Float value)
        add_cache_attribute(Model self, IntKey attribute_key, ParticleIndex particle, IMP::Int value)
        add_cache_attribute(Model self, IMP::IntsKey attribute_key, ParticleIndex particle, IMP::Ints value)
        add_cache_attribute(Model self, StringKey attribute_key, ParticleIndex particle, IMP::String value)
        add_cache_attribute(Model self, ParticleIndexesKey attribute_key, ParticleIndex particle, IMP::ParticleIndexes value)
        add_cache_attribute(Model self, ParticleIndexKey attribute_key, ParticleIndex particle, ParticleIndex value)
        add_cache_attribute(Model self, ObjectKey attribute_key, ParticleIndex particle, Object value)
        add_cache_attribute(Model self, IMP::WeakObjectKey attribute_key, ParticleIndex particle, Object value)
        """
        return _IMP_kernel.Model_add_cache_attribute(self, *args)


    def set_is_optimized(self, arg2, arg3, arg4):
        """set_is_optimized(Model self, FloatKey arg2, ParticleIndex arg3, bool arg4)"""
        return _IMP_kernel.Model_set_is_optimized(self, arg2, arg3, arg4)


    def add_to_derivative(self, k, particle, v, da):
        """add_to_derivative(Model self, FloatKey k, ParticleIndex particle, double v, DerivativeAccumulator da)"""
        return _IMP_kernel.Model_add_to_derivative(self, k, particle, v, da)


    def get_particle(self, p):
        """get_particle(Model self, ParticleIndex p) -> Particle"""
        return _IMP_kernel.Model_get_particle(self, p)


    def get_has_particle(self, p):
        """get_has_particle(Model self, ParticleIndex p) -> bool"""
        return _IMP_kernel.Model_get_has_particle(self, p)


    def get_particle_indexes(self):
        """get_particle_indexes(Model self) -> IMP::ParticleIndexes"""
        return _IMP_kernel.Model_get_particle_indexes(self)


    def get_model_objects(self):
        """get_model_objects(Model self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Model_get_model_objects(self)


    def remove_particle(self, pi):
        """remove_particle(Model self, ParticleIndex pi)"""
        return _IMP_kernel.Model_remove_particle(self, pi)


    def add_data(self, mk, o):
        """add_data(Model self, ModelKey mk, Object o)"""
        return _IMP_kernel.Model_add_data(self, mk, o)


    def get_data(self, mk):
        """get_data(Model self, ModelKey mk) -> Object"""
        return _IMP_kernel.Model_get_data(self, mk)


    def remove_data(self, mk):
        """remove_data(Model self, ModelKey mk)"""
        return _IMP_kernel.Model_remove_data(self, mk)


    def get_has_data(self, mk):
        """get_has_data(Model self, ModelKey mk) -> bool"""
        return _IMP_kernel.Model_get_has_data(self, mk)


    def get_version_info(self):
        """get_version_info(Model self) -> VersionInfo"""
        return _IMP_kernel.Model_get_version_info(self)


    def do_destroy(self):
        """do_destroy(Model self)"""
        return _IMP_kernel.Model_do_destroy(self)


    def __str__(self):
        """__str__(Model self) -> std::string"""
        return _IMP_kernel.Model___str__(self)


    def __repr__(self):
        """__repr__(Model self) -> std::string"""
        return _IMP_kernel.Model___repr__(self)


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

Model_swigregister = _IMP_kernel.Model_swigregister
Model_swigregister(Model)

class Decorator(_Value):
    """Proxy of C++ IMP::Decorator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, p):
        """__init__(IMP::Decorator self, _ParticleAdaptor p) -> Decorator"""
        this = _IMP_kernel.new_Decorator(p)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __ne__(self, o):
        """__ne__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___ne__(self, o)


    def __lt__(self, o):
        """__lt__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___lt__(self, o)


    def __gt__(self, o):
        """__gt__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___gt__(self, o)


    def __ge__(self, o):
        """__ge__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___ge__(self, o)


    def __le__(self, o):
        """__le__(Decorator self, Object o) -> bool"""
        return _IMP_kernel.Decorator___le__(self, o)


    def get_particle(self):
        """get_particle(Decorator self) -> Particle"""
        return _IMP_kernel.Decorator_get_particle(self)


    def get_particle_index(self):
        """get_particle_index(Decorator self) -> ParticleIndex"""
        return _IMP_kernel.Decorator_get_particle_index(self)


    def get_model(self):
        """get_model(Decorator self) -> Model"""
        return _IMP_kernel.Decorator_get_model(self)


    def get_is_valid(self):
        """get_is_valid(Decorator self) -> bool"""
        return _IMP_kernel.Decorator_get_is_valid(self)


    def __hash__(self):
        """__hash__(Decorator self) -> std::size_t"""
        return _IMP_kernel.Decorator___hash__(self)


    def __eq__(self, *args):
        """
        __eq__(Decorator self, Object o) -> bool
        __eq__(Decorator self, Decorator o) -> bool
        __eq__(Decorator self, Particle o) -> bool
        """
        return _IMP_kernel.Decorator___eq__(self, *args)


    def __bool__(self):
        """__bool__(Decorator self) -> bool"""
        return _IMP_kernel.Decorator___bool__(self)


    __nonzero__ = __bool__

    __swig_destroy__ = _IMP_kernel.delete_Decorator
    __del__ = lambda self: None
Decorator_swigregister = _IMP_kernel.Decorator_swigregister
Decorator_swigregister(Decorator)


def check_particle(m, pi):
    """check_particle(Model m, ParticleIndex pi)"""
    return _IMP_kernel.check_particle(m, pi)
class UnaryFunction(Object):
    """Proxy of C++ IMP::UnaryFunction class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::UnaryFunction self, std::string name) -> UnaryFunction
        __init__(IMP::UnaryFunction self) -> UnaryFunction
        """
        if self.__class__ == UnaryFunction:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_UnaryFunction(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != UnaryFunction:
            _director_objects.register(self)




    def evaluate(self, feature):
        """evaluate(UnaryFunction self, double feature) -> double"""
        return _IMP_kernel.UnaryFunction_evaluate(self, feature)


    def evaluate_with_derivative(self, feature):
        """evaluate_with_derivative(UnaryFunction self, double feature) -> IMP::DerivativePair"""
        return _IMP_kernel.UnaryFunction_evaluate_with_derivative(self, feature)

    __swig_destroy__ = _IMP_kernel.delete_UnaryFunction
    __del__ = lambda self: None

    def __str__(self):
        """__str__(UnaryFunction self) -> std::string"""
        return _IMP_kernel.UnaryFunction___str__(self)


    def __repr__(self):
        """__repr__(UnaryFunction self) -> std::string"""
        return _IMP_kernel.UnaryFunction___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_UnaryFunction(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_UnaryFunction(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(UnaryFunction self)"""
        return _IMP_kernel.UnaryFunction_do_destroy(self)

UnaryFunction_swigregister = _IMP_kernel.UnaryFunction_swigregister
UnaryFunction_swigregister(UnaryFunction)

class OptimizerState(ModelObject):
    """Proxy of C++ IMP::OptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, name):
        """__init__(IMP::OptimizerState self, Model m, std::string name) -> OptimizerState"""
        if self.__class__ == OptimizerState:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_OptimizerState(_self, m, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != OptimizerState:
            _director_objects.register(self)




    def update(self):
        """update(OptimizerState self)"""
        return _IMP_kernel.OptimizerState_update(self)


    def set_is_optimizing(self, arg0):
        """set_is_optimizing(OptimizerState self, bool arg0)"""
        return _IMP_kernel.OptimizerState_set_is_optimizing(self, arg0)


    def get_optimizer(self):
        """get_optimizer(OptimizerState self) -> Optimizer"""
        return _IMP_kernel.OptimizerState_get_optimizer(self)


    def set_period(self, p):
        """set_period(OptimizerState self, unsigned int p)"""
        return _IMP_kernel.OptimizerState_set_period(self, p)


    def get_period(self):
        """get_period(OptimizerState self) -> unsigned int"""
        return _IMP_kernel.OptimizerState_get_period(self)


    def reset(self):
        """reset(OptimizerState self)"""
        return _IMP_kernel.OptimizerState_reset(self)


    def update_always(self):
        """update_always(OptimizerState self)"""
        return _IMP_kernel.OptimizerState_update_always(self)


    def get_number_of_updates(self):
        """get_number_of_updates(OptimizerState self) -> unsigned int"""
        return _IMP_kernel.OptimizerState_get_number_of_updates(self)


    def set_number_of_updates(self, n):
        """set_number_of_updates(OptimizerState self, unsigned int n)"""
        return _IMP_kernel.OptimizerState_set_number_of_updates(self, n)

    __swig_destroy__ = _IMP_kernel.delete_OptimizerState
    __del__ = lambda self: None

    def do_update(self, arg0):
        """do_update(OptimizerState self, unsigned int arg0)"""
        return _IMP_kernel.OptimizerState_do_update(self, arg0)


    def do_set_is_optimizing(self, arg0):
        """do_set_is_optimizing(OptimizerState self, bool arg0)"""
        return _IMP_kernel.OptimizerState_do_set_is_optimizing(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.OptimizerState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(OptimizerState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.OptimizerState_do_get_outputs(self)


    def __str__(self):
        """__str__(OptimizerState self) -> std::string"""
        return _IMP_kernel.OptimizerState___str__(self)


    def __repr__(self):
        """__repr__(OptimizerState self) -> std::string"""
        return _IMP_kernel.OptimizerState___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_OptimizerState(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_OptimizerState(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(OptimizerState self)"""
        return _IMP_kernel.OptimizerState_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(OptimizerState self, bool arg0)"""
        return _IMP_kernel.OptimizerState_handle_set_has_required_score_states(self, arg0)


    def do_get_interactions(self):
        """do_get_interactions(OptimizerState self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.OptimizerState_do_get_interactions(self)

OptimizerState_swigregister = _IMP_kernel.OptimizerState_swigregister
OptimizerState_swigregister(OptimizerState)

class Refiner(_ParticleInputs, Object):
    """Proxy of C++ IMP::Refiner class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Refiner self, std::string name, bool is_by_ref=False) -> Refiner
        __init__(IMP::Refiner self, std::string name) -> Refiner
        __init__(IMP::Refiner self) -> Refiner
        """
        if self.__class__ == Refiner:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Refiner(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Refiner:
            _director_objects.register(self)




    def get_can_refine(self, arg0):
        """get_can_refine(Refiner self, Particle arg0) -> bool"""
        return _IMP_kernel.Refiner_get_can_refine(self, arg0)


    def get_refined_indexes(self, m, pi):
        """get_refined_indexes(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes"""
        return _IMP_kernel.Refiner_get_refined_indexes(self, m, pi)


    def get_refined_indexes_by_ref(self, m, pi):
        """get_refined_indexes_by_ref(Refiner self, Model m, ParticleIndex pi) -> IMP::ParticleIndexes const &"""
        return _IMP_kernel.Refiner_get_refined_indexes_by_ref(self, m, pi)


    def get_is_by_ref_supported(self):
        """get_is_by_ref_supported(Refiner self) -> bool"""
        return _IMP_kernel.Refiner_get_is_by_ref_supported(self)


    def get_refined(self, *args):
        """
        get_refined(Refiner self, Particle a) -> IMP::ParticlesTemp const
        get_refined(Refiner self, Particle a, unsigned int i) -> Particle
        """
        return _IMP_kernel.Refiner_get_refined(self, *args)


    def get_number_of_refined(self, a):
        """get_number_of_refined(Refiner self, Particle a) -> unsigned int"""
        return _IMP_kernel.Refiner_get_number_of_refined(self, a)


    def __str__(self):
        """__str__(Refiner self) -> std::string"""
        return _IMP_kernel.Refiner___str__(self)


    def __repr__(self):
        """__repr__(Refiner self) -> std::string"""
        return _IMP_kernel.Refiner___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Refiner(o)

    __swig_destroy__ = _IMP_kernel.delete_Refiner
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Refiner(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(Refiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Refiner_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(Refiner self)"""
        return _IMP_kernel.Refiner_do_destroy(self)

Refiner_swigregister = _IMP_kernel.Refiner_swigregister
Refiner_swigregister(Refiner)

class Optimizer(ModelObject):
    """Proxy of C++ IMP::Optimizer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def set_is_optimizing_states(self, tf):
        """set_is_optimizing_states(Optimizer self, bool tf)"""
        return _IMP_kernel.Optimizer_set_is_optimizing_states(self, tf)


    def get_optimizer_state_inputs(self):
        """get_optimizer_state_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Optimizer_get_optimizer_state_inputs(self)


    def do_get_inputs(self):
        """do_get_inputs(Optimizer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Optimizer_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(Optimizer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.Optimizer_do_get_outputs(self)


    def __init__(self, *args):
        """
        __init__(IMP::Optimizer self, Model m, std::string name) -> Optimizer
        __init__(IMP::Optimizer self, Model m) -> Optimizer
        """
        if self.__class__ == Optimizer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Optimizer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Optimizer:
            _director_objects.register(self)




    def optimize(self, max_steps):
        """optimize(Optimizer self, unsigned int max_steps) -> double"""
        return _IMP_kernel.Optimizer_optimize(self, max_steps)


    def set_stop_on_good_score(self, tf):
        """set_stop_on_good_score(Optimizer self, bool tf)"""
        return _IMP_kernel.Optimizer_set_stop_on_good_score(self, tf)


    def get_stop_on_good_score(self):
        """get_stop_on_good_score(Optimizer self) -> bool"""
        return _IMP_kernel.Optimizer_get_stop_on_good_score(self)


    def get_last_score(self):
        """get_last_score(Optimizer self) -> double"""
        return _IMP_kernel.Optimizer_get_last_score(self)


    def get_scoring_function(self):
        """get_scoring_function(Optimizer self) -> ScoringFunction"""
        return _IMP_kernel.Optimizer_get_scoring_function(self)


    def remove_optimizer_state(self, d):
        """remove_optimizer_state(Optimizer self, OptimizerState d)"""
        return _IMP_kernel.Optimizer_remove_optimizer_state(self, d)


    def remove_optimizer_states(self, d):
        """remove_optimizer_states(Optimizer self, IMP::OptimizerStates const & d)"""
        return _IMP_kernel.Optimizer_remove_optimizer_states(self, d)


    def set_optimizer_states(self, ps):
        """set_optimizer_states(Optimizer self, IMP::OptimizerStates const & ps)"""
        return _IMP_kernel.Optimizer_set_optimizer_states(self, ps)


    def set_optimizer_states_order(self, objs):
        """set_optimizer_states_order(Optimizer self, IMP::OptimizerStates const & objs)"""
        return _IMP_kernel.Optimizer_set_optimizer_states_order(self, objs)


    def add_optimizer_state(self, obj):
        """add_optimizer_state(Optimizer self, OptimizerState obj) -> unsigned int"""
        return _IMP_kernel.Optimizer_add_optimizer_state(self, obj)


    def add_optimizer_states(self, objs):
        """add_optimizer_states(Optimizer self, IMP::OptimizerStates const & objs)"""
        return _IMP_kernel.Optimizer_add_optimizer_states(self, objs)


    def clear_optimizer_states(self):
        """clear_optimizer_states(Optimizer self)"""
        return _IMP_kernel.Optimizer_clear_optimizer_states(self)


    def get_number_of_optimizer_states(self):
        """get_number_of_optimizer_states(Optimizer self) -> unsigned int"""
        return _IMP_kernel.Optimizer_get_number_of_optimizer_states(self)


    def get_has_optimizer_states(self):
        """get_has_optimizer_states(Optimizer self) -> bool"""
        return _IMP_kernel.Optimizer_get_has_optimizer_states(self)


    def get_optimizer_state(self, i):
        """get_optimizer_state(Optimizer self, unsigned int i) -> OptimizerState"""
        return _IMP_kernel.Optimizer_get_optimizer_state(self, i)


    def get_optimizer_states(self):
        """get_optimizer_states(Optimizer self) -> IMP::OptimizerStates"""
        return _IMP_kernel.Optimizer_get_optimizer_states(self)


    def reserve_optimizer_states(self, sz):
        """reserve_optimizer_states(Optimizer self, unsigned int sz)"""
        return _IMP_kernel.Optimizer_reserve_optimizer_states(self, sz)


    def set_scoring_function(self, sf):
        """set_scoring_function(Optimizer self, _ScoringFunctionAdaptor sf)"""
        return _IMP_kernel.Optimizer_set_scoring_function(self, sf)

    __swig_destroy__ = _IMP_kernel.delete_Optimizer
    def __del__(self):
        """__del__(IMP::Optimizer self)"""

        _director_objects.cleanup()


        pass


    def do_optimize(self, ns):
        """do_optimize(Optimizer self, unsigned int ns) -> double"""
        return _IMP_kernel.Optimizer_do_optimize(self, ns)


    def update_states(self):
        """update_states(Optimizer self)"""
        return _IMP_kernel.Optimizer_update_states(self)


    def __str__(self):
        """__str__(Optimizer self) -> std::string"""
        return _IMP_kernel.Optimizer___str__(self)


    def __repr__(self):
        """__repr__(Optimizer self) -> std::string"""
        return _IMP_kernel.Optimizer___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Optimizer(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Optimizer(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(Optimizer self)"""
        return _IMP_kernel.Optimizer_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(Optimizer self, bool arg0)"""
        return _IMP_kernel.Optimizer_handle_set_has_required_score_states(self, arg0)


    def do_get_interactions(self):
        """do_get_interactions(Optimizer self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.Optimizer_do_get_interactions(self)

Optimizer_swigregister = _IMP_kernel.Optimizer_swigregister
Optimizer_swigregister(Optimizer)

class AttributeOptimizer(Optimizer):
    """Proxy of C++ IMP::AttributeOptimizer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::AttributeOptimizer self, Model m, std::string name) -> AttributeOptimizer
        __init__(IMP::AttributeOptimizer self, Model m) -> AttributeOptimizer
        """
        if self.__class__ == AttributeOptimizer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_AttributeOptimizer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != AttributeOptimizer:
            _director_objects.register(self)




    def get_optimized_attributes(self):
        """get_optimized_attributes(AttributeOptimizer self) -> IMP::FloatIndexes"""
        return _IMP_kernel.AttributeOptimizer_get_optimized_attributes(self)


    def set_value(self, fi, v):
        """set_value(AttributeOptimizer self, FloatIndex fi, double v)"""
        return _IMP_kernel.AttributeOptimizer_set_value(self, fi, v)


    def get_value(self, fi):
        """get_value(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
        return _IMP_kernel.AttributeOptimizer_get_value(self, fi)


    def get_derivative(self, fi):
        """get_derivative(AttributeOptimizer self, FloatIndex fi) -> IMP::Float"""
        return _IMP_kernel.AttributeOptimizer_get_derivative(self, fi)


    def get_width(self, k):
        """get_width(AttributeOptimizer self, FloatKey k) -> double"""
        return _IMP_kernel.AttributeOptimizer_get_width(self, k)


    def set_scaled_value(self, fi, v):
        """set_scaled_value(AttributeOptimizer self, FloatIndex fi, IMP::Float v)"""
        return _IMP_kernel.AttributeOptimizer_set_scaled_value(self, fi, v)


    def get_scaled_value(self, fi):
        """get_scaled_value(AttributeOptimizer self, FloatIndex fi) -> double"""
        return _IMP_kernel.AttributeOptimizer_get_scaled_value(self, fi)


    def get_scaled_derivative(self, fi):
        """get_scaled_derivative(AttributeOptimizer self, FloatIndex fi) -> double"""
        return _IMP_kernel.AttributeOptimizer_get_scaled_derivative(self, fi)


    def clear_range_cache(self):
        """clear_range_cache(AttributeOptimizer self)"""
        return _IMP_kernel.AttributeOptimizer_clear_range_cache(self)


    def __str__(self):
        """__str__(AttributeOptimizer self) -> std::string"""
        return _IMP_kernel.AttributeOptimizer___str__(self)


    def __repr__(self):
        """__repr__(AttributeOptimizer self) -> std::string"""
        return _IMP_kernel.AttributeOptimizer___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_AttributeOptimizer(o)

    __swig_destroy__ = _IMP_kernel.delete_AttributeOptimizer
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_AttributeOptimizer(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(AttributeOptimizer self)"""
        return _IMP_kernel.AttributeOptimizer_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(AttributeOptimizer self, bool arg0)"""
        return _IMP_kernel.AttributeOptimizer_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.AttributeOptimizer_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(AttributeOptimizer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.AttributeOptimizer_do_get_outputs(self)


    def do_get_interactions(self):
        """do_get_interactions(AttributeOptimizer self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.AttributeOptimizer_do_get_interactions(self)


    def do_optimize(self, ns):
        """do_optimize(AttributeOptimizer self, unsigned int ns) -> double"""
        return _IMP_kernel.AttributeOptimizer_do_optimize(self, ns)

AttributeOptimizer_swigregister = _IMP_kernel.AttributeOptimizer_swigregister
AttributeOptimizer_swigregister(AttributeOptimizer)

class ConfigurationSet(Object):
    """Proxy of C++ IMP::ConfigurationSet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::ConfigurationSet self, Model m, std::string name) -> ConfigurationSet
        __init__(IMP::ConfigurationSet self, Model m) -> ConfigurationSet
        """
        this = _IMP_kernel.new_ConfigurationSet(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def save_configuration(self):
        """save_configuration(ConfigurationSet self)"""
        return _IMP_kernel.ConfigurationSet_save_configuration(self)


    def get_number_of_configurations(self):
        """get_number_of_configurations(ConfigurationSet self) -> unsigned int"""
        return _IMP_kernel.ConfigurationSet_get_number_of_configurations(self)


    def load_configuration(self, i):
        """load_configuration(ConfigurationSet self, int i)"""
        return _IMP_kernel.ConfigurationSet_load_configuration(self, i)


    def remove_configuration(self, i):
        """remove_configuration(ConfigurationSet self, unsigned int i)"""
        return _IMP_kernel.ConfigurationSet_remove_configuration(self, i)


    def get_model(self):
        """get_model(ConfigurationSet self) -> Model"""
        return _IMP_kernel.ConfigurationSet_get_model(self)


    def get_version_info(self):
        """get_version_info(ConfigurationSet self) -> VersionInfo"""
        return _IMP_kernel.ConfigurationSet_get_version_info(self)


    def __str__(self):
        """__str__(ConfigurationSet self) -> std::string"""
        return _IMP_kernel.ConfigurationSet___str__(self)


    def __repr__(self):
        """__repr__(ConfigurationSet self) -> std::string"""
        return _IMP_kernel.ConfigurationSet___repr__(self)


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

ConfigurationSet_swigregister = _IMP_kernel.ConfigurationSet_swigregister
ConfigurationSet_swigregister(ConfigurationSet)

class SaveToConfigurationSetOptimizerState(OptimizerState):
    """Proxy of C++ IMP::SaveToConfigurationSetOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, cs):
        """__init__(IMP::SaveToConfigurationSetOptimizerState self, ConfigurationSet cs) -> SaveToConfigurationSetOptimizerState"""
        this = _IMP_kernel.new_SaveToConfigurationSetOptimizerState(cs)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_version_info(self):
        """get_version_info(SaveToConfigurationSetOptimizerState self) -> VersionInfo"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(SaveToConfigurationSetOptimizerState self) -> std::string"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(SaveToConfigurationSetOptimizerState self) -> std::string"""
        return _IMP_kernel.SaveToConfigurationSetOptimizerState___repr__(self)


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

SaveToConfigurationSetOptimizerState_swigregister = _IMP_kernel.SaveToConfigurationSetOptimizerState_swigregister
SaveToConfigurationSetOptimizerState_swigregister(SaveToConfigurationSetOptimizerState)

class Configuration(Object):
    """Proxy of C++ IMP::Configuration class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Configuration self, Model m, std::string name) -> Configuration
        __init__(IMP::Configuration self, Model m) -> Configuration
        __init__(IMP::Configuration self, Model m, Configuration base, std::string name) -> Configuration
        __init__(IMP::Configuration self, Model m, Configuration base) -> Configuration
        """
        this = _IMP_kernel.new_Configuration(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def load_configuration(self):
        """load_configuration(Configuration self)"""
        return _IMP_kernel.Configuration_load_configuration(self)


    def swap_configuration(self):
        """swap_configuration(Configuration self)"""
        return _IMP_kernel.Configuration_swap_configuration(self)


    def get_version_info(self):
        """get_version_info(Configuration self) -> VersionInfo"""
        return _IMP_kernel.Configuration_get_version_info(self)


    def __str__(self):
        """__str__(Configuration self) -> std::string"""
        return _IMP_kernel.Configuration___str__(self)


    def __repr__(self):
        """__repr__(Configuration self) -> std::string"""
        return _IMP_kernel.Configuration___repr__(self)


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

Configuration_swigregister = _IMP_kernel.Configuration_swigregister
Configuration_swigregister(Configuration)

class Sampler(Object):
    """Proxy of C++ IMP::Sampler class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::Sampler self, Model m, std::string name) -> Sampler
        __init__(IMP::Sampler self, Model m) -> Sampler
        """
        if self.__class__ == Sampler:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_Sampler(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Sampler:
            _director_objects.register(self)




    def create_sample(self):
        """create_sample(Sampler self) -> ConfigurationSet"""
        return _IMP_kernel.Sampler_create_sample(self)


    def get_scoring_function(self):
        """get_scoring_function(Sampler self) -> ScoringFunction"""
        return _IMP_kernel.Sampler_get_scoring_function(self)


    def set_scoring_function(self, sf):
        """set_scoring_function(Sampler self, _ScoringFunctionAdaptor sf)"""
        return _IMP_kernel.Sampler_set_scoring_function(self, sf)


    def get_model(self):
        """get_model(Sampler self) -> Model"""
        return _IMP_kernel.Sampler_get_model(self)


    def do_sample(self):
        """do_sample(Sampler self) -> ConfigurationSet"""
        return _IMP_kernel.Sampler_do_sample(self)

    __swig_destroy__ = _IMP_kernel.delete_Sampler
    __del__ = lambda self: None

    def __str__(self):
        """__str__(Sampler self) -> std::string"""
        return _IMP_kernel.Sampler___str__(self)


    def __repr__(self):
        """__repr__(Sampler self) -> std::string"""
        return _IMP_kernel.Sampler___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Sampler(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_Sampler(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(Sampler self)"""
        return _IMP_kernel.Sampler_do_destroy(self)

Sampler_swigregister = _IMP_kernel.Sampler_swigregister
Sampler_swigregister(Sampler)

class PairModifier(_ParticleInputs, _ParticleOutputs, Object):
    """Proxy of C++ IMP::PairModifier class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::PairModifier self, std::string name) -> PairModifier
        __init__(IMP::PairModifier self) -> PairModifier
        """
        if self.__class__ == PairModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairModifier(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != PairModifier:
            _director_objects.register(self)




    def apply_index(self, m, v):
        """apply_index(PairModifier self, Model m, IMP::ParticleIndexPair const & v)"""
        return _IMP_kernel.PairModifier_apply_index(self, m, v)


    def apply_indexes(self, m, o, lower_bound, upper_bound):
        """apply_indexes(PairModifier self, Model m, IMP::ParticleIndexPairs const & o, unsigned int lower_bound, unsigned int upper_bound)"""
        return _IMP_kernel.PairModifier_apply_indexes(self, m, o, lower_bound, upper_bound)


    def __str__(self):
        """__str__(PairModifier self) -> std::string"""
        return _IMP_kernel.PairModifier___str__(self)


    def __repr__(self):
        """__repr__(PairModifier self) -> std::string"""
        return _IMP_kernel.PairModifier___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_PairModifier(o)

    __swig_destroy__ = _IMP_kernel.delete_PairModifier
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairModifier(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.PairModifier_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(PairModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.PairModifier_do_get_outputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(PairModifier self)"""
        return _IMP_kernel.PairModifier_do_destroy(self)

PairModifier_swigregister = _IMP_kernel.PairModifier_swigregister
PairModifier_swigregister(PairModifier)

class PairScore(_ParticleInputs, Object):
    """Proxy of C++ IMP::PairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::PairScore self, std::string name) -> PairScore
        __init__(IMP::PairScore self) -> PairScore
        """
        if self.__class__ == PairScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairScore(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != PairScore:
            _director_objects.register(self)




    def evaluate_index(self, m, vt, da):
        """evaluate_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.PairScore_evaluate_index(self, m, vt, da)


    def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
        """evaluate_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.PairScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)


    def evaluate_if_good_index(self, m, vt, da, max):
        """evaluate_if_good_index(PairScore self, Model m, IMP::ParticleIndexPair const & vt, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.PairScore_evaluate_if_good_index(self, m, vt, da, max)


    def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
        """evaluate_if_good_indexes(PairScore self, Model m, IMP::ParticleIndexPairs const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.PairScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)


    def create_current_decomposition(self, m, vt):
        """create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
        return _IMP_kernel.PairScore_create_current_decomposition(self, m, vt)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(PairScore self, Model m, IMP::ParticleIndexPair const & vt) -> IMP::Restraints"""
        return _IMP_kernel.PairScore_do_create_current_decomposition(self, m, vt)

    __swig_destroy__ = _IMP_kernel.delete_PairScore
    __del__ = lambda self: None

    def __str__(self):
        """__str__(PairScore self) -> std::string"""
        return _IMP_kernel.PairScore___str__(self)


    def __repr__(self):
        """__repr__(PairScore self) -> std::string"""
        return _IMP_kernel.PairScore___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_PairScore(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairScore(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(PairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.PairScore_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(PairScore self)"""
        return _IMP_kernel.PairScore_do_destroy(self)

PairScore_swigregister = _IMP_kernel.PairScore_swigregister
PairScore_swigregister(PairScore)

class PairPredicate(_ParticleInputs, Object):
    """Proxy of C++ IMP::PairPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::PairPredicate self, std::string name) -> PairPredicate
        __init__(IMP::PairPredicate self) -> PairPredicate
        """
        if self.__class__ == PairPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairPredicate(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != PairPredicate:
            _director_objects.register(self)




    def get_value(self, *args):
        """
        get_value(PairPredicate self, IMP::ParticlePair const & vt) -> int
        get_value(PairPredicate self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.PairPredicate_get_value(self, *args)


    def __call__(self, m, vt):
        """__call__(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int"""
        return _IMP_kernel.PairPredicate___call__(self, m, vt)


    def get_value_index(self, *args):
        """
        get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPair const & vt) -> int
        get_value_index(PairPredicate self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_kernel.PairPredicate_get_value_index(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_PairPredicate
    __del__ = lambda self: None

    def __str__(self):
        """__str__(PairPredicate self) -> std::string"""
        return _IMP_kernel.PairPredicate___str__(self)


    def __repr__(self):
        """__repr__(PairPredicate self) -> std::string"""
        return _IMP_kernel.PairPredicate___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_PairPredicate(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairPredicate(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(PairPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.PairPredicate_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(PairPredicate self)"""
        return _IMP_kernel.PairPredicate_do_destroy(self)

PairPredicate_swigregister = _IMP_kernel.PairPredicate_swigregister
PairPredicate_swigregister(PairPredicate)

class PairContainer(Container):
    """Proxy of C++ IMP::PairContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def apply_generic(self, m):
        """apply_generic(PairContainer self, PairModifier m)"""
        return _IMP_kernel.PairContainer_apply_generic(self, m)


    def apply(self, sm):
        """apply(PairContainer self, PairModifier sm)"""
        return _IMP_kernel.PairContainer_apply(self, sm)


    def get_range_indexes(self):
        """get_range_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
        return _IMP_kernel.PairContainer_get_range_indexes(self)


    def get_contents(self):
        """get_contents(PairContainer self) -> IMP::ParticleIndexPairs const &"""
        return _IMP_kernel.PairContainer_get_contents(self)


    def get_indexes(self):
        """get_indexes(PairContainer self) -> IMP::ParticleIndexPairs"""
        return _IMP_kernel.PairContainer_get_indexes(self)


    def get(self, *args):
        """
        get(PairContainer self) -> IMP::ParticlePairsTemp
        get(PairContainer self, unsigned int i) -> IMP::ParticlePair
        """
        return _IMP_kernel.PairContainer_get(self, *args)


    def get_number(self):
        """get_number(PairContainer self) -> unsigned int"""
        return _IMP_kernel.PairContainer_get_number(self)


    def get_particle_pairs(self):
        """get_particle_pairs(PairContainer self) -> IMP::ParticlePairsTemp"""
        return _IMP_kernel.PairContainer_get_particle_pairs(self)


    def get_particle_pair(self, i):
        """get_particle_pair(PairContainer self, unsigned int i) -> IMP::ParticlePair"""
        return _IMP_kernel.PairContainer_get_particle_pair(self, i)


    def __init__(self, *args):
        """
        __init__(IMP::PairContainer self, Model m, std::string name) -> PairContainer
        __init__(IMP::PairContainer self, Model m) -> PairContainer
        """
        if self.__class__ == PairContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_PairContainer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != PairContainer:
            _director_objects.register(self)




    def do_apply(self, sm):
        """do_apply(PairContainer self, PairModifier sm)"""
        return _IMP_kernel.PairContainer_do_apply(self, sm)


    def do_get_provides_access(self):
        """do_get_provides_access(PairContainer self) -> bool"""
        return _IMP_kernel.PairContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_PairContainer
    __del__ = lambda self: None

    def __str__(self):
        """__str__(PairContainer self) -> std::string"""
        return _IMP_kernel.PairContainer___str__(self)


    def __repr__(self):
        """__repr__(PairContainer self) -> std::string"""
        return _IMP_kernel.PairContainer___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_PairContainer(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_PairContainer(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(PairContainer self)"""
        return _IMP_kernel.PairContainer_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(PairContainer self, bool arg0)"""
        return _IMP_kernel.PairContainer_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(PairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.PairContainer_do_get_inputs(self)


    def do_get_interactions(self):
        """do_get_interactions(PairContainer self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.PairContainer_do_get_interactions(self)


    def do_get_contents_hash(self):
        """do_get_contents_hash(PairContainer self) -> std::size_t"""
        return _IMP_kernel.PairContainer_do_get_contents_hash(self)

PairContainer_swigregister = _IMP_kernel.PairContainer_swigregister
PairContainer_swigregister(PairContainer)

class _PairContainerAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::PairContainerAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::PairContainerAdaptor self) -> _PairContainerAdaptor
        __init__(IMP::PairContainerAdaptor self, PairContainer c) -> _PairContainerAdaptor
        __init__(IMP::PairContainerAdaptor self, IMP::ParticlePairsTemp const & t) -> _PairContainerAdaptor
        """
        this = _IMP_kernel.new__PairContainerAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_name_if_default(self, name):
        """set_name_if_default(_PairContainerAdaptor self, std::string name)"""
        return _IMP_kernel._PairContainerAdaptor_set_name_if_default(self, name)

    __swig_destroy__ = _IMP_kernel.delete__PairContainerAdaptor
    __del__ = lambda self: None
_PairContainerAdaptor_swigregister = _IMP_kernel._PairContainerAdaptor_swigregister
_PairContainerAdaptor_swigregister(_PairContainerAdaptor)

class QuadModifier(_ParticleInputs, _ParticleOutputs, Object):
    """Proxy of C++ IMP::QuadModifier class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::QuadModifier self, std::string name) -> QuadModifier
        __init__(IMP::QuadModifier self) -> QuadModifier
        """
        if self.__class__ == QuadModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadModifier(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != QuadModifier:
            _director_objects.register(self)




    def apply_index(self, m, v):
        """apply_index(QuadModifier self, Model m, IMP::ParticleIndexQuad const & v)"""
        return _IMP_kernel.QuadModifier_apply_index(self, m, v)


    def apply_indexes(self, m, o, lower_bound, upper_bound):
        """apply_indexes(QuadModifier self, Model m, IMP::ParticleIndexQuads const & o, unsigned int lower_bound, unsigned int upper_bound)"""
        return _IMP_kernel.QuadModifier_apply_indexes(self, m, o, lower_bound, upper_bound)


    def __str__(self):
        """__str__(QuadModifier self) -> std::string"""
        return _IMP_kernel.QuadModifier___str__(self)


    def __repr__(self):
        """__repr__(QuadModifier self) -> std::string"""
        return _IMP_kernel.QuadModifier___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_QuadModifier(o)

    __swig_destroy__ = _IMP_kernel.delete_QuadModifier
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadModifier(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.QuadModifier_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(QuadModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.QuadModifier_do_get_outputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(QuadModifier self)"""
        return _IMP_kernel.QuadModifier_do_destroy(self)

QuadModifier_swigregister = _IMP_kernel.QuadModifier_swigregister
QuadModifier_swigregister(QuadModifier)

class QuadScore(_ParticleInputs, Object):
    """Proxy of C++ IMP::QuadScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::QuadScore self, std::string name) -> QuadScore
        __init__(IMP::QuadScore self) -> QuadScore
        """
        if self.__class__ == QuadScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadScore(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != QuadScore:
            _director_objects.register(self)




    def evaluate_index(self, m, vt, da):
        """evaluate_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.QuadScore_evaluate_index(self, m, vt, da)


    def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
        """evaluate_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.QuadScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)


    def evaluate_if_good_index(self, m, vt, da, max):
        """evaluate_if_good_index(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.QuadScore_evaluate_if_good_index(self, m, vt, da, max)


    def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
        """evaluate_if_good_indexes(QuadScore self, Model m, IMP::ParticleIndexQuads const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.QuadScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)


    def create_current_decomposition(self, m, vt):
        """create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
        return _IMP_kernel.QuadScore_create_current_decomposition(self, m, vt)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(QuadScore self, Model m, IMP::ParticleIndexQuad const & vt) -> IMP::Restraints"""
        return _IMP_kernel.QuadScore_do_create_current_decomposition(self, m, vt)

    __swig_destroy__ = _IMP_kernel.delete_QuadScore
    __del__ = lambda self: None

    def __str__(self):
        """__str__(QuadScore self) -> std::string"""
        return _IMP_kernel.QuadScore___str__(self)


    def __repr__(self):
        """__repr__(QuadScore self) -> std::string"""
        return _IMP_kernel.QuadScore___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_QuadScore(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadScore(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(QuadScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.QuadScore_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(QuadScore self)"""
        return _IMP_kernel.QuadScore_do_destroy(self)

QuadScore_swigregister = _IMP_kernel.QuadScore_swigregister
QuadScore_swigregister(QuadScore)

class QuadPredicate(_ParticleInputs, Object):
    """Proxy of C++ IMP::QuadPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::QuadPredicate self, std::string name) -> QuadPredicate
        __init__(IMP::QuadPredicate self) -> QuadPredicate
        """
        if self.__class__ == QuadPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadPredicate(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != QuadPredicate:
            _director_objects.register(self)




    def get_value(self, *args):
        """
        get_value(QuadPredicate self, IMP::ParticleQuad const & vt) -> int
        get_value(QuadPredicate self, IMP::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.QuadPredicate_get_value(self, *args)


    def __call__(self, m, vt):
        """__call__(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int"""
        return _IMP_kernel.QuadPredicate___call__(self, m, vt)


    def get_value_index(self, *args):
        """
        get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuad const & vt) -> int
        get_value_index(QuadPredicate self, Model m, IMP::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_kernel.QuadPredicate_get_value_index(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_QuadPredicate
    __del__ = lambda self: None

    def __str__(self):
        """__str__(QuadPredicate self) -> std::string"""
        return _IMP_kernel.QuadPredicate___str__(self)


    def __repr__(self):
        """__repr__(QuadPredicate self) -> std::string"""
        return _IMP_kernel.QuadPredicate___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_QuadPredicate(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadPredicate(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(QuadPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.QuadPredicate_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(QuadPredicate self)"""
        return _IMP_kernel.QuadPredicate_do_destroy(self)

QuadPredicate_swigregister = _IMP_kernel.QuadPredicate_swigregister
QuadPredicate_swigregister(QuadPredicate)

class QuadContainer(Container):
    """Proxy of C++ IMP::QuadContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def apply_generic(self, m):
        """apply_generic(QuadContainer self, QuadModifier m)"""
        return _IMP_kernel.QuadContainer_apply_generic(self, m)


    def apply(self, sm):
        """apply(QuadContainer self, QuadModifier sm)"""
        return _IMP_kernel.QuadContainer_apply(self, sm)


    def get_range_indexes(self):
        """get_range_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
        return _IMP_kernel.QuadContainer_get_range_indexes(self)


    def get_contents(self):
        """get_contents(QuadContainer self) -> IMP::ParticleIndexQuads const &"""
        return _IMP_kernel.QuadContainer_get_contents(self)


    def get_indexes(self):
        """get_indexes(QuadContainer self) -> IMP::ParticleIndexQuads"""
        return _IMP_kernel.QuadContainer_get_indexes(self)


    def get(self, *args):
        """
        get(QuadContainer self) -> IMP::ParticleQuadsTemp
        get(QuadContainer self, unsigned int i) -> IMP::ParticleQuad
        """
        return _IMP_kernel.QuadContainer_get(self, *args)


    def get_number(self):
        """get_number(QuadContainer self) -> unsigned int"""
        return _IMP_kernel.QuadContainer_get_number(self)


    def get_particle_quads(self):
        """get_particle_quads(QuadContainer self) -> IMP::ParticleQuadsTemp"""
        return _IMP_kernel.QuadContainer_get_particle_quads(self)


    def get_particle_quad(self, i):
        """get_particle_quad(QuadContainer self, unsigned int i) -> IMP::ParticleQuad"""
        return _IMP_kernel.QuadContainer_get_particle_quad(self, i)


    def __init__(self, *args):
        """
        __init__(IMP::QuadContainer self, Model m, std::string name) -> QuadContainer
        __init__(IMP::QuadContainer self, Model m) -> QuadContainer
        """
        if self.__class__ == QuadContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_QuadContainer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != QuadContainer:
            _director_objects.register(self)




    def do_apply(self, sm):
        """do_apply(QuadContainer self, QuadModifier sm)"""
        return _IMP_kernel.QuadContainer_do_apply(self, sm)


    def do_get_provides_access(self):
        """do_get_provides_access(QuadContainer self) -> bool"""
        return _IMP_kernel.QuadContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_QuadContainer
    __del__ = lambda self: None

    def __str__(self):
        """__str__(QuadContainer self) -> std::string"""
        return _IMP_kernel.QuadContainer___str__(self)


    def __repr__(self):
        """__repr__(QuadContainer self) -> std::string"""
        return _IMP_kernel.QuadContainer___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_QuadContainer(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_QuadContainer(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(QuadContainer self)"""
        return _IMP_kernel.QuadContainer_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(QuadContainer self, bool arg0)"""
        return _IMP_kernel.QuadContainer_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(QuadContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.QuadContainer_do_get_inputs(self)


    def do_get_interactions(self):
        """do_get_interactions(QuadContainer self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.QuadContainer_do_get_interactions(self)


    def do_get_contents_hash(self):
        """do_get_contents_hash(QuadContainer self) -> std::size_t"""
        return _IMP_kernel.QuadContainer_do_get_contents_hash(self)

QuadContainer_swigregister = _IMP_kernel.QuadContainer_swigregister
QuadContainer_swigregister(QuadContainer)

class _QuadContainerAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::QuadContainerAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::QuadContainerAdaptor self) -> _QuadContainerAdaptor
        __init__(IMP::QuadContainerAdaptor self, QuadContainer c) -> _QuadContainerAdaptor
        __init__(IMP::QuadContainerAdaptor self, IMP::ParticleQuadsTemp const & t) -> _QuadContainerAdaptor
        """
        this = _IMP_kernel.new__QuadContainerAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_name_if_default(self, name):
        """set_name_if_default(_QuadContainerAdaptor self, std::string name)"""
        return _IMP_kernel._QuadContainerAdaptor_set_name_if_default(self, name)

    __swig_destroy__ = _IMP_kernel.delete__QuadContainerAdaptor
    __del__ = lambda self: None
_QuadContainerAdaptor_swigregister = _IMP_kernel._QuadContainerAdaptor_swigregister
_QuadContainerAdaptor_swigregister(_QuadContainerAdaptor)

class SingletonModifier(_ParticleInputs, _ParticleOutputs, Object):
    """Proxy of C++ IMP::SingletonModifier class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::SingletonModifier self, std::string name) -> SingletonModifier
        __init__(IMP::SingletonModifier self) -> SingletonModifier
        """
        if self.__class__ == SingletonModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonModifier(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != SingletonModifier:
            _director_objects.register(self)




    def apply_index(self, m, v):
        """apply_index(SingletonModifier self, Model m, ParticleIndex v)"""
        return _IMP_kernel.SingletonModifier_apply_index(self, m, v)


    def apply_indexes(self, m, o, lower_bound, upper_bound):
        """apply_indexes(SingletonModifier self, Model m, IMP::ParticleIndexes const & o, unsigned int lower_bound, unsigned int upper_bound)"""
        return _IMP_kernel.SingletonModifier_apply_indexes(self, m, o, lower_bound, upper_bound)


    def __str__(self):
        """__str__(SingletonModifier self) -> std::string"""
        return _IMP_kernel.SingletonModifier___str__(self)


    def __repr__(self):
        """__repr__(SingletonModifier self) -> std::string"""
        return _IMP_kernel.SingletonModifier___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_SingletonModifier(o)

    __swig_destroy__ = _IMP_kernel.delete_SingletonModifier
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonModifier(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.SingletonModifier_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(SingletonModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.SingletonModifier_do_get_outputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(SingletonModifier self)"""
        return _IMP_kernel.SingletonModifier_do_destroy(self)

SingletonModifier_swigregister = _IMP_kernel.SingletonModifier_swigregister
SingletonModifier_swigregister(SingletonModifier)

class SingletonScore(_ParticleInputs, Object):
    """Proxy of C++ IMP::SingletonScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::SingletonScore self, std::string name) -> SingletonScore
        __init__(IMP::SingletonScore self) -> SingletonScore
        """
        if self.__class__ == SingletonScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonScore(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != SingletonScore:
            _director_objects.register(self)




    def evaluate_index(self, m, vt, da):
        """evaluate_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.SingletonScore_evaluate_index(self, m, vt, da)


    def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
        """evaluate_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.SingletonScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)


    def evaluate_if_good_index(self, m, vt, da, max):
        """evaluate_if_good_index(SingletonScore self, Model m, ParticleIndex vt, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.SingletonScore_evaluate_if_good_index(self, m, vt, da, max)


    def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
        """evaluate_if_good_indexes(SingletonScore self, Model m, IMP::ParticleIndexes const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.SingletonScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)


    def create_current_decomposition(self, m, vt):
        """create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
        return _IMP_kernel.SingletonScore_create_current_decomposition(self, m, vt)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(SingletonScore self, Model m, ParticleIndex vt) -> IMP::Restraints"""
        return _IMP_kernel.SingletonScore_do_create_current_decomposition(self, m, vt)

    __swig_destroy__ = _IMP_kernel.delete_SingletonScore
    __del__ = lambda self: None

    def __str__(self):
        """__str__(SingletonScore self) -> std::string"""
        return _IMP_kernel.SingletonScore___str__(self)


    def __repr__(self):
        """__repr__(SingletonScore self) -> std::string"""
        return _IMP_kernel.SingletonScore___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_SingletonScore(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonScore(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(SingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.SingletonScore_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(SingletonScore self)"""
        return _IMP_kernel.SingletonScore_do_destroy(self)

SingletonScore_swigregister = _IMP_kernel.SingletonScore_swigregister
SingletonScore_swigregister(SingletonScore)

class SingletonPredicate(_ParticleInputs, Object):
    """Proxy of C++ IMP::SingletonPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::SingletonPredicate self, std::string name) -> SingletonPredicate
        __init__(IMP::SingletonPredicate self) -> SingletonPredicate
        """
        if self.__class__ == SingletonPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonPredicate(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != SingletonPredicate:
            _director_objects.register(self)




    def get_value(self, *args):
        """
        get_value(SingletonPredicate self, Particle vt) -> int
        get_value(SingletonPredicate self, IMP::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.SingletonPredicate_get_value(self, *args)


    def __call__(self, m, vt):
        """__call__(SingletonPredicate self, Model m, ParticleIndex vt) -> int"""
        return _IMP_kernel.SingletonPredicate___call__(self, m, vt)


    def get_value_index(self, *args):
        """
        get_value_index(SingletonPredicate self, Model m, ParticleIndex vt) -> int
        get_value_index(SingletonPredicate self, Model m, IMP::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_kernel.SingletonPredicate_get_value_index(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_SingletonPredicate
    __del__ = lambda self: None

    def __str__(self):
        """__str__(SingletonPredicate self) -> std::string"""
        return _IMP_kernel.SingletonPredicate___str__(self)


    def __repr__(self):
        """__repr__(SingletonPredicate self) -> std::string"""
        return _IMP_kernel.SingletonPredicate___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_SingletonPredicate(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonPredicate(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(SingletonPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.SingletonPredicate_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(SingletonPredicate self)"""
        return _IMP_kernel.SingletonPredicate_do_destroy(self)

SingletonPredicate_swigregister = _IMP_kernel.SingletonPredicate_swigregister
SingletonPredicate_swigregister(SingletonPredicate)

class SingletonContainer(Container):
    """Proxy of C++ IMP::SingletonContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def apply_generic(self, m):
        """apply_generic(SingletonContainer self, SingletonModifier m)"""
        return _IMP_kernel.SingletonContainer_apply_generic(self, m)


    def apply(self, sm):
        """apply(SingletonContainer self, SingletonModifier sm)"""
        return _IMP_kernel.SingletonContainer_apply(self, sm)


    def get_range_indexes(self):
        """get_range_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
        return _IMP_kernel.SingletonContainer_get_range_indexes(self)


    def get_contents(self):
        """get_contents(SingletonContainer self) -> IMP::ParticleIndexes const &"""
        return _IMP_kernel.SingletonContainer_get_contents(self)


    def get_indexes(self):
        """get_indexes(SingletonContainer self) -> IMP::ParticleIndexes"""
        return _IMP_kernel.SingletonContainer_get_indexes(self)


    def get(self, *args):
        """
        get(SingletonContainer self) -> IMP::ParticlesTemp
        get(SingletonContainer self, unsigned int i) -> Particle
        """
        return _IMP_kernel.SingletonContainer_get(self, *args)


    def get_number(self):
        """get_number(SingletonContainer self) -> unsigned int"""
        return _IMP_kernel.SingletonContainer_get_number(self)


    def get_particles(self):
        """get_particles(SingletonContainer self) -> IMP::ParticlesTemp"""
        return _IMP_kernel.SingletonContainer_get_particles(self)


    def get_particle(self, i):
        """get_particle(SingletonContainer self, unsigned int i) -> Particle"""
        return _IMP_kernel.SingletonContainer_get_particle(self, i)


    def __init__(self, *args):
        """
        __init__(IMP::SingletonContainer self, Model m, std::string name) -> SingletonContainer
        __init__(IMP::SingletonContainer self, Model m) -> SingletonContainer
        """
        if self.__class__ == SingletonContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_SingletonContainer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != SingletonContainer:
            _director_objects.register(self)




    def do_apply(self, sm):
        """do_apply(SingletonContainer self, SingletonModifier sm)"""
        return _IMP_kernel.SingletonContainer_do_apply(self, sm)


    def do_get_provides_access(self):
        """do_get_provides_access(SingletonContainer self) -> bool"""
        return _IMP_kernel.SingletonContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_SingletonContainer
    __del__ = lambda self: None

    def __str__(self):
        """__str__(SingletonContainer self) -> std::string"""
        return _IMP_kernel.SingletonContainer___str__(self)


    def __repr__(self):
        """__repr__(SingletonContainer self) -> std::string"""
        return _IMP_kernel.SingletonContainer___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_SingletonContainer(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_SingletonContainer(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(SingletonContainer self)"""
        return _IMP_kernel.SingletonContainer_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(SingletonContainer self, bool arg0)"""
        return _IMP_kernel.SingletonContainer_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(SingletonContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.SingletonContainer_do_get_inputs(self)


    def do_get_interactions(self):
        """do_get_interactions(SingletonContainer self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.SingletonContainer_do_get_interactions(self)


    def do_get_contents_hash(self):
        """do_get_contents_hash(SingletonContainer self) -> std::size_t"""
        return _IMP_kernel.SingletonContainer_do_get_contents_hash(self)

SingletonContainer_swigregister = _IMP_kernel.SingletonContainer_swigregister
SingletonContainer_swigregister(SingletonContainer)

class _SingletonContainerAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::SingletonContainerAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::SingletonContainerAdaptor self) -> _SingletonContainerAdaptor
        __init__(IMP::SingletonContainerAdaptor self, SingletonContainer c) -> _SingletonContainerAdaptor
        __init__(IMP::SingletonContainerAdaptor self, IMP::ParticlesTemp const & t) -> _SingletonContainerAdaptor
        """
        this = _IMP_kernel.new__SingletonContainerAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_name_if_default(self, name):
        """set_name_if_default(_SingletonContainerAdaptor self, std::string name)"""
        return _IMP_kernel._SingletonContainerAdaptor_set_name_if_default(self, name)

    __swig_destroy__ = _IMP_kernel.delete__SingletonContainerAdaptor
    __del__ = lambda self: None
_SingletonContainerAdaptor_swigregister = _IMP_kernel._SingletonContainerAdaptor_swigregister
_SingletonContainerAdaptor_swigregister(_SingletonContainerAdaptor)

class TripletModifier(_ParticleInputs, _ParticleOutputs, Object):
    """Proxy of C++ IMP::TripletModifier class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::TripletModifier self, std::string name) -> TripletModifier
        __init__(IMP::TripletModifier self) -> TripletModifier
        """
        if self.__class__ == TripletModifier:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletModifier(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != TripletModifier:
            _director_objects.register(self)




    def apply_index(self, m, v):
        """apply_index(TripletModifier self, Model m, IMP::ParticleIndexTriplet const & v)"""
        return _IMP_kernel.TripletModifier_apply_index(self, m, v)


    def apply_indexes(self, m, o, lower_bound, upper_bound):
        """apply_indexes(TripletModifier self, Model m, IMP::ParticleIndexTriplets const & o, unsigned int lower_bound, unsigned int upper_bound)"""
        return _IMP_kernel.TripletModifier_apply_indexes(self, m, o, lower_bound, upper_bound)


    def __str__(self):
        """__str__(TripletModifier self) -> std::string"""
        return _IMP_kernel.TripletModifier___str__(self)


    def __repr__(self):
        """__repr__(TripletModifier self) -> std::string"""
        return _IMP_kernel.TripletModifier___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_TripletModifier(o)

    __swig_destroy__ = _IMP_kernel.delete_TripletModifier
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletModifier(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.TripletModifier_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(TripletModifier self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.TripletModifier_do_get_outputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(TripletModifier self)"""
        return _IMP_kernel.TripletModifier_do_destroy(self)

TripletModifier_swigregister = _IMP_kernel.TripletModifier_swigregister
TripletModifier_swigregister(TripletModifier)

class TripletScore(_ParticleInputs, Object):
    """Proxy of C++ IMP::TripletScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::TripletScore self, std::string name) -> TripletScore
        __init__(IMP::TripletScore self) -> TripletScore
        """
        if self.__class__ == TripletScore:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletScore(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != TripletScore:
            _director_objects.register(self)




    def evaluate_index(self, m, vt, da):
        """evaluate_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da) -> double"""
        return _IMP_kernel.TripletScore_evaluate_index(self, m, vt, da)


    def evaluate_indexes(self, m, o, da, lower_bound, upper_bound):
        """evaluate_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.TripletScore_evaluate_indexes(self, m, o, da, lower_bound, upper_bound)


    def evaluate_if_good_index(self, m, vt, da, max):
        """evaluate_if_good_index(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt, DerivativeAccumulator da, double max) -> double"""
        return _IMP_kernel.TripletScore_evaluate_if_good_index(self, m, vt, da, max)


    def evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound):
        """evaluate_if_good_indexes(TripletScore self, Model m, IMP::ParticleIndexTriplets const & o, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double"""
        return _IMP_kernel.TripletScore_evaluate_if_good_indexes(self, m, o, da, max, lower_bound, upper_bound)


    def create_current_decomposition(self, m, vt):
        """create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
        return _IMP_kernel.TripletScore_create_current_decomposition(self, m, vt)


    def do_create_current_decomposition(self, m, vt):
        """do_create_current_decomposition(TripletScore self, Model m, IMP::ParticleIndexTriplet const & vt) -> IMP::Restraints"""
        return _IMP_kernel.TripletScore_do_create_current_decomposition(self, m, vt)

    __swig_destroy__ = _IMP_kernel.delete_TripletScore
    __del__ = lambda self: None

    def __str__(self):
        """__str__(TripletScore self) -> std::string"""
        return _IMP_kernel.TripletScore___str__(self)


    def __repr__(self):
        """__repr__(TripletScore self) -> std::string"""
        return _IMP_kernel.TripletScore___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_TripletScore(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletScore(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(TripletScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.TripletScore_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(TripletScore self)"""
        return _IMP_kernel.TripletScore_do_destroy(self)

TripletScore_swigregister = _IMP_kernel.TripletScore_swigregister
TripletScore_swigregister(TripletScore)

class TripletPredicate(_ParticleInputs, Object):
    """Proxy of C++ IMP::TripletPredicate class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::TripletPredicate self, std::string name) -> TripletPredicate
        __init__(IMP::TripletPredicate self) -> TripletPredicate
        """
        if self.__class__ == TripletPredicate:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletPredicate(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != TripletPredicate:
            _director_objects.register(self)




    def get_value(self, *args):
        """
        get_value(TripletPredicate self, IMP::ParticleTriplet const & vt) -> int
        get_value(TripletPredicate self, IMP::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_kernel.TripletPredicate_get_value(self, *args)


    def __call__(self, m, vt):
        """__call__(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int"""
        return _IMP_kernel.TripletPredicate___call__(self, m, vt)


    def get_value_index(self, *args):
        """
        get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplet const & vt) -> int
        get_value_index(TripletPredicate self, Model m, IMP::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_kernel.TripletPredicate_get_value_index(self, *args)

    __swig_destroy__ = _IMP_kernel.delete_TripletPredicate
    __del__ = lambda self: None

    def __str__(self):
        """__str__(TripletPredicate self) -> std::string"""
        return _IMP_kernel.TripletPredicate___str__(self)


    def __repr__(self):
        """__repr__(TripletPredicate self) -> std::string"""
        return _IMP_kernel.TripletPredicate___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_TripletPredicate(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletPredicate(self)
        return weakref_proxy(self)

    def do_get_inputs(self, m, pis):
        """do_get_inputs(TripletPredicate self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.TripletPredicate_do_get_inputs(self, m, pis)


    def do_destroy(self):
        """do_destroy(TripletPredicate self)"""
        return _IMP_kernel.TripletPredicate_do_destroy(self)

TripletPredicate_swigregister = _IMP_kernel.TripletPredicate_swigregister
TripletPredicate_swigregister(TripletPredicate)

class TripletContainer(Container):
    """Proxy of C++ IMP::TripletContainer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def apply_generic(self, m):
        """apply_generic(TripletContainer self, TripletModifier m)"""
        return _IMP_kernel.TripletContainer_apply_generic(self, m)


    def apply(self, sm):
        """apply(TripletContainer self, TripletModifier sm)"""
        return _IMP_kernel.TripletContainer_apply(self, sm)


    def get_range_indexes(self):
        """get_range_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
        return _IMP_kernel.TripletContainer_get_range_indexes(self)


    def get_contents(self):
        """get_contents(TripletContainer self) -> IMP::ParticleIndexTriplets const &"""
        return _IMP_kernel.TripletContainer_get_contents(self)


    def get_indexes(self):
        """get_indexes(TripletContainer self) -> IMP::ParticleIndexTriplets"""
        return _IMP_kernel.TripletContainer_get_indexes(self)


    def get(self, *args):
        """
        get(TripletContainer self) -> IMP::ParticleTripletsTemp
        get(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet
        """
        return _IMP_kernel.TripletContainer_get(self, *args)


    def get_number(self):
        """get_number(TripletContainer self) -> unsigned int"""
        return _IMP_kernel.TripletContainer_get_number(self)


    def get_particle_triplets(self):
        """get_particle_triplets(TripletContainer self) -> IMP::ParticleTripletsTemp"""
        return _IMP_kernel.TripletContainer_get_particle_triplets(self)


    def get_particle_triplet(self, i):
        """get_particle_triplet(TripletContainer self, unsigned int i) -> IMP::ParticleTriplet"""
        return _IMP_kernel.TripletContainer_get_particle_triplet(self, i)


    def __init__(self, *args):
        """
        __init__(IMP::TripletContainer self, Model m, std::string name) -> TripletContainer
        __init__(IMP::TripletContainer self, Model m) -> TripletContainer
        """
        if self.__class__ == TripletContainer:
            _self = None
        else:
            _self = self
        this = _IMP_kernel.new_TripletContainer(_self, *args)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != TripletContainer:
            _director_objects.register(self)




    def do_apply(self, sm):
        """do_apply(TripletContainer self, TripletModifier sm)"""
        return _IMP_kernel.TripletContainer_do_apply(self, sm)


    def do_get_provides_access(self):
        """do_get_provides_access(TripletContainer self) -> bool"""
        return _IMP_kernel.TripletContainer_do_get_provides_access(self)

    __swig_destroy__ = _IMP_kernel.delete_TripletContainer
    __del__ = lambda self: None

    def __str__(self):
        """__str__(TripletContainer self) -> std::string"""
        return _IMP_kernel.TripletContainer___str__(self)


    def __repr__(self):
        """__repr__(TripletContainer self) -> std::string"""
        return _IMP_kernel.TripletContainer___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP" == "IMP":
          return VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_TripletContainer(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kernel.disown_TripletContainer(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(TripletContainer self)"""
        return _IMP_kernel.TripletContainer_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(TripletContainer self, bool arg0)"""
        return _IMP_kernel.TripletContainer_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(TripletContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel.TripletContainer_do_get_inputs(self)


    def do_get_interactions(self):
        """do_get_interactions(TripletContainer self) -> IMP::ModelObjectsTemps"""
        return _IMP_kernel.TripletContainer_do_get_interactions(self)


    def do_get_contents_hash(self):
        """do_get_contents_hash(TripletContainer self) -> std::size_t"""
        return _IMP_kernel.TripletContainer_do_get_contents_hash(self)

TripletContainer_swigregister = _IMP_kernel.TripletContainer_swigregister
TripletContainer_swigregister(TripletContainer)

class _TripletContainerAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::TripletContainerAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::TripletContainerAdaptor self) -> _TripletContainerAdaptor
        __init__(IMP::TripletContainerAdaptor self, TripletContainer c) -> _TripletContainerAdaptor
        __init__(IMP::TripletContainerAdaptor self, IMP::ParticleTripletsTemp const & t) -> _TripletContainerAdaptor
        """
        this = _IMP_kernel.new__TripletContainerAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_name_if_default(self, name):
        """set_name_if_default(_TripletContainerAdaptor self, std::string name)"""
        return _IMP_kernel._TripletContainerAdaptor_set_name_if_default(self, name)

    __swig_destroy__ = _IMP_kernel.delete__TripletContainerAdaptor
    __del__ = lambda self: None
_TripletContainerAdaptor_swigregister = _IMP_kernel._TripletContainerAdaptor_swigregister
_TripletContainerAdaptor_swigregister(_TripletContainerAdaptor)


def write_particles_to_buffer(particles, keys):
    """write_particles_to_buffer(IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys) -> IMP::Vector< char >"""
    return _IMP_kernel.write_particles_to_buffer(particles, keys)

def read_particles_from_buffer(buffer, particles, keys):
    """read_particles_from_buffer(IMP::Vector< char > const & buffer, IMP::ParticlesTemp const & particles, IMP::FloatKeys const & keys)"""
    return _IMP_kernel.read_particles_from_buffer(buffer, particles, keys)

def get_particles(m, ps):
    """get_particles(Model m, IMP::ParticleIndexes const & ps) -> IMP::ParticlesTemp"""
    return _IMP_kernel.get_particles(m, ps)

def get_indexes(*args):
    """
    get_indexes(IMP::ParticlesTemp const & ps) -> IMP::ParticleIndexes
    get_indexes(IMP::ParticlePairsTemp const & ps) -> IMP::ParticleIndexPairs
    """
    return _IMP_kernel.get_indexes(*args)
class _ParticleIndexAdaptor(object):
    """Proxy of C++ IMP::ParticleIndexAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::ParticleIndexAdaptor self, Particle p) -> _ParticleIndexAdaptor
        __init__(IMP::ParticleIndexAdaptor self, ParticleIndex pi) -> _ParticleIndexAdaptor
        __init__(IMP::ParticleIndexAdaptor self, Decorator d) -> _ParticleIndexAdaptor
        """
        this = _IMP_kernel.new__ParticleIndexAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexAdaptor
    __del__ = lambda self: None
_ParticleIndexAdaptor_swigregister = _IMP_kernel._ParticleIndexAdaptor_swigregister
_ParticleIndexAdaptor_swigregister(_ParticleIndexAdaptor)

class _ParticleIndexesAdaptor(_InputAdaptor):
    """Proxy of C++ IMP::ParticleIndexesAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticlesTemp const & ps) -> _ParticleIndexesAdaptor
        __init__(IMP::ParticleIndexesAdaptor self, IMP::ParticleIndexes const & pi) -> _ParticleIndexesAdaptor
        __init__(IMP::ParticleIndexesAdaptor self) -> _ParticleIndexesAdaptor
        """
        this = _IMP_kernel.new__ParticleIndexesAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexesAdaptor
    __del__ = lambda self: None
_ParticleIndexesAdaptor_swigregister = _IMP_kernel._ParticleIndexesAdaptor_swigregister
_ParticleIndexesAdaptor_swigregister(_ParticleIndexesAdaptor)

class _ParticleIndexPairsAdaptor(object):
    """Proxy of C++ IMP::ParticleIndexPairsAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticlePairsTemp const & ps) -> _ParticleIndexPairsAdaptor
        __init__(IMP::ParticleIndexPairsAdaptor self, IMP::ParticleIndexPairs const & pi) -> _ParticleIndexPairsAdaptor
        __init__(IMP::ParticleIndexPairsAdaptor self) -> _ParticleIndexPairsAdaptor
        """
        this = _IMP_kernel.new__ParticleIndexPairsAdaptor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ParticleIndexPairsAdaptor
    __del__ = lambda self: None
_ParticleIndexPairsAdaptor_swigregister = _IMP_kernel._ParticleIndexPairsAdaptor_swigregister
_ParticleIndexPairsAdaptor_swigregister(_ParticleIndexPairsAdaptor)

class _ConstRestraint(Restraint):
    """Proxy of C++ IMP::internal::_ConstRestraint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::internal::_ConstRestraint self, double v, IMP::ParticlesTemp const ps) -> _ConstRestraint
        __init__(IMP::internal::_ConstRestraint self, Model m, IMP::ParticleIndexes const & pis, double v) -> _ConstRestraint
        """
        this = _IMP_kernel.new__ConstRestraint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_value(self):
        """get_value(_ConstRestraint self) -> double"""
        return _IMP_kernel._ConstRestraint_get_value(self)


    def do_create_decomposition(self):
        """do_create_decomposition(_ConstRestraint self) -> IMP::Restraints"""
        return _IMP_kernel._ConstRestraint_do_create_decomposition(self)


    def do_get_inputs(self):
        """do_get_inputs(_ConstRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel._ConstRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(_ConstRestraint self) -> VersionInfo"""
        return _IMP_kernel._ConstRestraint_get_version_info(self)


    def __str__(self):
        """__str__(_ConstRestraint self) -> std::string"""
        return _IMP_kernel._ConstRestraint___str__(self)


    def __repr__(self):
        """__repr__(_ConstRestraint self) -> std::string"""
        return _IMP_kernel._ConstRestraint___repr__(self)


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

_ConstRestraint_swigregister = _IMP_kernel._ConstRestraint_swigregister
_ConstRestraint_swigregister(_ConstRestraint)

class _ConstSingletonScore(SingletonScore):
    """Proxy of C++ IMP::internal::_ConstSingletonScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, v):
        """__init__(IMP::internal::_ConstSingletonScore self, double v) -> _ConstSingletonScore"""
        this = _IMP_kernel.new__ConstSingletonScore(v)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, arg2, arg3):
        """do_get_inputs(_ConstSingletonScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel._ConstSingletonScore_do_get_inputs(self, arg2, arg3)


    def get_version_info(self):
        """get_version_info(_ConstSingletonScore self) -> VersionInfo"""
        return _IMP_kernel._ConstSingletonScore_get_version_info(self)

_ConstSingletonScore_swigregister = _IMP_kernel._ConstSingletonScore_swigregister
_ConstSingletonScore_swigregister(_ConstSingletonScore)

class _ConstPairScore(PairScore):
    """Proxy of C++ IMP::internal::_ConstPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, v):
        """__init__(IMP::internal::_ConstPairScore self, double v) -> _ConstPairScore"""
        this = _IMP_kernel.new__ConstPairScore(v)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, arg2, arg3):
        """do_get_inputs(_ConstPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel._ConstPairScore_do_get_inputs(self, arg2, arg3)


    def get_version_info(self):
        """get_version_info(_ConstPairScore self) -> VersionInfo"""
        return _IMP_kernel._ConstPairScore_get_version_info(self)

_ConstPairScore_swigregister = _IMP_kernel._ConstPairScore_swigregister
_ConstPairScore_swigregister(_ConstPairScore)

class _TrivialDecorator(Decorator):
    """Proxy of C++ IMP::internal::_TrivialDecorator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::internal::_TrivialDecorator self) -> _TrivialDecorator
        __init__(IMP::internal::_TrivialDecorator self, Model m, ParticleIndex id) -> _TrivialDecorator
        __init__(IMP::internal::_TrivialDecorator self, _ParticleAdaptor d) -> _TrivialDecorator
        """
        this = _IMP_kernel.new__TrivialDecorator(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(_TrivialDecorator self, _ostream out)
        show(_TrivialDecorator self)
        """
        return _IMP_kernel._TrivialDecorator_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
        setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
        """
        return _IMP_kernel._TrivialDecorator_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_kernel._TrivialDecorator_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(_TrivialDecorator self, FloatKey a0)
        remove_attribute(_TrivialDecorator self, IntKey a0)
        remove_attribute(_TrivialDecorator self, StringKey a0)
        remove_attribute(_TrivialDecorator self, ParticleIndexKey a0)
        remove_attribute(_TrivialDecorator self, ObjectKey a0)
        """
        return _IMP_kernel._TrivialDecorator_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(_TrivialDecorator self, FloatKey a0) -> bool
        has_attribute(_TrivialDecorator self, IntKey a0) -> bool
        has_attribute(_TrivialDecorator self, StringKey a0) -> bool
        has_attribute(_TrivialDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(_TrivialDecorator self, ObjectKey a0) -> bool
        """
        return _IMP_kernel._TrivialDecorator_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(_TrivialDecorator self, FloatKey a0) -> double"""
        return _IMP_kernel._TrivialDecorator_get_derivative(self, a0)


    def get_name(self):
        """get_name(_TrivialDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDecorator_get_name(self)


    def clear_caches(self):
        """clear_caches(_TrivialDecorator self)"""
        return _IMP_kernel._TrivialDecorator_clear_caches(self)


    def set_name(self, a0):
        """set_name(_TrivialDecorator self, std::string a0)"""
        return _IMP_kernel._TrivialDecorator_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(_TrivialDecorator self, IMP::CheckLevel a0)"""
        return _IMP_kernel._TrivialDecorator_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(_TrivialDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_kernel._TrivialDecorator_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(_TrivialDecorator self, FloatKey a0, bool a1)"""
        return _IMP_kernel._TrivialDecorator_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(_TrivialDecorator self, FloatKey a0) -> bool"""
        return _IMP_kernel._TrivialDecorator_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(_TrivialDecorator self) -> IMP::CheckLevel"""
        return _IMP_kernel._TrivialDecorator_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __eq__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __ne__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __le__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __lt__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __ge__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(_TrivialDecorator self, _TrivialDecorator o) -> bool
        __gt__(_TrivialDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDecorator___gt__(self, *args)


    def __hash__(self):
        """__hash__(_TrivialDecorator self) -> std::size_t"""
        return _IMP_kernel._TrivialDecorator___hash__(self)


    def __str__(self):
        """__str__(_TrivialDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDecorator___str__(self)


    def __repr__(self):
        """__repr__(_TrivialDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDecorator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__TrivialDecorator
    __del__ = lambda self: None
_TrivialDecorator_swigregister = _IMP_kernel._TrivialDecorator_swigregister
_TrivialDecorator_swigregister(_TrivialDecorator)

def _TrivialDecorator_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> _TrivialDecorator
    _TrivialDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDecorator
    """
    return _IMP_kernel._TrivialDecorator_setup_particle(*args)

def _TrivialDecorator_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    _TrivialDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_kernel._TrivialDecorator_get_is_setup(*args)

class _TrivialDerivedDecorator(_TrivialDecorator):
    """Proxy of C++ IMP::internal::_TrivialDerivedDecorator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::internal::_TrivialDerivedDecorator self) -> _TrivialDerivedDecorator
        __init__(IMP::internal::_TrivialDerivedDecorator self, Model m, ParticleIndex id) -> _TrivialDerivedDecorator
        __init__(IMP::internal::_TrivialDerivedDecorator self, _ParticleAdaptor d) -> _TrivialDerivedDecorator
        """
        this = _IMP_kernel.new__TrivialDerivedDecorator(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(_TrivialDerivedDecorator self, _ostream out)
        show(_TrivialDerivedDecorator self)
        """
        return _IMP_kernel._TrivialDerivedDecorator_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
        setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
        """
        return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(_TrivialDerivedDecorator self, FloatKey a0)
        remove_attribute(_TrivialDerivedDecorator self, IntKey a0)
        remove_attribute(_TrivialDerivedDecorator self, StringKey a0)
        remove_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0)
        remove_attribute(_TrivialDerivedDecorator self, ObjectKey a0)
        """
        return _IMP_kernel._TrivialDerivedDecorator_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(_TrivialDerivedDecorator self, FloatKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, IntKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, StringKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(_TrivialDerivedDecorator self, ObjectKey a0) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(_TrivialDerivedDecorator self, FloatKey a0) -> double"""
        return _IMP_kernel._TrivialDerivedDecorator_get_derivative(self, a0)


    def get_name(self):
        """get_name(_TrivialDerivedDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDerivedDecorator_get_name(self)


    def clear_caches(self):
        """clear_caches(_TrivialDerivedDecorator self)"""
        return _IMP_kernel._TrivialDerivedDecorator_clear_caches(self)


    def set_name(self, a0):
        """set_name(_TrivialDerivedDecorator self, std::string a0)"""
        return _IMP_kernel._TrivialDerivedDecorator_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(_TrivialDerivedDecorator self, IMP::CheckLevel a0)"""
        return _IMP_kernel._TrivialDerivedDecorator_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(_TrivialDerivedDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_kernel._TrivialDerivedDecorator_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(_TrivialDerivedDecorator self, FloatKey a0, bool a1)"""
        return _IMP_kernel._TrivialDerivedDecorator_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(_TrivialDerivedDecorator self, FloatKey a0) -> bool"""
        return _IMP_kernel._TrivialDerivedDecorator_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(_TrivialDerivedDecorator self) -> IMP::CheckLevel"""
        return _IMP_kernel._TrivialDerivedDecorator_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __eq__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __ne__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __le__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __lt__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __ge__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(_TrivialDerivedDecorator self, _TrivialDerivedDecorator o) -> bool
        __gt__(_TrivialDerivedDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialDerivedDecorator___gt__(self, *args)


    def __hash__(self):
        """__hash__(_TrivialDerivedDecorator self) -> std::size_t"""
        return _IMP_kernel._TrivialDerivedDecorator___hash__(self)


    def __str__(self):
        """__str__(_TrivialDerivedDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDerivedDecorator___str__(self)


    def __repr__(self):
        """__repr__(_TrivialDerivedDecorator self) -> std::string"""
        return _IMP_kernel._TrivialDerivedDecorator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__TrivialDerivedDecorator
    __del__ = lambda self: None
_TrivialDerivedDecorator_swigregister = _IMP_kernel._TrivialDerivedDecorator_swigregister
_TrivialDerivedDecorator_swigregister(_TrivialDerivedDecorator)

def _TrivialDerivedDecorator_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> _TrivialDerivedDecorator
    _TrivialDerivedDecorator_setup_particle(_ParticleAdaptor decorator) -> _TrivialDerivedDecorator
    """
    return _IMP_kernel._TrivialDerivedDecorator_setup_particle(*args)

def _TrivialDerivedDecorator_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    _TrivialDerivedDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_kernel._TrivialDerivedDecorator_get_is_setup(*args)

class _TrivialTraitsDecorator(Decorator):
    """Proxy of C++ IMP::internal::_TrivialTraitsDecorator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def get_decorator_traits(self):
        """get_decorator_traits(_TrivialTraitsDecorator self) -> StringKey"""
        return _IMP_kernel._TrivialTraitsDecorator_get_decorator_traits(self)


    def get_default_decorator_traits():
        """get_default_decorator_traits() -> StringKey"""
        return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()

    get_default_decorator_traits = staticmethod(get_default_decorator_traits)

    def __init__(self, *args):
        """
        __init__(IMP::internal::_TrivialTraitsDecorator self) -> _TrivialTraitsDecorator
        __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id, StringKey tr) -> _TrivialTraitsDecorator
        __init__(IMP::internal::_TrivialTraitsDecorator self, Model m, ParticleIndex id) -> _TrivialTraitsDecorator
        __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
        __init__(IMP::internal::_TrivialTraitsDecorator self, _ParticleAdaptor d) -> _TrivialTraitsDecorator
        """
        this = _IMP_kernel.new__TrivialTraitsDecorator(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def show(self, *args):
        """
        show(_TrivialTraitsDecorator self, _ostream out)
        show(_TrivialTraitsDecorator self)
        """
        return _IMP_kernel._TrivialTraitsDecorator_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
        setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
        setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
        setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
        """
        return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_default_key():
        """get_default_key() -> StringKey"""
        return _IMP_kernel._TrivialTraitsDecorator_get_default_key()

    get_default_key = staticmethod(get_default_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(_TrivialTraitsDecorator self, FloatKey a0)
        remove_attribute(_TrivialTraitsDecorator self, IntKey a0)
        remove_attribute(_TrivialTraitsDecorator self, StringKey a0)
        remove_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0)
        remove_attribute(_TrivialTraitsDecorator self, ObjectKey a0)
        """
        return _IMP_kernel._TrivialTraitsDecorator_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(_TrivialTraitsDecorator self, FloatKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, IntKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, StringKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, ParticleIndexKey a0) -> bool
        has_attribute(_TrivialTraitsDecorator self, ObjectKey a0) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(_TrivialTraitsDecorator self, FloatKey a0) -> double"""
        return _IMP_kernel._TrivialTraitsDecorator_get_derivative(self, a0)


    def get_name(self):
        """get_name(_TrivialTraitsDecorator self) -> std::string"""
        return _IMP_kernel._TrivialTraitsDecorator_get_name(self)


    def clear_caches(self):
        """clear_caches(_TrivialTraitsDecorator self)"""
        return _IMP_kernel._TrivialTraitsDecorator_clear_caches(self)


    def set_name(self, a0):
        """set_name(_TrivialTraitsDecorator self, std::string a0)"""
        return _IMP_kernel._TrivialTraitsDecorator_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(_TrivialTraitsDecorator self, IMP::CheckLevel a0)"""
        return _IMP_kernel._TrivialTraitsDecorator_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(_TrivialTraitsDecorator self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_kernel._TrivialTraitsDecorator_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(_TrivialTraitsDecorator self, FloatKey a0, bool a1)"""
        return _IMP_kernel._TrivialTraitsDecorator_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(_TrivialTraitsDecorator self, FloatKey a0) -> bool"""
        return _IMP_kernel._TrivialTraitsDecorator_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(_TrivialTraitsDecorator self) -> IMP::CheckLevel"""
        return _IMP_kernel._TrivialTraitsDecorator_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __eq__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __ne__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __le__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __lt__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __ge__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(_TrivialTraitsDecorator self, _TrivialTraitsDecorator o) -> bool
        __gt__(_TrivialTraitsDecorator self, Particle d) -> bool
        """
        return _IMP_kernel._TrivialTraitsDecorator___gt__(self, *args)


    def __hash__(self):
        """__hash__(_TrivialTraitsDecorator self) -> std::size_t"""
        return _IMP_kernel._TrivialTraitsDecorator___hash__(self)


    def __str__(self):
        """__str__(_TrivialTraitsDecorator self) -> std::string"""
        return _IMP_kernel._TrivialTraitsDecorator___str__(self)


    def __repr__(self):
        """__repr__(_TrivialTraitsDecorator self) -> std::string"""
        return _IMP_kernel._TrivialTraitsDecorator___repr__(self)

    __swig_destroy__ = _IMP_kernel.delete__TrivialTraitsDecorator
    __del__ = lambda self: None
_TrivialTraitsDecorator_swigregister = _IMP_kernel._TrivialTraitsDecorator_swigregister
_TrivialTraitsDecorator_swigregister(_TrivialTraitsDecorator)

def _TrivialTraitsDecorator_get_default_decorator_traits():
    """_TrivialTraitsDecorator_get_default_decorator_traits() -> StringKey"""
    return _IMP_kernel._TrivialTraitsDecorator_get_default_decorator_traits()

def _TrivialTraitsDecorator_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, StringKey tr) -> _TrivialTraitsDecorator
    setup_particle(Model m, ParticleIndex pi) -> _TrivialTraitsDecorator
    setup_particle(_ParticleAdaptor d, StringKey tr) -> _TrivialTraitsDecorator
    _TrivialTraitsDecorator_setup_particle(_ParticleAdaptor d) -> _TrivialTraitsDecorator
    """
    return _IMP_kernel._TrivialTraitsDecorator_setup_particle(*args)

def _TrivialTraitsDecorator_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p, StringKey tr) -> bool
    get_is_setup(_ParticleAdaptor p) -> bool
    get_is_setup(Model m, ParticleIndex pi, StringKey k) -> bool
    _TrivialTraitsDecorator_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_kernel._TrivialTraitsDecorator_get_is_setup(*args)

def _TrivialTraitsDecorator_get_default_key():
    """_TrivialTraitsDecorator_get_default_key() -> StringKey"""
    return _IMP_kernel._TrivialTraitsDecorator_get_default_key()


def __lshift__(*args):
    """
    __lshift__(_ostream out, _TrivialDecorator n) -> _ostream
    __lshift__(_ostream out, _TrivialDerivedDecorator n) -> _ostream
    __lshift__(_ostream out, _TrivialTraitsDecorator n) -> _ostream
    """
    return _IMP_kernel.__lshift__(*args)
class _ConstOptimizer(Optimizer):
    """Proxy of C++ IMP::internal::_ConstOptimizer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m):
        """__init__(IMP::internal::_ConstOptimizer self, Model m) -> _ConstOptimizer"""
        this = _IMP_kernel.new__ConstOptimizer(m)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_optimize(self, max_steps):
        """do_optimize(_ConstOptimizer self, unsigned int max_steps) -> IMP::Float"""
        return _IMP_kernel._ConstOptimizer_do_optimize(self, max_steps)


    def get_version_info(self):
        """get_version_info(_ConstOptimizer self) -> VersionInfo"""
        return _IMP_kernel._ConstOptimizer_get_version_info(self)


    def __str__(self):
        """__str__(_ConstOptimizer self) -> std::string"""
        return _IMP_kernel._ConstOptimizer___str__(self)


    def __repr__(self):
        """__repr__(_ConstOptimizer self) -> std::string"""
        return _IMP_kernel._ConstOptimizer___repr__(self)


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

_ConstOptimizer_swigregister = _IMP_kernel._ConstOptimizer_swigregister
_ConstOptimizer_swigregister(_ConstOptimizer)


def get_particle(p):
    """get_particle(Particle p) -> Particle"""
    return _IMP_kernel.get_particle(p)

def _decorator_test(p):
    """_decorator_test(Particle p)"""
    return _IMP_kernel._decorator_test(p)

def _overloaded_decorator(*args):
    """
    _overloaded_decorator(_TrivialDecorator a) -> int
    _overloaded_decorator(_TrivialDerivedDecorator a) -> int
    """
    return _IMP_kernel._overloaded_decorator(*args)

def _take_particles(*args):
    """
    _take_particles(IMP::Particles const & ps) -> unsigned int
    _take_particles(Model m, IMP::Particles const & ps) -> unsigned int
    _take_particles(Model m, IMP::Particles const & ps, TextOutput out) -> unsigned int
    """
    return _IMP_kernel._take_particles(*args)

def _give_particles(m):
    """_give_particles(Model m) -> IMP::Particles const &"""
    return _IMP_kernel._give_particles(m)

def _pass_particles(ps):
    """_pass_particles(IMP::Particles const & ps) -> IMP::Particles const &"""
    return _IMP_kernel._pass_particles(ps)

def _pass_particle(ps):
    """_pass_particle(Particle ps) -> Particle"""
    return _IMP_kernel._pass_particle(ps)

def _pass_particle_pair(pp):
    """_pass_particle_pair(IMP::ParticlePair const & pp) -> IMP::ParticlePair const &"""
    return _IMP_kernel._pass_particle_pair(pp)

def _give_particles_copy(m):
    """_give_particles_copy(Model m) -> IMP::Particles"""
    return _IMP_kernel._give_particles_copy(m)

def _pass_float_keys(input):
    """_pass_float_keys(IMP::FloatKeys const & input) -> IMP::FloatKeys"""
    return _IMP_kernel._pass_float_keys(input)

def _pass(*args):
    """
    _pass(IMP::Particles const & p) -> IMP::Particles const
    _pass(IMP::Restraints const & p) -> IMP::Restraints const &
    """
    return _IMP_kernel._pass(*args)

def _pass_decorators(p):
    """_pass_decorators(IMP::internal::_TrivialDecorators const & p) -> IMP::internal::_TrivialDecorators const &"""
    return _IMP_kernel._pass_decorators(p)

def _pass_decorator_traits(p):
    """_pass_decorator_traits(IMP::internal::_TrivialTraitsDecorators const & p) -> IMP::internal::_TrivialTraitsDecorators const &"""
    return _IMP_kernel._pass_decorator_traits(p)

def _pass_particle_pairs(p):
    """_pass_particle_pairs(IMP::ParticlePairsTemp const & p) -> IMP::ParticlePairsTemp"""
    return _IMP_kernel._pass_particle_pairs(p)

def _pass_particle_index_pairs(p):
    """_pass_particle_index_pairs(IMP::ParticleIndexPairs const & p) -> IMP::ParticleIndexPairs"""
    return _IMP_kernel._pass_particle_index_pairs(p)

def _pass_model_objects(p):
    """_pass_model_objects(IMP::ModelObjectsTemp const & p) -> IMP::ModelObjectsTemp"""
    return _IMP_kernel._pass_model_objects(p)

def _pass_particles_temps(ps):
    """_pass_particles_temps(IMP::ParticlesTemps const & ps) -> IMP::ParticlesTemps"""
    return _IMP_kernel._pass_particles_temps(ps)

def _test_overload(*args):
    """
    _test_overload(IMP::Particles const & ps) -> int
    _test_overload(IMP::Restraints const & ps) -> int
    """
    return _IMP_kernel._test_overload(*args)

def _get_range(m, k):
    """_get_range(Model m, FloatKey k) -> IMP::FloatRange"""
    return _IMP_kernel._get_range(m, k)

def _create_particles_from_pdb(name, m):
    """_create_particles_from_pdb(std::string name, Model m) -> IMP::ParticleIndexes"""
    return _IMP_kernel._create_particles_from_pdb(name, m)
class _LogPairScore(PairScore):
    """Proxy of C++ IMP::internal::_LogPairScore class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(IMP::internal::_LogPairScore self) -> _LogPairScore"""
        this = _IMP_kernel.new__LogPairScore()
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_get_inputs(self, arg2, arg3):
        """do_get_inputs(_LogPairScore self, Model arg2, IMP::ParticleIndexes const & arg3) -> IMP::ModelObjectsTemp"""
        return _IMP_kernel._LogPairScore_do_get_inputs(self, arg2, arg3)


    def get_version_info(self):
        """get_version_info(_LogPairScore self) -> VersionInfo"""
        return _IMP_kernel._LogPairScore_get_version_info(self)


    def get_particle_pairs(self):
        """get_particle_pairs(_LogPairScore self) -> IMP::ParticlePairsTemp"""
        return _IMP_kernel._LogPairScore_get_particle_pairs(self)


    def clear(self):
        """clear(_LogPairScore self)"""
        return _IMP_kernel._LogPairScore_clear(self)


    def get_contains(self, pp):
        """get_contains(_LogPairScore self, IMP::ParticlePair const & pp) -> bool"""
        return _IMP_kernel._LogPairScore_get_contains(self, pp)

_LogPairScore_swigregister = _IMP_kernel._LogPairScore_swigregister
_LogPairScore_swigregister(_LogPairScore)


def _overloaded_particles(*args):
    """
    _overloaded_particles(Particle arg1)
    _overloaded_particles(IMP::Particles const & arg1)
    _overloaded_particles(IMP::ParticlesTemp const & arg1)
    _overloaded_particles(Model arg1, IMP::ParticleIndexes const & arg2)
    _overloaded_particles(IMP::internal::_TrivialDecorators const & arg1)
    _overloaded_particles(_TrivialDecorator arg1)
    """
    return _IMP_kernel._overloaded_particles(*args)
class _ImplicitParticles(object):
    """Proxy of C++ IMP::internal::_ImplicitParticles class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IMP::internal::_ImplicitParticles self, Particle arg2) -> _ImplicitParticles
        __init__(IMP::internal::_ImplicitParticles self, IMP::Particles const & arg2) -> _ImplicitParticles
        __init__(IMP::internal::_ImplicitParticles self, IMP::ParticlesTemp const & arg2) -> _ImplicitParticles
        __init__(IMP::internal::_ImplicitParticles self, Model arg2, IMP::ParticleIndexes const & arg3) -> _ImplicitParticles
        __init__(IMP::internal::_ImplicitParticles self, IMP::internal::_TrivialDecorators const & arg2) -> _ImplicitParticles
        __init__(IMP::internal::_ImplicitParticles self, _TrivialDecorator arg2) -> _ImplicitParticles
        """
        this = _IMP_kernel.new__ImplicitParticles(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete__ImplicitParticles
    __del__ = lambda self: None
_ImplicitParticles_swigregister = _IMP_kernel._ImplicitParticles_swigregister
_ImplicitParticles_swigregister(_ImplicitParticles)


def _implicit_particles(arg1):
    """_implicit_particles(_ImplicitParticles arg1)"""
    return _IMP_kernel._implicit_particles(arg1)

def _take_particle_adaptor(pa):
    """_take_particle_adaptor(_ParticleAdaptor pa) -> ParticleIndex"""
    return _IMP_kernel._take_particle_adaptor(pa)

def _take_particle_indexes_adaptor(pa):
    """_take_particle_indexes_adaptor(_ParticleIndexesAdaptor pa) -> IMP::ParticleIndexes"""
    return _IMP_kernel._take_particle_indexes_adaptor(pa)
class ScopedSetFloatAttribute(_RAII):
    """Proxy of C++ IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self) -> ScopedSetFloatAttribute
        __init__(IMP::ScopedSetAttribute<(FloatKey,IMP::Float)> self, Particle p, FloatKey key, double const & value) -> ScopedSetFloatAttribute
        """
        this = _IMP_kernel.new_ScopedSetFloatAttribute(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set(self, p, key, value):
        """set(ScopedSetFloatAttribute self, Particle p, FloatKey key, double const & value)"""
        return _IMP_kernel.ScopedSetFloatAttribute_set(self, p, key, value)


    def reset(self):
        """reset(ScopedSetFloatAttribute self)"""
        return _IMP_kernel.ScopedSetFloatAttribute_reset(self)

    __swig_destroy__ = _IMP_kernel.delete_ScopedSetFloatAttribute
    __del__ = lambda self: None

    def show(self, *args):
        """
        show(ScopedSetFloatAttribute self, _ostream out)
        show(ScopedSetFloatAttribute self)
        """
        return _IMP_kernel.ScopedSetFloatAttribute_show(self, *args)


    def __str__(self):
        """__str__(ScopedSetFloatAttribute self) -> std::string"""
        return _IMP_kernel.ScopedSetFloatAttribute___str__(self)


    def __repr__(self):
        """__repr__(ScopedSetFloatAttribute self) -> std::string"""
        return _IMP_kernel.ScopedSetFloatAttribute___repr__(self)

ScopedSetFloatAttribute_swigregister = _IMP_kernel.ScopedSetFloatAttribute_swigregister
ScopedSetFloatAttribute_swigregister(ScopedSetFloatAttribute)


#used_modules=[]
#def show_used_modules():
#    for m in used_modules:
#        print "%-20s %s" % (m.get_module(), m.get_version())

# Ensure that Windows gets the PATH set to include anything in the library
# search path
if sys.platform == 'win32' and 'IMP_LD_PATH' in os.environ:
    dirs = os.environ['IMP_LD_PATH'].split(":")
    pathcomps = os.environ['PATH'].split(";")
    for d in dirs:
        if d not in pathcomps:
            os.environ['PATH'] = d + ';' + os.environ['PATH']



import sys
import os

class CommandDispatcher(object):
    """Allow command line tools to easily implement multiple commands.
       Typically, an IMP command line tool will use an instance of this class
       to provide a consistent interface to multiple distinct commands
       from a single binary, rather than providing a potentially large
       number of binaries. This is similar to the way a number of common
       command line tools outside of %IMP function (e.g. Git provides a single
       `git` tool which implements multiple commands - `git add`, `git commit`,
       `git push` and so on).

       Each command is implemented with a Python module of the same name
       that can be imported from the module (for example, if `module_name`
       is `IMP.foo`, the `bar` command is provided by the `IMP.foo.bar` Python
       module, which would usually be found as `modules/foo/pyext/src/bar.py`).
       Each such module should have a docstring and a `%main()` method
       that takes no arguments (the module should also call its `%main()` method
       if it is run directly, i.e. with something like
       `if __name__=="__main__": %main()`). The encompassing module
       (`IMP.foo` in the example) should define `_all_commands` as a Python
       list of all valid commands.

       See the `multifit` and `cnmultifit` command line tools for example
       usage.
    """

    def __init__(self, short_help, long_help, module_name):
        """Constructor.
           @param short_help A few words that describe the command line tool.
           @param long_help Longer text, used in the `help` command.
           @param module_name Name of the module (e.g. `IMP.foo`) that
                  implements the commands.
        """
        self.short_help = short_help
        self.long_help = long_help
        self.module_name = module_name
        self._all_commands = self.import_module()._all_commands
        self._progname = os.path.basename(sys.argv[0])

    def main(self):
        """Call this method to act upon the user-provided command line"""
        if len(sys.argv) <= 1:
            print(self.short_help + " Use '%s help' for help." % self._progname)
        else:
            command = sys.argv[1]
            if command in ('help', '--help', '-h'):
                if len(sys.argv) == 3:
                    self.show_command_help(sys.argv[2])
                else:
                    self.show_help()
            elif command == '--version':
                self.show_version()
            elif command in self._all_commands:
                self.do_command(command)
            else:
                self.unknown_command(command)

    def import_module(self, mod=None):
        modname = self.module_name
        if mod is not None:
            modname += "." + mod
        return __import__(modname, {}, {}, [''])

    def unknown_command(self, command):
        print("Unknown command: '%s'" % command)
        print("Use '%s help' for help." % self._progname)
        sys.exit(1)

    def _get_version(self):
        return self.import_module().get_module_version()

    def show_version(self):
        print(self._progname + ' ' + self._get_version())

    def show_help(self):
        ver = self._get_version()
        print("%s, version %s." % (self._progname, ver))
        print(self.long_help + """

This program is part of IMP, the Integrative Modeling Platform,
which is Copyright 2007-2016 IMP Inventors.
For additional information about IMP, see <https://integrativemodeling.org>.

Usage: %s <command> [options] [args]

Commands:""" % self._progname)
        commands = self._all_commands[:] + ['help']
        commands.sort()
        cmdlen = max([len(c) for c in commands])
        for c in commands:
            if c == 'help':
                doc = 'Get help on using %s.' % self._progname
            else:
                doc = self.import_module(c).__doc__ or "<no help>"
            c += ' ' * (cmdlen - len(c))
            print('    ' + c + '  ' + doc)
        print("""
Use "%s help <command>" for detailed help on any command
 or "%s --version" to see the version number.""" % (self._progname,
                                                    self._progname))

    def do_command(self, command):
        mod = self.import_module(command)
        sys.argv[0] = self._progname + ' ' + command
        del sys.argv[1]
        mod.main()

    def show_command_help(self, command):
        if command == 'help':
            self.show_help()
        elif command in self._all_commands or command == 'help':
            mod = self.import_module(command)
            sys.argv = [self._progname + ' ' + command, '--help']
            mod.main()
        else:
            self.unknown_command(command)




import optparse
import sys

class OptionParser(optparse.OptionParser):
    """IMP-specific subclass of optparse.OptionParser.
       This adds options common to all IMP applications
       (see IMP::setup_from_argv()).
    """

    _use_boost_parser = True

    def __init__(self, *args, **kwargs):
# Don't add --help or --version options (since the Boost
# option parser handles those)
        kwargs['add_help_option'] = False
        kwargs['version'] = None
# Handle old users of IMP.OptionParser that set imp_module
        if 'imp_module' in kwargs:
            del kwargs['imp_module']
        try:
            optparse.OptionParser.__init__(self, *args, **kwargs)
        except TypeError:
            if 'epilog' in kwargs:
# Older optparse doesn't support the epilog keyword
                del kwargs['epilog']
                optparse.OptionParser.__init__(self, *args, **kwargs)
            else:
                raise

# Don't complain if invalid options are encountered; pass them through
# unmodified
    def _process_long_opt(self, rargs, values):
        if self._use_boost_parser:
            try:
                optparse.OptionParser._process_long_opt(self, rargs, values)
            except optparse.BadOptionError as err:
                if not hasattr(err, 'opt_str') \
                   and err.msg.startswith('no such option:'):
                    self.largs.append(err.msg[16:])
                else:
                    self.largs.append(err.opt_str)
        else:
            optparse.OptionParser._process_long_opt(self, rargs, values)
    def _process_short_opts(self, rargs, values):
        if self._use_boost_parser:
            try:
                optparse.OptionParser._process_short_opts(self, rargs, values)
            except optparse.BadOptionError as err:
                self.largs.append(err.opt_str)
        else:
            optparse.OptionParser._process_short_opts(self, rargs, values)

    def _process_args(self, largs, rargs, values):
        if self._use_boost_parser:
# If the special argument -- is present, preserve it (by default
# optparse will remove it). Otherwise, the Boost option parser will
# not treat positional arguments after -- correctly.
            try:
                dashdash = rargs.index('--')
            except ValueError:
                dashdash = len(rargs)
            saved_args = rargs[dashdash:]
            del rargs[dashdash:]
            optparse.OptionParser._process_args(self, largs, rargs, values)
            rargs.extend(saved_args)
        else:
            optparse.OptionParser._process_args(self, largs, rargs, values)

    def parse_args(self, num_positional=None):
        """Parse the command line and return options and positional arguments.
           This functions in the same way as the method in the base class
           optparse.OptionParser, except that it also processes options common
           to all IMP applications (these are not returned in opts, but can be
           obtained in the usual way, e.g. by calling
           IMP::get_string_flag()).
           @param[in] num_positional If a positive integer, exactly that
                      many positional arguments must be specified on the
                      command line; if a negative integer, that many or
                      more must be given; if None, any number of positional
                      arguments can be given.
           @returns   opts, args
        """
# First, parse the command line with optparse
        opts, args = optparse.OptionParser.parse_args(self)
        if not self._use_boost_parser:
            return opts, args
        orig_desc = self.description
        orig_usage = self.usage
        if self.usage:
            usage = self.usage.replace('%prog ', '')
        else:
            usage = ''
        if num_positional is None:
# If num_positional was not specified, prevent the Boost parser
# from complaining about the number of positional arguments
            numpos = -1
            args.append('dummy')
        else:
            numpos = num_positional
        try:
            self.usage = self.description = None
# Pass the rest of the command line to the Boost parser; add the
# optparse-generated help to that from Boost
            args = setup_from_argv([sys.argv[0]] + args,
                           self.format_help() \
                           + "\nOptions common to all IMP applications:",
                           usage, numpos)
        finally:
            self.description = orig_desc
            self.usage = orig_usage
        if num_positional is None:
            args.pop()
        return opts, args



def get_networkx_graph(ig):
    import networkx
    g = networkx.DiGraph()
    if len(ig.get_vertices()) == 0:
        return g

    class NodeWrapper:

        def __init__(self, p):
            self.p = p

        def __str__(self):
            return self.p.get_name()

        def __call__(self, name):
            return self.p.__call__(name)

    for vi in ig.get_vertices():
        n = ig.get_vertex_name(vi)
        g.add_node(NodeWrapper(n))
    for vi in ig.get_vertices():
        n = ig.get_vertex_name(vi)
        for ni in ig.get_out_neighbors(vi):
            nn = ig.get_vertex_name(ni)
            g.add_edge(NodeWrapper(n), NodeWrapper(nn))
    return g


def show_altgraph(g):
    def clean(name):
        try:
            n0 = name.get_name()
        except:
            n0 = str(name)
        n1 = str(n0).replace('"', '')
        n2 = n1.replace("\n", '')
        return n2
    import altgraph
    from altgraph import Graph, Dot
    graph = Graph.Graph()
    for i, v in enumerate(g.get_vertices()):
        graph.add_node(i)  # , node_data=g.get_vertex_name(v)
    for i, v in enumerate(g.get_vertices()):
        for n in g.get_out_neighbors(v):
            graph.add_edge(v, n)
    dot = Dot.Dot(graph)  # , graph_type="digraph"
    for i, v in enumerate(g.get_vertices()):
        dot.node_style(i, label=clean(g.get_vertex_name(v)))
    dot.display()


def show_graphviz(g):
    tfn = create_temporary_file_name("graph", ".dot")
    tfon = create_temporary_file_name("graph", ".pdf")
    st = g.get_graphviz_string()
    open(tfn, "w").write(st)
    try:
        import subprocess
    except ImportError:
        import sys
        sys.stderr.write("Cannot run dot on Python 2.3 systems.\n")
        return
    try:
        print("running dot")
        sp = subprocess.Popen(["dot", "-Tpdf", tfn, "-o" + tfon])
        sp.wait()
    except:
        import sys
        sys.stderr.write("The dot command from the graphviz package was not found. Please make sure it is in the PATH passed to IMP.\n")
        return
    import platform
    if platform.system() == "Darwin":
        cmd = ["open"]
    else:
        cmd = ["gv", "acroread", "xpdf"]
    success = False
    for c in cmd:
        print("launching viewer " + c)
        try:
            subprocess.check_call([c, tfon])
            success = True
            break
        except:
            pass
    if not success:
        print("Could not display file. It is saved at " + tfon)
    return tfon




import functools
import contextlib

def deprecated_module(version, module, help_message):
    """Mark a Python module as deprecated.
       @note The `module` argument would normally be `__name__`.
       @see [deprecation support](@ref deprecation)."""
    handle_use_deprecated(
                "Module %s is deprecated. %s\n" % (module, help_message))

def deprecated_object(version, help_message):
    """Python decorator to mark a class as deprecated.
       @see [deprecation support](@ref deprecation)."""
    def wrapper(obj):
        orig_init = obj.__init__
# Don't try to copy __module__ since __init__ may not have it
# (e.g. if we subclassed object but didn't override __init__)
        @functools.wraps(orig_init, ('__name__', '__doc__'))
        def __init__(obj, *args, **keys):
            handle_use_deprecated("Object %s is deprecated. %s\n"
                                  % (type(obj), help_message))
            orig_init(obj, *args, **keys)
        obj.__init__ = __init__
        return obj
    return wrapper

def deprecated_method(version, help_message):
    """Python decorator to mark a method as deprecated.
       @see [deprecation support](@ref deprecation)."""
    def out_wrapper(obj):
        @functools.wraps(obj)
        def wrapper(cls, *args, **keys):
            handle_use_deprecated("Method %s in %s is deprecated. %s\n"
                               % (obj.__name__, type(cls), help_message))
            return obj(cls, *args, **keys)
        return wrapper
    return out_wrapper

def deprecated_function(version, help_message):
    """Python decorator to mark a function as deprecated.
       @see [deprecation support](@ref deprecation)."""
    def out_wrapper(obj):
        @functools.wraps(obj)
        def wrapper(*args, **keys):
            handle_use_deprecated("Function %s is deprecated. %s\n"
                                  % (obj.__name__, help_message))
            return obj(*args, **keys)
        return wrapper
    return out_wrapper

@contextlib.contextmanager
def allow_deprecated(allow=True):
    """Context manager to temporarily allow (or disallow) deprecated code.
       @see [deprecation support](@ref deprecation)."""
    old = get_deprecation_exceptions()
    set_deprecation_exceptions(not allow)
    yield
    set_deprecation_exceptions(old)

class RandomNumberGenerator(object):
    """Proxy of C++ IMP::RandomNumberGenerator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def seed(self, x):
        """seed(RandomNumberGenerator self, ::boost::int32_t x)"""
        return _IMP_kernel.RandomNumberGenerator_seed(self, x)


    def __call__(self):
        """__call__(RandomNumberGenerator self) -> int"""
        return _IMP_kernel.RandomNumberGenerator___call__(self)


    def __init__(self):
        """__init__(IMP::RandomNumberGenerator self) -> RandomNumberGenerator"""
        this = _IMP_kernel.new_RandomNumberGenerator()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _IMP_kernel.delete_RandomNumberGenerator
    __del__ = lambda self: None
RandomNumberGenerator_swigregister = _IMP_kernel.RandomNumberGenerator_swigregister
RandomNumberGenerator_swigregister(RandomNumberGenerator)


def get_random_float_uniform(*args):
    """
    get_random_float_uniform() -> float
    get_random_float_uniform(float min, float max) -> float
    """
    return _IMP_kernel.get_random_float_uniform(*args)

def get_random_double_uniform(*args):
    """
    get_random_double_uniform() -> double
    get_random_double_uniform(double min, double max) -> double
    """
    return _IMP_kernel.get_random_double_uniform(*args)

def get_random_floats_normal(n, mean=0.0, stddev=1.0):
    """
    get_random_floats_normal(unsigned int n, float mean=0.0, float stddev=1.0) -> IMP::Vector< float >
    get_random_floats_normal(unsigned int n, float mean=0.0) -> IMP::Vector< float >
    get_random_floats_normal(unsigned int n) -> IMP::Vector< float >
    """
    return _IMP_kernel.get_random_floats_normal(n, mean, stddev)

def get_random_doubles_normal(n, mean=0.0, stddev=1.0):
    """
    get_random_doubles_normal(unsigned int n, double mean=0.0, double stddev=1.0) -> IMP::Vector< double >
    get_random_doubles_normal(unsigned int n, double mean=0.0) -> IMP::Vector< double >
    get_random_doubles_normal(unsigned int n) -> IMP::Vector< double >
    """
    return _IMP_kernel.get_random_doubles_normal(n, mean, stddev)

def get_random_floats_uniform(n):
    """get_random_floats_uniform(unsigned int n) -> IMP::Vector< float >"""
    return _IMP_kernel.get_random_floats_uniform(n)

def get_random_doubles_uniform(n):
    """get_random_doubles_uniform(unsigned int n) -> IMP::Vector< double >"""
    return _IMP_kernel.get_random_doubles_uniform(n)

def get_random_seed():
    """get_random_seed() -> boost::uint64_t"""
    return _IMP_kernel.get_random_seed()

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

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

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

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


random_number_generator = cvar.random_number_generator