atom/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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_atom', [dirname(__file__)])
        except ImportError:
            import _IMP_atom
            return _IMP_atom
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_atom', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_atom = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_atom
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 Exception:
        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 Exception:
    weakref_proxy = lambda x: x


class IMP_ATOM_SwigPyIterator(object):
    """Proxy of C++ swig::IMP_ATOM_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_atom.delete_IMP_ATOM_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(IMP_ATOM_SwigPyIterator self) -> PyObject *"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(IMP_ATOM_SwigPyIterator self, size_t n=1) -> IMP_ATOM_SwigPyIterator
        incr(IMP_ATOM_SwigPyIterator self) -> IMP_ATOM_SwigPyIterator
        """
        return _IMP_atom.IMP_ATOM_SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(IMP_ATOM_SwigPyIterator self, size_t n=1) -> IMP_ATOM_SwigPyIterator
        decr(IMP_ATOM_SwigPyIterator self) -> IMP_ATOM_SwigPyIterator
        """
        return _IMP_atom.IMP_ATOM_SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(IMP_ATOM_SwigPyIterator self, IMP_ATOM_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(IMP_ATOM_SwigPyIterator self, IMP_ATOM_SwigPyIterator x) -> bool"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(IMP_ATOM_SwigPyIterator self) -> IMP_ATOM_SwigPyIterator"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_copy(self)


    def next(self):
        """next(IMP_ATOM_SwigPyIterator self) -> PyObject *"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_next(self)


    def __next__(self):
        """__next__(IMP_ATOM_SwigPyIterator self) -> PyObject *"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator___next__(self)


    def previous(self):
        """previous(IMP_ATOM_SwigPyIterator self) -> PyObject *"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(IMP_ATOM_SwigPyIterator self, ptrdiff_t n) -> IMP_ATOM_SwigPyIterator"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(IMP_ATOM_SwigPyIterator self, IMP_ATOM_SwigPyIterator x) -> bool"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(IMP_ATOM_SwigPyIterator self, IMP_ATOM_SwigPyIterator x) -> bool"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(IMP_ATOM_SwigPyIterator self, ptrdiff_t n) -> IMP_ATOM_SwigPyIterator"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(IMP_ATOM_SwigPyIterator self, ptrdiff_t n) -> IMP_ATOM_SwigPyIterator"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(IMP_ATOM_SwigPyIterator self, ptrdiff_t n) -> IMP_ATOM_SwigPyIterator"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(IMP_ATOM_SwigPyIterator self, ptrdiff_t n) -> IMP_ATOM_SwigPyIterator
        __sub__(IMP_ATOM_SwigPyIterator self, IMP_ATOM_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_atom.IMP_ATOM_SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
IMP_ATOM_SwigPyIterator_swigregister = _IMP_atom.IMP_ATOM_SwigPyIterator_swigregister
IMP_ATOM_SwigPyIterator_swigregister(IMP_ATOM_SwigPyIterator)


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


_IMP_atom.IMP_DEBUG_swigconstant(_IMP_atom)
IMP_DEBUG = _IMP_atom.IMP_DEBUG

_IMP_atom.IMP_RELEASE_swigconstant(_IMP_atom)
IMP_RELEASE = _IMP_atom.IMP_RELEASE

_IMP_atom.IMP_SILENT_swigconstant(_IMP_atom)
IMP_SILENT = _IMP_atom.IMP_SILENT

_IMP_atom.IMP_PROGRESS_swigconstant(_IMP_atom)
IMP_PROGRESS = _IMP_atom.IMP_PROGRESS

_IMP_atom.IMP_TERSE_swigconstant(_IMP_atom)
IMP_TERSE = _IMP_atom.IMP_TERSE

_IMP_atom.IMP_VERBOSE_swigconstant(_IMP_atom)
IMP_VERBOSE = _IMP_atom.IMP_VERBOSE

_IMP_atom.IMP_MEMORY_swigconstant(_IMP_atom)
IMP_MEMORY = _IMP_atom.IMP_MEMORY

_IMP_atom.IMP_NONE_swigconstant(_IMP_atom)
IMP_NONE = _IMP_atom.IMP_NONE

_IMP_atom.IMP_USAGE_swigconstant(_IMP_atom)
IMP_USAGE = _IMP_atom.IMP_USAGE

_IMP_atom.IMP_INTERNAL_swigconstant(_IMP_atom)
IMP_INTERNAL = _IMP_atom.IMP_INTERNAL

_IMP_atom.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_atom)
IMP_KERNEL_HAS_LOG4CXX = _IMP_atom.IMP_KERNEL_HAS_LOG4CXX

_IMP_atom.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_atom)
IMP_COMPILER_HAS_AUTO = _IMP_atom.IMP_COMPILER_HAS_AUTO

_IMP_atom.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_atom)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_atom.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_atom.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_atom)
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_atom.IMP_COMPILER_HAS_UNIQUE_PTR

_IMP_atom.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_atom.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_atom.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_atom)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_atom.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_atom.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_atom)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_atom.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_atom.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_atom)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_atom.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_atom.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPKERNEL_SHOW_WARNINGS = _IMP_atom.IMPKERNEL_SHOW_WARNINGS

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

class _ostream(object):
    """Proxy of C++ std::ostream class."""

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

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

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

_ostream_swigregister = _IMP_atom._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_atom.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_atom)
IMP_COMPILER_HAS_OVERRIDE = _IMP_atom.IMP_COMPILER_HAS_OVERRIDE

_IMP_atom.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_atom)
IMP_COMPILER_HAS_FINAL = _IMP_atom.IMP_COMPILER_HAS_FINAL

_IMP_atom.IMP_HAS_NOEXCEPT_swigconstant(_IMP_atom)
IMP_HAS_NOEXCEPT = _IMP_atom.IMP_HAS_NOEXCEPT
import IMP

_IMP_atom.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_atom)
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_CGAL_HAS_BOOST_FILESYSTEM

_IMP_atom.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_atom)
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

_IMP_atom.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_atom.IMP_CGAL_HAS_BOOST_RANDOM

_IMP_atom.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_atom)
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_atom.IMP_CGAL_HAS_BOOST_SYSTEM

_IMP_atom.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPCGAL_SHOW_WARNINGS = _IMP_atom.IMPCGAL_SHOW_WARNINGS
import IMP.cgal

_IMP_atom.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_atom)
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_atom.IMP_ALGEBRA_HAS_IMP_CGAL

_IMP_atom.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_atom)
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

_IMP_atom.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_atom)
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

_IMP_atom.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_RANDOM

_IMP_atom.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_atom)
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_SYSTEM

_IMP_atom.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_atom)
IMP_ALGEBRA_HAS_CGAL = _IMP_atom.IMP_ALGEBRA_HAS_CGAL

_IMP_atom.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_atom)
IMP_ALGEBRA_HAS_ANN = _IMP_atom.IMP_ALGEBRA_HAS_ANN

_IMP_atom.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPALGEBRA_SHOW_WARNINGS = _IMP_atom.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra

_IMP_atom.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_atom)
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_atom.IMP_DISPLAY_HAS_IMP_CGAL

_IMP_atom.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_atom)
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

_IMP_atom.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_atom)
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

_IMP_atom.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_atom.IMP_DISPLAY_HAS_BOOST_RANDOM

_IMP_atom.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_atom)
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_atom.IMP_DISPLAY_HAS_BOOST_SYSTEM

_IMP_atom.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_atom)
IMP_DISPLAY_HAS_CGAL = _IMP_atom.IMP_DISPLAY_HAS_CGAL

_IMP_atom.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPDISPLAY_SHOW_WARNINGS = _IMP_atom.IMPDISPLAY_SHOW_WARNINGS
import IMP.display

_IMP_atom.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_atom)
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

_IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_atom)
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

_IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_atom)
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

_IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

_IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_atom)
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

_IMP_atom.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_atom)
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_CGAL

_IMP_atom.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_atom)
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_HDF5

_IMP_atom.IMPSCOREFUNCTOR_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_atom.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor

_IMP_atom.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_atom)
IMP_CORE_HAS_IMP_CGAL = _IMP_atom.IMP_CORE_HAS_IMP_CGAL

_IMP_atom.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_atom)
IMP_CORE_HAS_IMP_KERNEL = _IMP_atom.IMP_CORE_HAS_IMP_KERNEL

_IMP_atom.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_atom)
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_CORE_HAS_BOOST_FILESYSTEM

_IMP_atom.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_atom)
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

_IMP_atom.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_CORE_HAS_BOOST_RANDOM = _IMP_atom.IMP_CORE_HAS_BOOST_RANDOM

_IMP_atom.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_atom)
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_atom.IMP_CORE_HAS_BOOST_SYSTEM

_IMP_atom.IMP_CORE_HAS_CGAL_swigconstant(_IMP_atom)
IMP_CORE_HAS_CGAL = _IMP_atom.IMP_CORE_HAS_CGAL

_IMP_atom.IMP_CORE_HAS_HDF5_swigconstant(_IMP_atom)
IMP_CORE_HAS_HDF5 = _IMP_atom.IMP_CORE_HAS_HDF5

_IMP_atom.IMPCORE_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPCORE_SHOW_WARNINGS = _IMP_atom.IMPCORE_SHOW_WARNINGS
import IMP.core

_IMP_atom.IMP_CONTAINER_HAS_IMP_ALGEBRA_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_atom.IMP_CONTAINER_HAS_IMP_ALGEBRA

_IMP_atom.IMP_CONTAINER_HAS_IMP_CGAL_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_atom.IMP_CONTAINER_HAS_IMP_CGAL

_IMP_atom.IMP_CONTAINER_HAS_IMP_DISPLAY_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_atom.IMP_CONTAINER_HAS_IMP_DISPLAY

_IMP_atom.IMP_CONTAINER_HAS_IMP_KERNEL_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_atom.IMP_CONTAINER_HAS_IMP_KERNEL

_IMP_atom.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_atom.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

_IMP_atom.IMP_CONTAINER_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

_IMP_atom.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

_IMP_atom.IMP_CONTAINER_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_atom.IMP_CONTAINER_HAS_BOOST_RANDOM

_IMP_atom.IMP_CONTAINER_HAS_BOOST_SYSTEM_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_atom.IMP_CONTAINER_HAS_BOOST_SYSTEM

_IMP_atom.IMP_CONTAINER_HAS_CGAL_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_CGAL = _IMP_atom.IMP_CONTAINER_HAS_CGAL

_IMP_atom.IMP_CONTAINER_HAS_HDF5_swigconstant(_IMP_atom)
IMP_CONTAINER_HAS_HDF5 = _IMP_atom.IMP_CONTAINER_HAS_HDF5

_IMP_atom.IMPCONTAINER_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPCONTAINER_SHOW_WARNINGS = _IMP_atom.IMPCONTAINER_SHOW_WARNINGS
import IMP.container

_IMP_atom.IMP_ATOM_HAS_IMP_CGAL_swigconstant(_IMP_atom)
IMP_ATOM_HAS_IMP_CGAL = _IMP_atom.IMP_ATOM_HAS_IMP_CGAL

_IMP_atom.IMP_ATOM_HAS_IMP_KERNEL_swigconstant(_IMP_atom)
IMP_ATOM_HAS_IMP_KERNEL = _IMP_atom.IMP_ATOM_HAS_IMP_KERNEL

_IMP_atom.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_atom)
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_atom.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

_IMP_atom.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_atom)
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

_IMP_atom.IMP_ATOM_HAS_BOOST_RANDOM_swigconstant(_IMP_atom)
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_atom.IMP_ATOM_HAS_BOOST_RANDOM

_IMP_atom.IMP_ATOM_HAS_BOOST_REGEX_swigconstant(_IMP_atom)
IMP_ATOM_HAS_BOOST_REGEX = _IMP_atom.IMP_ATOM_HAS_BOOST_REGEX

_IMP_atom.IMP_ATOM_HAS_BOOST_SYSTEM_swigconstant(_IMP_atom)
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_atom.IMP_ATOM_HAS_BOOST_SYSTEM

_IMP_atom.IMP_ATOM_HAS_CGAL_swigconstant(_IMP_atom)
IMP_ATOM_HAS_CGAL = _IMP_atom.IMP_ATOM_HAS_CGAL

_IMP_atom.IMP_ATOM_HAS_HDF5_swigconstant(_IMP_atom)
IMP_ATOM_HAS_HDF5 = _IMP_atom.IMP_ATOM_HAS_HDF5

_IMP_atom.IMPATOM_SHOW_WARNINGS_swigconstant(_IMP_atom)
IMPATOM_SHOW_WARNINGS = _IMP_atom.IMPATOM_SHOW_WARNINGS

_IMP_atom.IMP_ATOM_TYPE_INDEX_swigconstant(_IMP_atom)
IMP_ATOM_TYPE_INDEX = _IMP_atom.IMP_ATOM_TYPE_INDEX

_IMP_atom.IMP_RESIDUE_TYPE_INDEX_swigconstant(_IMP_atom)
IMP_RESIDUE_TYPE_INDEX = _IMP_atom.IMP_RESIDUE_TYPE_INDEX

_IMP_atom.IMP_HIERARCHY_TYPE_INDEX_swigconstant(_IMP_atom)
IMP_HIERARCHY_TYPE_INDEX = _IMP_atom.IMP_HIERARCHY_TYPE_INDEX
class HierarchyTree(IMP.Object):
    """Proxy of C++ IMP::internal::BoostDigraph<(IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex)> 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::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex)> self) -> HierarchyTree"""
        this = _IMP_atom.new_HierarchyTree()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_graph(self):
        """get_graph(HierarchyTree self) -> IMP::atom::HierarchyTree const &"""
        return _IMP_atom.HierarchyTree_get_graph(self)


    def get_vertices(self):
        """get_vertices(HierarchyTree self) -> IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptors"""
        return _IMP_atom.HierarchyTree_get_vertices(self)


    def get_vertex_name(self, i):
        """get_vertex_name(HierarchyTree self, IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptor i) -> Hierarchy"""
        return _IMP_atom.HierarchyTree_get_vertex_name(self, i)


    def get_in_neighbors(self, v):
        """get_in_neighbors(HierarchyTree self, IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptors"""
        return _IMP_atom.HierarchyTree_get_in_neighbors(self, v)


    def get_out_neighbors(self, v):
        """get_out_neighbors(HierarchyTree self, IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptor v) -> IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptors"""
        return _IMP_atom.HierarchyTree_get_out_neighbors(self, v)


    def show_graphviz(self, *args):
        """
        show_graphviz(HierarchyTree self, _ostream out)
        show_graphviz(HierarchyTree self)
        """
        return _IMP_atom.HierarchyTree_show_graphviz(self, *args)


    def get_graphviz_string(self):
        """get_graphviz_string(HierarchyTree self) -> std::string"""
        return _IMP_atom.HierarchyTree_get_graphviz_string(self)


    def add_edge(self, v0, v1):
        """add_edge(HierarchyTree self, IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptor v0, IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptor v1)"""
        return _IMP_atom.HierarchyTree_add_edge(self, v0, v1)


    def add_vertex(self, l):
        """add_vertex(HierarchyTree self, Hierarchy l) -> IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptor"""
        return _IMP_atom.HierarchyTree_add_vertex(self, l)


    def remove_vertex(self, l):
        """remove_vertex(HierarchyTree self, IMP::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy,IMP::atom::ShowHierarchyTreeVertex >::VertexDescriptor l)"""
        return _IMP_atom.HierarchyTree_remove_vertex(self, l)

    __swig_destroy__ = _IMP_atom.delete_HierarchyTree
    __del__ = lambda self: None
HierarchyTree_swigregister = _IMP_atom.HierarchyTree_swigregister
HierarchyTree_swigregister(HierarchyTree)


_value_types.append("HierarchyTree")


_object_types.append("PDBSelector")


def _object_cast_to_PDBSelector(o):
    """_object_cast_to_PDBSelector(Object o) -> PDBSelector"""
    return _IMP_atom._object_cast_to_PDBSelector(o)

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


_value_types.append("Angle")


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


_value_types.append("Atom")


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


_value_types.append("Bond")


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


_value_types.append("Bonded")


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


_value_types.append("CHARMMAtom")


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


_value_types.append("Chain")


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


_value_types.append("CenterOfMass")


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


_value_types.append("Charged")


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


_value_types.append("Diffusion")


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


_value_types.append("RigidBodyDiffusion")


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


_value_types.append("TAMDParticle")


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


_value_types.append("TAMDCentroid")


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


_value_types.append("Dihedral")


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


_value_types.append("Domain")


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


_value_types.append("Fragment")


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


_value_types.append("Hierarchy")


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


_value_types.append("LennardJones")


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


_value_types.append("Mass")


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


_value_types.append("LinearVelocity")


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


_value_types.append("AngularVelocity")


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


_value_types.append("Molecule")


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


_value_types.append("Residue")


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


_value_types.append("Representation")


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


_value_types.append("State")


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


_value_types.append("Copy")


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


_value_types.append("SecondaryStructureResidue")


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


_value_types.append("StructureSource")


_object_types.append("Simulator")


def _object_cast_to_Simulator(o):
    """_object_cast_to_Simulator(Object o) -> Simulator"""
    return _IMP_atom._object_cast_to_Simulator(o)

_object_types.append("ATOMPDBSelector")


def _object_cast_to_ATOMPDBSelector(o):
    """_object_cast_to_ATOMPDBSelector(Object o) -> ATOMPDBSelector"""
    return _IMP_atom._object_cast_to_ATOMPDBSelector(o)

_object_types.append("AllMol2Selector")


def _object_cast_to_AllMol2Selector(o):
    """_object_cast_to_AllMol2Selector(Object o) -> AllMol2Selector"""
    return _IMP_atom._object_cast_to_AllMol2Selector(o)

_object_types.append("AllPDBSelector")


def _object_cast_to_AllPDBSelector(o):
    """_object_cast_to_AllPDBSelector(Object o) -> AllPDBSelector"""
    return _IMP_atom._object_cast_to_AllPDBSelector(o)

_object_types.append("AndPDBSelector")


def _object_cast_to_AndPDBSelector(o):
    """_object_cast_to_AndPDBSelector(Object o) -> AndPDBSelector"""
    return _IMP_atom._object_cast_to_AndPDBSelector(o)

_object_types.append("XorPDBSelector")


def _object_cast_to_XorPDBSelector(o):
    """_object_cast_to_XorPDBSelector(Object o) -> XorPDBSelector"""
    return _IMP_atom._object_cast_to_XorPDBSelector(o)

_object_types.append("ResidueTypePDBSelector")


def _object_cast_to_ResidueTypePDBSelector(o):
    """_object_cast_to_ResidueTypePDBSelector(Object o) -> ResidueTypePDBSelector"""
    return _IMP_atom._object_cast_to_ResidueTypePDBSelector(o)

_object_types.append("AtomTypePDBSelector")


def _object_cast_to_AtomTypePDBSelector(o):
    """_object_cast_to_AtomTypePDBSelector(Object o) -> AtomTypePDBSelector"""
    return _IMP_atom._object_cast_to_AtomTypePDBSelector(o)

_object_types.append("AngleSingletonScore")


def _object_cast_to_AngleSingletonScore(o):
    """_object_cast_to_AngleSingletonScore(Object o) -> AngleSingletonScore"""
    return _IMP_atom._object_cast_to_AngleSingletonScore(o)

_object_types.append("BondEndpointsRefiner")


def _object_cast_to_BondEndpointsRefiner(o):
    """_object_cast_to_BondEndpointsRefiner(Object o) -> BondEndpointsRefiner"""
    return _IMP_atom._object_cast_to_BondEndpointsRefiner(o)

_object_types.append("BondPairContainer")


def _object_cast_to_BondPairContainer(o):
    """_object_cast_to_BondPairContainer(Object o) -> BondPairContainer"""
    return _IMP_atom._object_cast_to_BondPairContainer(o)

_object_types.append("BondSingletonScore")


def _object_cast_to_BondSingletonScore(o):
    """_object_cast_to_BondSingletonScore(Object o) -> BondSingletonScore"""
    return _IMP_atom._object_cast_to_BondSingletonScore(o)

_object_types.append("BondedPairFilter")


def _object_cast_to_BondedPairFilter(o):
    """_object_cast_to_BondedPairFilter(Object o) -> BondedPairFilter"""
    return _IMP_atom._object_cast_to_BondedPairFilter(o)

_object_types.append("BrownianDynamics")


def _object_cast_to_BrownianDynamics(o):
    """_object_cast_to_BrownianDynamics(Object o) -> BrownianDynamics"""
    return _IMP_atom._object_cast_to_BrownianDynamics(o)

_object_types.append("BrownianDynamicsTAMD")


def _object_cast_to_BrownianDynamicsTAMD(o):
    """_object_cast_to_BrownianDynamicsTAMD(Object o) -> BrownianDynamicsTAMD"""
    return _IMP_atom._object_cast_to_BrownianDynamicsTAMD(o)

_object_types.append("CAlphaPDBSelector")


def _object_cast_to_CAlphaPDBSelector(o):
    """_object_cast_to_CAlphaPDBSelector(Object o) -> CAlphaPDBSelector"""
    return _IMP_atom._object_cast_to_CAlphaPDBSelector(o)

_object_types.append("CBetaPDBSelector")


def _object_cast_to_CBetaPDBSelector(o):
    """_object_cast_to_CBetaPDBSelector(Object o) -> CBetaPDBSelector"""
    return _IMP_atom._object_cast_to_CBetaPDBSelector(o)

_object_types.append("BackbonePDBSelector")


def _object_cast_to_BackbonePDBSelector(o):
    """_object_cast_to_BackbonePDBSelector(Object o) -> BackbonePDBSelector"""
    return _IMP_atom._object_cast_to_BackbonePDBSelector(o)

_object_types.append("CHARMMParameters")


def _object_cast_to_CHARMMParameters(o):
    """_object_cast_to_CHARMMParameters(Object o) -> CHARMMParameters"""
    return _IMP_atom._object_cast_to_CHARMMParameters(o)

_object_types.append("CHARMMResidueTopology")


def _object_cast_to_CHARMMResidueTopology(o):
    """_object_cast_to_CHARMMResidueTopology(Object o) -> CHARMMResidueTopology"""
    return _IMP_atom._object_cast_to_CHARMMResidueTopology(o)

_object_types.append("CHARMMSegmentTopology")


def _object_cast_to_CHARMMSegmentTopology(o):
    """_object_cast_to_CHARMMSegmentTopology(Object o) -> CHARMMSegmentTopology"""
    return _IMP_atom._object_cast_to_CHARMMSegmentTopology(o)

_object_types.append("CHARMMStereochemistryRestraint")


def _object_cast_to_CHARMMStereochemistryRestraint(o):
    """_object_cast_to_CHARMMStereochemistryRestraint(Object o) -> CHARMMStereochemistryRestraint"""
    return _IMP_atom._object_cast_to_CHARMMStereochemistryRestraint(o)

_object_types.append("CHARMMTopology")


def _object_cast_to_CHARMMTopology(o):
    """_object_cast_to_CHARMMTopology(Object o) -> CHARMMTopology"""
    return _IMP_atom._object_cast_to_CHARMMTopology(o)

_object_types.append("CPDBSelector")


def _object_cast_to_CPDBSelector(o):
    """_object_cast_to_CPDBSelector(Object o) -> CPDBSelector"""
    return _IMP_atom._object_cast_to_CPDBSelector(o)

_object_types.append("ChainPDBSelector")


def _object_cast_to_ChainPDBSelector(o):
    """_object_cast_to_ChainPDBSelector(Object o) -> ChainPDBSelector"""
    return _IMP_atom._object_cast_to_ChainPDBSelector(o)

_object_types.append("CoulombPairScore")


def _object_cast_to_CoulombPairScore(o):
    """_object_cast_to_CoulombPairScore(Object o) -> CoulombPairScore"""
    return _IMP_atom._object_cast_to_CoulombPairScore(o)

_object_types.append("CoverBond")


def _object_cast_to_CoverBond(o):
    """_object_cast_to_CoverBond(Object o) -> CoverBond"""
    return _IMP_atom._object_cast_to_CoverBond(o)

_object_types.append("DihedralSingletonScore")


def _object_cast_to_DihedralSingletonScore(o):
    """_object_cast_to_DihedralSingletonScore(Object o) -> DihedralSingletonScore"""
    return _IMP_atom._object_cast_to_DihedralSingletonScore(o)

_object_types.append("DopePairScore")


def _object_cast_to_DopePairScore(o):
    """_object_cast_to_DopePairScore(Object o) -> DopePairScore"""
    return _IMP_atom._object_cast_to_DopePairScore(o)

_object_types.append("OrientedSoapPairScore")


def _object_cast_to_OrientedSoapPairScore(o):
    """_object_cast_to_OrientedSoapPairScore(Object o) -> OrientedSoapPairScore"""
    return _IMP_atom._object_cast_to_OrientedSoapPairScore(o)

_object_types.append("EzRestraint")


def _object_cast_to_EzRestraint(o):
    """_object_cast_to_EzRestraint(Object o) -> EzRestraint"""
    return _IMP_atom._object_cast_to_EzRestraint(o)

_object_types.append("ForceFieldParameters")


def _object_cast_to_ForceFieldParameters(o):
    """_object_cast_to_ForceFieldParameters(Object o) -> ForceFieldParameters"""
    return _IMP_atom._object_cast_to_ForceFieldParameters(o)

_object_types.append("ForceSwitch")


def _object_cast_to_ForceSwitch(o):
    """_object_cast_to_ForceSwitch(Object o) -> ForceSwitch"""
    return _IMP_atom._object_cast_to_ForceSwitch(o)

_object_types.append("HydrogenPDBSelector")


def _object_cast_to_HydrogenPDBSelector(o):
    """_object_cast_to_HydrogenPDBSelector(Object o) -> HydrogenPDBSelector"""
    return _IMP_atom._object_cast_to_HydrogenPDBSelector(o)

_object_types.append("ImproperSingletonScore")


def _object_cast_to_ImproperSingletonScore(o):
    """_object_cast_to_ImproperSingletonScore(Object o) -> ImproperSingletonScore"""
    return _IMP_atom._object_cast_to_ImproperSingletonScore(o)

_object_types.append("LennardJonesPairScore")


def _object_cast_to_LennardJonesPairScore(o):
    """_object_cast_to_LennardJonesPairScore(Object o) -> LennardJonesPairScore"""
    return _IMP_atom._object_cast_to_LennardJonesPairScore(o)

_object_types.append("Mol2Selector")


def _object_cast_to_Mol2Selector(o):
    """_object_cast_to_Mol2Selector(Object o) -> Mol2Selector"""
    return _IMP_atom._object_cast_to_Mol2Selector(o)

_object_types.append("MolecularDynamics")


def _object_cast_to_MolecularDynamics(o):
    """_object_cast_to_MolecularDynamics(Object o) -> MolecularDynamics"""
    return _IMP_atom._object_cast_to_MolecularDynamics(o)

_object_types.append("NPDBSelector")


def _object_cast_to_NPDBSelector(o):
    """_object_cast_to_NPDBSelector(Object o) -> NPDBSelector"""
    return _IMP_atom._object_cast_to_NPDBSelector(o)

_object_types.append("NonAlternativePDBSelector")


def _object_cast_to_NonAlternativePDBSelector(o):
    """_object_cast_to_NonAlternativePDBSelector(Object o) -> NonAlternativePDBSelector"""
    return _IMP_atom._object_cast_to_NonAlternativePDBSelector(o)

_object_types.append("NonHydrogenMol2Selector")


def _object_cast_to_NonHydrogenMol2Selector(o):
    """_object_cast_to_NonHydrogenMol2Selector(Object o) -> NonHydrogenMol2Selector"""
    return _IMP_atom._object_cast_to_NonHydrogenMol2Selector(o)

_object_types.append("NonWaterNonHydrogenPDBSelector")


def _object_cast_to_NonWaterNonHydrogenPDBSelector(o):
    """_object_cast_to_NonWaterNonHydrogenPDBSelector(Object o) -> NonWaterNonHydrogenPDBSelector"""
    return _IMP_atom._object_cast_to_NonWaterNonHydrogenPDBSelector(o)

_object_types.append("NonWaterPDBSelector")


def _object_cast_to_NonWaterPDBSelector(o):
    """_object_cast_to_NonWaterPDBSelector(Object o) -> NonWaterPDBSelector"""
    return _IMP_atom._object_cast_to_NonWaterPDBSelector(o)

_object_types.append("NotPDBSelector")


def _object_cast_to_NotPDBSelector(o):
    """_object_cast_to_NotPDBSelector(Object o) -> NotPDBSelector"""
    return _IMP_atom._object_cast_to_NotPDBSelector(o)

_object_types.append("OrPDBSelector")


def _object_cast_to_OrPDBSelector(o):
    """_object_cast_to_OrPDBSelector(Object o) -> OrPDBSelector"""
    return _IMP_atom._object_cast_to_OrPDBSelector(o)

_object_types.append("PPDBSelector")


def _object_cast_to_PPDBSelector(o):
    """_object_cast_to_PPDBSelector(Object o) -> PPDBSelector"""
    return _IMP_atom._object_cast_to_PPDBSelector(o)

_object_types.append("ProteinLigandAtomPairScore")


def _object_cast_to_ProteinLigandAtomPairScore(o):
    """_object_cast_to_ProteinLigandAtomPairScore(Object o) -> ProteinLigandAtomPairScore"""
    return _IMP_atom._object_cast_to_ProteinLigandAtomPairScore(o)

_object_types.append("ProteinLigandRestraint")


def _object_cast_to_ProteinLigandRestraint(o):
    """_object_cast_to_ProteinLigandRestraint(Object o) -> ProteinLigandRestraint"""
    return _IMP_atom._object_cast_to_ProteinLigandRestraint(o)

_object_types.append("SameResiduePairFilter")


def _object_cast_to_SameResiduePairFilter(o):
    """_object_cast_to_SameResiduePairFilter(Object o) -> SameResiduePairFilter"""
    return _IMP_atom._object_cast_to_SameResiduePairFilter(o)

_object_types.append("SoapPairFilter")


def _object_cast_to_SoapPairFilter(o):
    """_object_cast_to_SoapPairFilter(Object o) -> SoapPairFilter"""
    return _IMP_atom._object_cast_to_SoapPairFilter(o)

_object_types.append("SmoothingFunction")


def _object_cast_to_SmoothingFunction(o):
    """_object_cast_to_SmoothingFunction(Object o) -> SmoothingFunction"""
    return _IMP_atom._object_cast_to_SmoothingFunction(o)

_object_types.append("StereochemistryPairFilter")


def _object_cast_to_StereochemistryPairFilter(o):
    """_object_cast_to_StereochemistryPairFilter(Object o) -> StereochemistryPairFilter"""
    return _IMP_atom._object_cast_to_StereochemistryPairFilter(o)

_object_types.append("VelocityScalingOptimizerState")


def _object_cast_to_VelocityScalingOptimizerState(o):
    """_object_cast_to_VelocityScalingOptimizerState(Object o) -> VelocityScalingOptimizerState"""
    return _IMP_atom._object_cast_to_VelocityScalingOptimizerState(o)

_object_types.append("WaterPDBSelector")


def _object_cast_to_WaterPDBSelector(o):
    """_object_cast_to_WaterPDBSelector(Object o) -> WaterPDBSelector"""
    return _IMP_atom._object_cast_to_WaterPDBSelector(o)

_object_types.append("WritePDBOptimizerState")


def _object_cast_to_WritePDBOptimizerState(o):
    """_object_cast_to_WritePDBOptimizerState(Object o) -> WritePDBOptimizerState"""
    return _IMP_atom._object_cast_to_WritePDBOptimizerState(o)

AtomTypes=list
_plural_types.append("AtomTypes")
_value_types.append("AtomType")


CHARMMAtomTopologies=list
_plural_types.append("CHARMMAtomTopologies")
_value_types.append("CHARMMAtomTopology")


CHARMMBondEndpoints=list
_plural_types.append("CHARMMBondEndpoints")
_value_types.append("CHARMMBondEndpoint")


CHARMMBondParametersList=list
_plural_types.append("CHARMMBondParametersList")
_value_types.append("CHARMMBondParameters")


CHARMMDihedralParametersList=list
_plural_types.append("CHARMMDihedralParametersList")
_value_types.append("CHARMMDihedralParameters")


_object_types.append("CHARMMIdealResidueTopology")


def _object_cast_to_CHARMMIdealResidueTopology(o):
    """_object_cast_to_CHARMMIdealResidueTopology(Object o) -> CHARMMIdealResidueTopology"""
    return _IMP_atom._object_cast_to_CHARMMIdealResidueTopology(o)

CHARMMInternalCoordinates=list
_plural_types.append("CHARMMInternalCoordinates")
_value_types.append("CHARMMInternalCoordinate")


_object_types.append("CHARMMPatch")


def _object_cast_to_CHARMMPatch(o):
    """_object_cast_to_CHARMMPatch(Object o) -> CHARMMPatch"""
    return _IMP_atom._object_cast_to_CHARMMPatch(o)

_object_types.append("CHARMMResidueTopologyBase")


def _object_cast_to_CHARMMResidueTopologyBase(o):
    """_object_cast_to_CHARMMResidueTopologyBase(Object o) -> CHARMMResidueTopologyBase"""
    return _IMP_atom._object_cast_to_CHARMMResidueTopologyBase(o)

ResidueTypes=list
_plural_types.append("ResidueTypes")
_value_types.append("ResidueType")


Selections=list
_plural_types.append("Selections")
_value_types.append("Selection")


_object_types.append("RemoveRigidMotionOptimizerState")


def _object_cast_to_RemoveRigidMotionOptimizerState(o):
    """_object_cast_to_RemoveRigidMotionOptimizerState(Object o) -> RemoveRigidMotionOptimizerState"""
    return _IMP_atom._object_cast_to_RemoveRigidMotionOptimizerState(o)

_object_types.append("BerendsenThermostatOptimizerState")


def _object_cast_to_BerendsenThermostatOptimizerState(o):
    """_object_cast_to_BerendsenThermostatOptimizerState(Object o) -> BerendsenThermostatOptimizerState"""
    return _IMP_atom._object_cast_to_BerendsenThermostatOptimizerState(o)

_object_types.append("LangevinThermostatOptimizerState")


def _object_cast_to_LangevinThermostatOptimizerState(o):
    """_object_cast_to_LangevinThermostatOptimizerState(Object o) -> LangevinThermostatOptimizerState"""
    return _IMP_atom._object_cast_to_LangevinThermostatOptimizerState(o)

_object_types.append("SelectionGeometry")


def _object_cast_to_SelectionGeometry(o):
    """_object_cast_to_SelectionGeometry(Object o) -> SelectionGeometry"""
    return _IMP_atom._object_cast_to_SelectionGeometry(o)

_object_types.append("HierarchyGeometry")


def _object_cast_to_HierarchyGeometry(o):
    """_object_cast_to_HierarchyGeometry(Object o) -> HierarchyGeometry"""
    return _IMP_atom._object_cast_to_HierarchyGeometry(o)

_object_types.append("HierarchiesGeometry")


def _object_cast_to_HierarchiesGeometry(o):
    """_object_cast_to_HierarchiesGeometry(Object o) -> HierarchiesGeometry"""
    return _IMP_atom._object_cast_to_HierarchiesGeometry(o)

_object_types.append("BondGeometry")


def _object_cast_to_BondGeometry(o):
    """_object_cast_to_BondGeometry(Object o) -> BondGeometry"""
    return _IMP_atom._object_cast_to_BondGeometry(o)

_object_types.append("BondsGeometry")


def _object_cast_to_BondsGeometry(o):
    """_object_cast_to_BondsGeometry(Object o) -> BondsGeometry"""
    return _IMP_atom._object_cast_to_BondsGeometry(o)

_object_types.append("CAAngleRestraint")


def _object_cast_to_CAAngleRestraint(o):
    """_object_cast_to_CAAngleRestraint(Object o) -> CAAngleRestraint"""
    return _IMP_atom._object_cast_to_CAAngleRestraint(o)

_object_types.append("CADihedralRestraint")


def _object_cast_to_CADihedralRestraint(o):
    """_object_cast_to_CADihedralRestraint(Object o) -> CADihedralRestraint"""
    return _IMP_atom._object_cast_to_CADihedralRestraint(o)

CHARMMDihedrals=list
_plural_types.append("CHARMMDihedrals")
_value_types.append("CHARMMDihedral")


CHARMMBonds=list
_plural_types.append("CHARMMBonds")
_value_types.append("CHARMMBond")


CHARMMAngles=list
_plural_types.append("CHARMMAngles")
_value_types.append("CHARMMAngle")

class Bond(IMP.Decorator):
    """Proxy of C++ IMP::atom::Bond 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::atom::Bond self) -> Bond
        __init__(IMP::atom::Bond self, Model m, ParticleIndex id) -> Bond
        __init__(IMP::atom::Bond self, _ParticleAdaptor d) -> Bond
        """
        this = _IMP_atom.new_Bond(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Bond self, _ostream out)
        show(Bond self)
        """
        return _IMP_atom.Bond_show(self, *args)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_atom.Bond_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)
    UNKNOWN = _IMP_atom.Bond_UNKNOWN
    NONBIOLOGICAL = _IMP_atom.Bond_NONBIOLOGICAL
    SINGLE = _IMP_atom.Bond_SINGLE
    DOUBLE = _IMP_atom.Bond_DOUBLE
    TRIPLE = _IMP_atom.Bond_TRIPLE
    HYDROGEN = _IMP_atom.Bond_HYDROGEN
    SALT = _IMP_atom.Bond_SALT
    PEPTIDE = _IMP_atom.Bond_PEPTIDE
    AMIDE = _IMP_atom.Bond_AMIDE
    AROMATIC = _IMP_atom.Bond_AROMATIC

    def get_bonded(self, i):
        """get_bonded(Bond self, unsigned int i) -> Bonded"""
        return _IMP_atom.Bond_get_bonded(self, i)


    def get_type(self):
        """get_type(Bond self) -> IMP::Int"""
        return _IMP_atom.Bond_get_type(self)


    def set_type(self, t):
        """set_type(Bond self, IMP::Int t)"""
        return _IMP_atom.Bond_set_type(self, t)


    def get_order(self):
        """get_order(Bond self) -> IMP::Int"""
        return _IMP_atom.Bond_get_order(self)


    def set_order(self, t):
        """set_order(Bond self, IMP::Int t)"""
        return _IMP_atom.Bond_set_order(self, t)


    def get_length(self):
        """get_length(Bond self) -> IMP::Float"""
        return _IMP_atom.Bond_get_length(self)


    def set_length(self, t):
        """set_length(Bond self, IMP::Float t)"""
        return _IMP_atom.Bond_set_length(self, t)


    def get_stiffness(self):
        """get_stiffness(Bond self) -> IMP::Float"""
        return _IMP_atom.Bond_get_stiffness(self)


    def set_stiffness(self, t):
        """set_stiffness(Bond self, IMP::Float t)"""
        return _IMP_atom.Bond_set_stiffness(self, t)


    def get_length_key():
        """get_length_key() -> FloatKey"""
        return _IMP_atom.Bond_get_length_key()

    get_length_key = staticmethod(get_length_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Bond self, FloatKey a0)
        remove_attribute(Bond self, IntKey a0)
        remove_attribute(Bond self, StringKey a0)
        remove_attribute(Bond self, ParticleIndexKey a0)
        remove_attribute(Bond self, ObjectKey a0)
        """
        return _IMP_atom.Bond_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Bond self, FloatKey a0) -> bool
        has_attribute(Bond self, IntKey a0) -> bool
        has_attribute(Bond self, StringKey a0) -> bool
        has_attribute(Bond self, ParticleIndexKey a0) -> bool
        has_attribute(Bond self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Bond_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Bond self, FloatKey a0) -> double"""
        return _IMP_atom.Bond_get_derivative(self, a0)


    def get_name(self):
        """get_name(Bond self) -> std::string"""
        return _IMP_atom.Bond_get_name(self)


    def clear_caches(self):
        """clear_caches(Bond self)"""
        return _IMP_atom.Bond_clear_caches(self)


    def set_name(self, a0):
        """set_name(Bond self, std::string a0)"""
        return _IMP_atom.Bond_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Bond self, IMP::CheckLevel a0)"""
        return _IMP_atom.Bond_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Bond self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Bond_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Bond self, FloatKey a0, bool a1)"""
        return _IMP_atom.Bond_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Bond self, FloatKey a0) -> bool"""
        return _IMP_atom.Bond_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Bond self) -> IMP::CheckLevel"""
        return _IMP_atom.Bond_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Bond self, Bond o) -> bool
        __eq__(Bond self, Particle d) -> bool
        """
        return _IMP_atom.Bond___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Bond self, Bond o) -> bool
        __ne__(Bond self, Particle d) -> bool
        """
        return _IMP_atom.Bond___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Bond self, Bond o) -> bool
        __le__(Bond self, Particle d) -> bool
        """
        return _IMP_atom.Bond___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Bond self, Bond o) -> bool
        __lt__(Bond self, Particle d) -> bool
        """
        return _IMP_atom.Bond___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Bond self, Bond o) -> bool
        __ge__(Bond self, Particle d) -> bool
        """
        return _IMP_atom.Bond___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Bond self, Bond o) -> bool
        __gt__(Bond self, Particle d) -> bool
        """
        return _IMP_atom.Bond___gt__(self, *args)


    def __hash__(self):
        """__hash__(Bond self) -> std::size_t"""
        return _IMP_atom.Bond___hash__(self)


    def __str__(self):
        """__str__(Bond self) -> std::string"""
        return _IMP_atom.Bond___str__(self)


    def __repr__(self):
        """__repr__(Bond self) -> std::string"""
        return _IMP_atom.Bond___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Bond
    __del__ = lambda self: None
Bond_swigregister = _IMP_atom.Bond_swigregister
Bond_swigregister(Bond)

def Bond_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Bond_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Bond_get_is_setup(*args)

def Bond_get_length_key():
    """Bond_get_length_key() -> FloatKey"""
    return _IMP_atom.Bond_get_length_key()

class Bonded(IMP.Decorator):
    """Proxy of C++ IMP::atom::Bonded 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::atom::Bonded self) -> Bonded
        __init__(IMP::atom::Bonded self, Model m, ParticleIndex id) -> Bonded
        __init__(IMP::atom::Bonded self, _ParticleAdaptor d) -> Bonded
        """
        this = _IMP_atom.new_Bonded(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Bonded self, _ostream out)
        show(Bonded self)
        """
        return _IMP_atom.Bonded_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> Bonded
        setup_particle(_ParticleAdaptor decorator) -> Bonded
        """
        return _IMP_atom.Bonded_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_atom.Bonded_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_number_of_bonds(self):
        """get_number_of_bonds(Bonded self) -> unsigned int"""
        return _IMP_atom.Bonded_get_number_of_bonds(self)


    def get_bond_indexes(self):
        """get_bond_indexes(Bonded self) -> IMP::ParticleIndexes"""
        return _IMP_atom.Bonded_get_bond_indexes(self)


    def get_bond(self, i):
        """get_bond(Bonded self, unsigned int i) -> Bond"""
        return _IMP_atom.Bonded_get_bond(self, i)


    def get_bonded(self, i):
        """get_bonded(Bonded self, unsigned int i) -> Bonded"""
        return _IMP_atom.Bonded_get_bonded(self, i)


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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Bonded self, FloatKey a0)
        remove_attribute(Bonded self, IntKey a0)
        remove_attribute(Bonded self, StringKey a0)
        remove_attribute(Bonded self, ParticleIndexKey a0)
        remove_attribute(Bonded self, ObjectKey a0)
        """
        return _IMP_atom.Bonded_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Bonded self, FloatKey a0) -> bool
        has_attribute(Bonded self, IntKey a0) -> bool
        has_attribute(Bonded self, StringKey a0) -> bool
        has_attribute(Bonded self, ParticleIndexKey a0) -> bool
        has_attribute(Bonded self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Bonded_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Bonded self, FloatKey a0) -> double"""
        return _IMP_atom.Bonded_get_derivative(self, a0)


    def get_name(self):
        """get_name(Bonded self) -> std::string"""
        return _IMP_atom.Bonded_get_name(self)


    def clear_caches(self):
        """clear_caches(Bonded self)"""
        return _IMP_atom.Bonded_clear_caches(self)


    def set_name(self, a0):
        """set_name(Bonded self, std::string a0)"""
        return _IMP_atom.Bonded_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Bonded self, IMP::CheckLevel a0)"""
        return _IMP_atom.Bonded_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Bonded self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Bonded_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Bonded self, FloatKey a0, bool a1)"""
        return _IMP_atom.Bonded_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Bonded self, FloatKey a0) -> bool"""
        return _IMP_atom.Bonded_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Bonded self) -> IMP::CheckLevel"""
        return _IMP_atom.Bonded_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Bonded self, Bonded o) -> bool
        __eq__(Bonded self, Particle d) -> bool
        """
        return _IMP_atom.Bonded___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Bonded self, Bonded o) -> bool
        __ne__(Bonded self, Particle d) -> bool
        """
        return _IMP_atom.Bonded___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Bonded self, Bonded o) -> bool
        __le__(Bonded self, Particle d) -> bool
        """
        return _IMP_atom.Bonded___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Bonded self, Bonded o) -> bool
        __lt__(Bonded self, Particle d) -> bool
        """
        return _IMP_atom.Bonded___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Bonded self, Bonded o) -> bool
        __ge__(Bonded self, Particle d) -> bool
        """
        return _IMP_atom.Bonded___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Bonded self, Bonded o) -> bool
        __gt__(Bonded self, Particle d) -> bool
        """
        return _IMP_atom.Bonded___gt__(self, *args)


    def __hash__(self):
        """__hash__(Bonded self) -> std::size_t"""
        return _IMP_atom.Bonded___hash__(self)


    def __str__(self):
        """__str__(Bonded self) -> std::string"""
        return _IMP_atom.Bonded___str__(self)


    def __repr__(self):
        """__repr__(Bonded self) -> std::string"""
        return _IMP_atom.Bonded___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Bonded
    __del__ = lambda self: None
Bonded_swigregister = _IMP_atom.Bonded_swigregister
Bonded_swigregister(Bonded)

def Bonded_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> Bonded
    Bonded_setup_particle(_ParticleAdaptor decorator) -> Bonded
    """
    return _IMP_atom.Bonded_setup_particle(*args)

def Bonded_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Bonded_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Bonded_get_is_setup(*args)


def create_custom_bond(a, b, length, stiffness=-1):
    """
    create_custom_bond(Bonded a, Bonded b, IMP::Float length, IMP::Float stiffness=-1) -> Bond
    create_custom_bond(Bonded a, Bonded b, IMP::Float length) -> Bond
    """
    return _IMP_atom.create_custom_bond(a, b, length, stiffness)

def create_bond(*args):
    """
    create_bond(Bonded a, Bonded b, IMP::Int t) -> Bond
    create_bond(Bonded a, Bonded b, Bond o) -> Bond
    """
    return _IMP_atom.create_bond(*args)

def destroy_bond(b):
    """destroy_bond(Bond b)"""
    return _IMP_atom.destroy_bond(b)

def get_bond(a, b):
    """get_bond(Bonded a, Bonded b) -> Bond"""
    return _IMP_atom.get_bond(a, b)
class BondGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::atom::BondGeometry 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::atom::BondGeometry self, Particle p) -> BondGeometry
        __init__(IMP::atom::BondGeometry self, Bond d) -> BondGeometry
        """
        this = _IMP_atom.new_BondGeometry(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(BondGeometry self) -> VersionInfo"""
        return _IMP_atom.BondGeometry_get_version_info(self)


    def __str__(self):
        """__str__(BondGeometry self) -> std::string"""
        return _IMP_atom.BondGeometry___str__(self)


    def __repr__(self):
        """__repr__(BondGeometry self) -> std::string"""
        return _IMP_atom.BondGeometry___repr__(self)


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

BondGeometry_swigregister = _IMP_atom.BondGeometry_swigregister
BondGeometry_swigregister(BondGeometry)

class BondsGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::atom::BondsGeometry class."""

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

    def __init__(self, sc):
        """__init__(IMP::atom::BondsGeometry self, SingletonContainer sc) -> BondsGeometry"""
        this = _IMP_atom.new_BondsGeometry(sc)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(BondsGeometry self) -> VersionInfo"""
        return _IMP_atom.BondsGeometry_get_version_info(self)


    def __str__(self):
        """__str__(BondsGeometry self) -> std::string"""
        return _IMP_atom.BondsGeometry___str__(self)


    def __repr__(self):
        """__repr__(BondsGeometry self) -> std::string"""
        return _IMP_atom.BondsGeometry___repr__(self)


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

BondsGeometry_swigregister = _IMP_atom.BondsGeometry_swigregister
BondsGeometry_swigregister(BondsGeometry)

class Hierarchy(IMP.core.Hierarchy):
    """Proxy of C++ IMP::atom::Hierarchy 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::atom::Hierarchy self, Model m, ParticleIndex pi) -> Hierarchy
        __init__(IMP::atom::Hierarchy self, _ParticleAdaptor pi) -> Hierarchy
        __init__(IMP::atom::Hierarchy self) -> Hierarchy
        __init__(IMP::atom::Hierarchy self, Hierarchy h) -> Hierarchy
        """
        this = _IMP_atom.new_Hierarchy(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def setup_particle(*args):
        """
        setup_particle(Particle p, _ParticleIndexesAdaptor children) -> Hierarchy
        setup_particle(Particle p) -> Hierarchy
        setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor children) -> Hierarchy
        setup_particle(Model m, ParticleIndex pi) -> Hierarchy
        """
        return _IMP_atom.Hierarchy_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_is_setup(*args):
        """
        get_is_setup(Particle p) -> bool
        get_is_setup(Model m, ParticleIndex p) -> bool
        """
        return _IMP_atom.Hierarchy_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_is_valid(self, print_info=False):
        """
        get_is_valid(Hierarchy self, bool print_info=False) -> bool
        get_is_valid(Hierarchy self) -> bool
        """
        return _IMP_atom.Hierarchy_get_is_valid(self, print_info)


    def add_child(self, o):
        """add_child(Hierarchy self, Hierarchy o)"""
        return _IMP_atom.Hierarchy_add_child(self, o)


    def get_child(self, i):
        """get_child(Hierarchy self, unsigned int i) -> Hierarchy"""
        return _IMP_atom.Hierarchy_get_child(self, i)


    def get_children(self):
        """get_children(Hierarchy self) -> IMP::atom::Hierarchies"""
        return _IMP_atom.Hierarchy_get_children(self)


    def get_parent(self):
        """get_parent(Hierarchy self) -> Hierarchy"""
        return _IMP_atom.Hierarchy_get_parent(self)


    def get_as_atom(self):
        """get_as_atom(Hierarchy self) -> Atom"""
        return _IMP_atom.Hierarchy_get_as_atom(self)


    def get_as_residue(self):
        """get_as_residue(Hierarchy self) -> Residue"""
        return _IMP_atom.Hierarchy_get_as_residue(self)


    def get_as_chain(self):
        """get_as_chain(Hierarchy self) -> Chain"""
        return _IMP_atom.Hierarchy_get_as_chain(self)


    def get_as_molecule(self):
        """get_as_molecule(Hierarchy self) -> Molecule"""
        return _IMP_atom.Hierarchy_get_as_molecule(self)


    def get_as_domain(self):
        """get_as_domain(Hierarchy self) -> Domain"""
        return _IMP_atom.Hierarchy_get_as_domain(self)


    def get_as_fragment(self):
        """get_as_fragment(Hierarchy self) -> Fragment"""
        return _IMP_atom.Hierarchy_get_as_fragment(self)


    def get_as_xyz(self):
        """get_as_xyz(Hierarchy self) -> XYZ"""
        return _IMP_atom.Hierarchy_get_as_xyz(self)


    def get_as_xyzr(self):
        """get_as_xyzr(Hierarchy self) -> XYZR"""
        return _IMP_atom.Hierarchy_get_as_xyzr(self)


    def get_as_mass(self):
        """get_as_mass(Hierarchy self) -> Mass"""
        return _IMP_atom.Hierarchy_get_as_mass(self)


    def get_as_state(self):
        """get_as_state(Hierarchy self) -> State"""
        return _IMP_atom.Hierarchy_get_as_state(self)


    def get_traits():
        """get_traits() -> HierarchyTraits"""
        return _IMP_atom.Hierarchy_get_traits()

    get_traits = staticmethod(get_traits)

    def show(self, *args):
        """
        show(Hierarchy self, _ostream out, std::string delimiter)
        show(Hierarchy self, _ostream out)
        show(Hierarchy self)
        """
        return _IMP_atom.Hierarchy_show(self, *args)


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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Hierarchy self, FloatKey a0)
        remove_attribute(Hierarchy self, IntKey a0)
        remove_attribute(Hierarchy self, StringKey a0)
        remove_attribute(Hierarchy self, ParticleIndexKey a0)
        remove_attribute(Hierarchy self, ObjectKey a0)
        """
        return _IMP_atom.Hierarchy_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Hierarchy self, FloatKey a0) -> bool
        has_attribute(Hierarchy self, IntKey a0) -> bool
        has_attribute(Hierarchy self, StringKey a0) -> bool
        has_attribute(Hierarchy self, ParticleIndexKey a0) -> bool
        has_attribute(Hierarchy self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Hierarchy_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Hierarchy self, FloatKey a0) -> double"""
        return _IMP_atom.Hierarchy_get_derivative(self, a0)


    def get_name(self):
        """get_name(Hierarchy self) -> std::string"""
        return _IMP_atom.Hierarchy_get_name(self)


    def clear_caches(self):
        """clear_caches(Hierarchy self)"""
        return _IMP_atom.Hierarchy_clear_caches(self)


    def set_name(self, a0):
        """set_name(Hierarchy self, std::string a0)"""
        return _IMP_atom.Hierarchy_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Hierarchy self, IMP::CheckLevel a0)"""
        return _IMP_atom.Hierarchy_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Hierarchy self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Hierarchy_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Hierarchy self, FloatKey a0, bool a1)"""
        return _IMP_atom.Hierarchy_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Hierarchy self, FloatKey a0) -> bool"""
        return _IMP_atom.Hierarchy_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Hierarchy self) -> IMP::CheckLevel"""
        return _IMP_atom.Hierarchy_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Hierarchy self, Hierarchy o) -> bool
        __eq__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_atom.Hierarchy___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Hierarchy self, Hierarchy o) -> bool
        __ne__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_atom.Hierarchy___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Hierarchy self, Hierarchy o) -> bool
        __le__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_atom.Hierarchy___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Hierarchy self, Hierarchy o) -> bool
        __lt__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_atom.Hierarchy___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Hierarchy self, Hierarchy o) -> bool
        __ge__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_atom.Hierarchy___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Hierarchy self, Hierarchy o) -> bool
        __gt__(Hierarchy self, Particle d) -> bool
        """
        return _IMP_atom.Hierarchy___gt__(self, *args)


    def __hash__(self):
        """__hash__(Hierarchy self) -> std::size_t"""
        return _IMP_atom.Hierarchy___hash__(self)


    def __str__(self):
        """__str__(Hierarchy self) -> std::string"""
        return _IMP_atom.Hierarchy___str__(self)


    def __repr__(self):
        """__repr__(Hierarchy self) -> std::string"""
        return _IMP_atom.Hierarchy___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Hierarchy
    __del__ = lambda self: None
Hierarchy_swigregister = _IMP_atom.Hierarchy_swigregister
Hierarchy_swigregister(Hierarchy)

def Hierarchy_setup_particle(*args):
    """
    setup_particle(Particle p, _ParticleIndexesAdaptor children) -> Hierarchy
    setup_particle(Particle p) -> Hierarchy
    setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor children) -> Hierarchy
    Hierarchy_setup_particle(Model m, ParticleIndex pi) -> Hierarchy
    """
    return _IMP_atom.Hierarchy_setup_particle(*args)

def Hierarchy_get_is_setup(*args):
    """
    get_is_setup(Particle p) -> bool
    Hierarchy_get_is_setup(Model m, ParticleIndex p) -> bool
    """
    return _IMP_atom.Hierarchy_get_is_setup(*args)

def Hierarchy_get_traits():
    """Hierarchy_get_traits() -> HierarchyTraits"""
    return _IMP_atom.Hierarchy_get_traits()


_IMP_atom.ATOM_TYPE_swigconstant(_IMP_atom)
ATOM_TYPE = _IMP_atom.ATOM_TYPE

_IMP_atom.RESIDUE_TYPE_swigconstant(_IMP_atom)
RESIDUE_TYPE = _IMP_atom.RESIDUE_TYPE

_IMP_atom.CHAIN_TYPE_swigconstant(_IMP_atom)
CHAIN_TYPE = _IMP_atom.CHAIN_TYPE

_IMP_atom.MOLECULE_TYPE_swigconstant(_IMP_atom)
MOLECULE_TYPE = _IMP_atom.MOLECULE_TYPE

_IMP_atom.DOMAIN_TYPE_swigconstant(_IMP_atom)
DOMAIN_TYPE = _IMP_atom.DOMAIN_TYPE

_IMP_atom.FRAGMENT_TYPE_swigconstant(_IMP_atom)
FRAGMENT_TYPE = _IMP_atom.FRAGMENT_TYPE

_IMP_atom.XYZ_TYPE_swigconstant(_IMP_atom)
XYZ_TYPE = _IMP_atom.XYZ_TYPE

_IMP_atom.XYZR_TYPE_swigconstant(_IMP_atom)
XYZR_TYPE = _IMP_atom.XYZR_TYPE

_IMP_atom.MASS_TYPE_swigconstant(_IMP_atom)
MASS_TYPE = _IMP_atom.MASS_TYPE

_IMP_atom.STATE_TYPE_swigconstant(_IMP_atom)
STATE_TYPE = _IMP_atom.STATE_TYPE

def get_by_type(mhd, t):
    """get_by_type(Hierarchy mhd, IMP::atom::GetByType t) -> IMP::atom::Hierarchies"""
    return _IMP_atom.get_by_type(mhd, t)

def create_fragment(ps):
    """create_fragment(IMP::atom::Hierarchies const & ps) -> Hierarchy"""
    return _IMP_atom.create_fragment(ps)

def get_internal_bonds(mhd):
    """get_internal_bonds(Hierarchy mhd) -> IMP::atom::Bonds"""
    return _IMP_atom.get_internal_bonds(mhd)

def get_root(h):
    """get_root(Hierarchy h) -> Hierarchy"""
    return _IMP_atom.get_root(h)

def show(*args):
    """
    show(Hierarchy h, _ostream out)
    show(Hierarchy h)
    """
    return _IMP_atom.show(*args)

def create_rigid_body(*args):
    """
    create_rigid_body(IMP::atom::Hierarchies const & h, std::string name) -> RigidBody
    create_rigid_body(IMP::atom::Hierarchies const & h) -> RigidBody
    create_rigid_body(Hierarchy h) -> RigidBody
    """
    return _IMP_atom.create_rigid_body(*args)

def create_compatible_rigid_body(h, reference):
    """create_compatible_rigid_body(Hierarchy h, Hierarchy reference) -> RigidBody"""
    return _IMP_atom.create_compatible_rigid_body(h, reference)

def setup_as_rigid_body(h):
    """setup_as_rigid_body(Hierarchy h) -> RigidBody"""
    return _IMP_atom.setup_as_rigid_body(h)

def get_is_heterogen(h):
    """get_is_heterogen(Hierarchy h) -> bool"""
    return _IMP_atom.get_is_heterogen(h)

def create_clone(d):
    """create_clone(Hierarchy d) -> Hierarchy"""
    return _IMP_atom.create_clone(d)

def create_clone_one(d):
    """create_clone_one(Hierarchy d) -> Hierarchy"""
    return _IMP_atom.create_clone_one(d)

def destroy(d):
    """destroy(Hierarchy d)"""
    return _IMP_atom.destroy(d)

def get_bounding_box(h):
    """get_bounding_box(Hierarchy h) -> BoundingBox3D"""
    return _IMP_atom.get_bounding_box(h)

def get_bounding_sphere(h):
    """get_bounding_sphere(Hierarchy h) -> Sphere3D"""
    return _IMP_atom.get_bounding_sphere(h)
class Angle(IMP.Decorator):
    """Proxy of C++ IMP::atom::Angle 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::atom::Angle self) -> Angle
        __init__(IMP::atom::Angle self, Model m, ParticleIndex id) -> Angle
        __init__(IMP::atom::Angle self, _ParticleAdaptor d) -> Angle
        """
        this = _IMP_atom.new_Angle(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Angle self, _ostream out)
        show(Angle self)
        """
        return _IMP_atom.Angle_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, XYZ a, XYZ b, XYZ c) -> Angle
        setup_particle(_ParticleAdaptor decorator, XYZ a, XYZ b, XYZ c) -> Angle
        """
        return _IMP_atom.Angle_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_atom.Angle_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_particle(self, *args):
        """
        get_particle(Angle self) -> Particle
        get_particle(Angle self, unsigned int i) -> Particle
        """
        return _IMP_atom.Angle_get_particle(self, *args)


    def get_ideal(self):
        """get_ideal(Angle self) -> IMP::Float"""
        return _IMP_atom.Angle_get_ideal(self)


    def set_ideal(self, t):
        """set_ideal(Angle self, IMP::Float t)"""
        return _IMP_atom.Angle_set_ideal(self, t)


    def get_stiffness(self):
        """get_stiffness(Angle self) -> IMP::Float"""
        return _IMP_atom.Angle_get_stiffness(self)


    def set_stiffness(self, t):
        """set_stiffness(Angle self, IMP::Float t)"""
        return _IMP_atom.Angle_set_stiffness(self, t)


    def get_particle_key(i):
        """get_particle_key(unsigned int i) -> ParticleIndexKey"""
        return _IMP_atom.Angle_get_particle_key(i)

    get_particle_key = staticmethod(get_particle_key)

    def get_ideal_key():
        """get_ideal_key() -> FloatKey"""
        return _IMP_atom.Angle_get_ideal_key()

    get_ideal_key = staticmethod(get_ideal_key)

    def get_stiffness_key():
        """get_stiffness_key() -> FloatKey"""
        return _IMP_atom.Angle_get_stiffness_key()

    get_stiffness_key = staticmethod(get_stiffness_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Angle self, FloatKey a0)
        remove_attribute(Angle self, IntKey a0)
        remove_attribute(Angle self, StringKey a0)
        remove_attribute(Angle self, ParticleIndexKey a0)
        remove_attribute(Angle self, ObjectKey a0)
        """
        return _IMP_atom.Angle_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Angle self, FloatKey a0) -> bool
        has_attribute(Angle self, IntKey a0) -> bool
        has_attribute(Angle self, StringKey a0) -> bool
        has_attribute(Angle self, ParticleIndexKey a0) -> bool
        has_attribute(Angle self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Angle_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Angle self, FloatKey a0) -> double"""
        return _IMP_atom.Angle_get_derivative(self, a0)


    def get_name(self):
        """get_name(Angle self) -> std::string"""
        return _IMP_atom.Angle_get_name(self)


    def clear_caches(self):
        """clear_caches(Angle self)"""
        return _IMP_atom.Angle_clear_caches(self)


    def set_name(self, a0):
        """set_name(Angle self, std::string a0)"""
        return _IMP_atom.Angle_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Angle self, IMP::CheckLevel a0)"""
        return _IMP_atom.Angle_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Angle self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Angle_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Angle self, FloatKey a0, bool a1)"""
        return _IMP_atom.Angle_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Angle self, FloatKey a0) -> bool"""
        return _IMP_atom.Angle_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Angle self) -> IMP::CheckLevel"""
        return _IMP_atom.Angle_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Angle self, Angle o) -> bool
        __eq__(Angle self, Particle d) -> bool
        """
        return _IMP_atom.Angle___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Angle self, Angle o) -> bool
        __ne__(Angle self, Particle d) -> bool
        """
        return _IMP_atom.Angle___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Angle self, Angle o) -> bool
        __le__(Angle self, Particle d) -> bool
        """
        return _IMP_atom.Angle___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Angle self, Angle o) -> bool
        __lt__(Angle self, Particle d) -> bool
        """
        return _IMP_atom.Angle___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Angle self, Angle o) -> bool
        __ge__(Angle self, Particle d) -> bool
        """
        return _IMP_atom.Angle___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Angle self, Angle o) -> bool
        __gt__(Angle self, Particle d) -> bool
        """
        return _IMP_atom.Angle___gt__(self, *args)


    def __hash__(self):
        """__hash__(Angle self) -> std::size_t"""
        return _IMP_atom.Angle___hash__(self)


    def __str__(self):
        """__str__(Angle self) -> std::string"""
        return _IMP_atom.Angle___str__(self)


    def __repr__(self):
        """__repr__(Angle self) -> std::string"""
        return _IMP_atom.Angle___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Angle
    __del__ = lambda self: None
Angle_swigregister = _IMP_atom.Angle_swigregister
Angle_swigregister(Angle)

def Angle_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, XYZ a, XYZ b, XYZ c) -> Angle
    Angle_setup_particle(_ParticleAdaptor decorator, XYZ a, XYZ b, XYZ c) -> Angle
    """
    return _IMP_atom.Angle_setup_particle(*args)

def Angle_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Angle_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Angle_get_is_setup(*args)

def Angle_get_particle_key(i):
    """Angle_get_particle_key(unsigned int i) -> ParticleIndexKey"""
    return _IMP_atom.Angle_get_particle_key(i)

def Angle_get_ideal_key():
    """Angle_get_ideal_key() -> FloatKey"""
    return _IMP_atom.Angle_get_ideal_key()

def Angle_get_stiffness_key():
    """Angle_get_stiffness_key() -> FloatKey"""
    return _IMP_atom.Angle_get_stiffness_key()

class Dihedral(IMP.Decorator):
    """Proxy of C++ IMP::atom::Dihedral 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::atom::Dihedral self) -> Dihedral
        __init__(IMP::atom::Dihedral self, Model m, ParticleIndex id) -> Dihedral
        __init__(IMP::atom::Dihedral self, _ParticleAdaptor d) -> Dihedral
        """
        this = _IMP_atom.new_Dihedral(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Dihedral self, _ostream out)
        show(Dihedral self)
        """
        return _IMP_atom.Dihedral_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, XYZ a, XYZ b, XYZ c, XYZ d) -> Dihedral
        setup_particle(_ParticleAdaptor decorator, XYZ a, XYZ b, XYZ c, XYZ d) -> Dihedral
        """
        return _IMP_atom.Dihedral_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_atom.Dihedral_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_particle(self, *args):
        """
        get_particle(Dihedral self) -> Particle
        get_particle(Dihedral self, unsigned int i) -> Particle
        """
        return _IMP_atom.Dihedral_get_particle(self, *args)


    def get_ideal(self):
        """get_ideal(Dihedral self) -> IMP::Float"""
        return _IMP_atom.Dihedral_get_ideal(self)


    def set_ideal(self, t):
        """set_ideal(Dihedral self, IMP::Float t)"""
        return _IMP_atom.Dihedral_set_ideal(self, t)


    def get_multiplicity(self):
        """get_multiplicity(Dihedral self) -> IMP::Int"""
        return _IMP_atom.Dihedral_get_multiplicity(self)


    def set_multiplicity(self, t):
        """set_multiplicity(Dihedral self, IMP::Int t)"""
        return _IMP_atom.Dihedral_set_multiplicity(self, t)


    def get_stiffness(self):
        """get_stiffness(Dihedral self) -> IMP::Float"""
        return _IMP_atom.Dihedral_get_stiffness(self)


    def set_stiffness(self, t):
        """set_stiffness(Dihedral self, IMP::Float t)"""
        return _IMP_atom.Dihedral_set_stiffness(self, t)


    def get_particle_key(i):
        """get_particle_key(unsigned int i) -> ParticleIndexKey"""
        return _IMP_atom.Dihedral_get_particle_key(i)

    get_particle_key = staticmethod(get_particle_key)

    def get_ideal_key():
        """get_ideal_key() -> FloatKey"""
        return _IMP_atom.Dihedral_get_ideal_key()

    get_ideal_key = staticmethod(get_ideal_key)

    def get_multiplicity_key():
        """get_multiplicity_key() -> IntKey"""
        return _IMP_atom.Dihedral_get_multiplicity_key()

    get_multiplicity_key = staticmethod(get_multiplicity_key)

    def get_stiffness_key():
        """get_stiffness_key() -> FloatKey"""
        return _IMP_atom.Dihedral_get_stiffness_key()

    get_stiffness_key = staticmethod(get_stiffness_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Dihedral self, FloatKey a0)
        remove_attribute(Dihedral self, IntKey a0)
        remove_attribute(Dihedral self, StringKey a0)
        remove_attribute(Dihedral self, ParticleIndexKey a0)
        remove_attribute(Dihedral self, ObjectKey a0)
        """
        return _IMP_atom.Dihedral_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Dihedral self, FloatKey a0) -> bool
        has_attribute(Dihedral self, IntKey a0) -> bool
        has_attribute(Dihedral self, StringKey a0) -> bool
        has_attribute(Dihedral self, ParticleIndexKey a0) -> bool
        has_attribute(Dihedral self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Dihedral_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Dihedral self, FloatKey a0) -> double"""
        return _IMP_atom.Dihedral_get_derivative(self, a0)


    def get_name(self):
        """get_name(Dihedral self) -> std::string"""
        return _IMP_atom.Dihedral_get_name(self)


    def clear_caches(self):
        """clear_caches(Dihedral self)"""
        return _IMP_atom.Dihedral_clear_caches(self)


    def set_name(self, a0):
        """set_name(Dihedral self, std::string a0)"""
        return _IMP_atom.Dihedral_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Dihedral self, IMP::CheckLevel a0)"""
        return _IMP_atom.Dihedral_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Dihedral self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Dihedral_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Dihedral self, FloatKey a0, bool a1)"""
        return _IMP_atom.Dihedral_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Dihedral self, FloatKey a0) -> bool"""
        return _IMP_atom.Dihedral_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Dihedral self) -> IMP::CheckLevel"""
        return _IMP_atom.Dihedral_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Dihedral self, Dihedral o) -> bool
        __eq__(Dihedral self, Particle d) -> bool
        """
        return _IMP_atom.Dihedral___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Dihedral self, Dihedral o) -> bool
        __ne__(Dihedral self, Particle d) -> bool
        """
        return _IMP_atom.Dihedral___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Dihedral self, Dihedral o) -> bool
        __le__(Dihedral self, Particle d) -> bool
        """
        return _IMP_atom.Dihedral___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Dihedral self, Dihedral o) -> bool
        __lt__(Dihedral self, Particle d) -> bool
        """
        return _IMP_atom.Dihedral___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Dihedral self, Dihedral o) -> bool
        __ge__(Dihedral self, Particle d) -> bool
        """
        return _IMP_atom.Dihedral___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Dihedral self, Dihedral o) -> bool
        __gt__(Dihedral self, Particle d) -> bool
        """
        return _IMP_atom.Dihedral___gt__(self, *args)


    def __hash__(self):
        """__hash__(Dihedral self) -> std::size_t"""
        return _IMP_atom.Dihedral___hash__(self)


    def __str__(self):
        """__str__(Dihedral self) -> std::string"""
        return _IMP_atom.Dihedral___str__(self)


    def __repr__(self):
        """__repr__(Dihedral self) -> std::string"""
        return _IMP_atom.Dihedral___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Dihedral
    __del__ = lambda self: None
Dihedral_swigregister = _IMP_atom.Dihedral_swigregister
Dihedral_swigregister(Dihedral)

def Dihedral_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, XYZ a, XYZ b, XYZ c, XYZ d) -> Dihedral
    Dihedral_setup_particle(_ParticleAdaptor decorator, XYZ a, XYZ b, XYZ c, XYZ d) -> Dihedral
    """
    return _IMP_atom.Dihedral_setup_particle(*args)

def Dihedral_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Dihedral_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Dihedral_get_is_setup(*args)

def Dihedral_get_particle_key(i):
    """Dihedral_get_particle_key(unsigned int i) -> ParticleIndexKey"""
    return _IMP_atom.Dihedral_get_particle_key(i)

def Dihedral_get_ideal_key():
    """Dihedral_get_ideal_key() -> FloatKey"""
    return _IMP_atom.Dihedral_get_ideal_key()

def Dihedral_get_multiplicity_key():
    """Dihedral_get_multiplicity_key() -> IntKey"""
    return _IMP_atom.Dihedral_get_multiplicity_key()

def Dihedral_get_stiffness_key():
    """Dihedral_get_stiffness_key() -> FloatKey"""
    return _IMP_atom.Dihedral_get_stiffness_key()

class SmoothingFunction(IMP.Object):
    """Proxy of C++ IMP::atom::SmoothingFunction 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")

    def __call__(self, *args):
        """
        __call__(SmoothingFunction self, double score, double distance) -> double
        __call__(SmoothingFunction self, double score, double deriv, double distance) -> IMP::DerivativePair
        """
        return _IMP_atom.SmoothingFunction___call__(self, *args)

    __swig_destroy__ = _IMP_atom.delete_SmoothingFunction
    __del__ = lambda self: None

    def __str__(self):
        """__str__(SmoothingFunction self) -> std::string"""
        return _IMP_atom.SmoothingFunction___str__(self)


    def __repr__(self):
        """__repr__(SmoothingFunction self) -> std::string"""
        return _IMP_atom.SmoothingFunction___repr__(self)


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

SmoothingFunction_swigregister = _IMP_atom.SmoothingFunction_swigregister
SmoothingFunction_swigregister(SmoothingFunction)

class ForceSwitch(SmoothingFunction):
    """Proxy of C++ IMP::atom::ForceSwitch class."""

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

    def __init__(self, min_distance, max_distance):
        """__init__(IMP::atom::ForceSwitch self, double min_distance, double max_distance) -> ForceSwitch"""
        this = _IMP_atom.new_ForceSwitch(min_distance, max_distance)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __call__(self, *args):
        """
        __call__(ForceSwitch self, double score, double distance) -> double
        __call__(ForceSwitch self, double score, double deriv, double distance) -> IMP::DerivativePair
        """
        return _IMP_atom.ForceSwitch___call__(self, *args)


    def get_version_info(self):
        """get_version_info(ForceSwitch self) -> VersionInfo"""
        return _IMP_atom.ForceSwitch_get_version_info(self)


    def __str__(self):
        """__str__(ForceSwitch self) -> std::string"""
        return _IMP_atom.ForceSwitch___str__(self)


    def __repr__(self):
        """__repr__(ForceSwitch self) -> std::string"""
        return _IMP_atom.ForceSwitch___repr__(self)


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

ForceSwitch_swigregister = _IMP_atom.ForceSwitch_swigregister
ForceSwitch_swigregister(ForceSwitch)

class AngleSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::atom::AngleSingletonScore class."""

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

    def __init__(self, f):
        """__init__(IMP::atom::AngleSingletonScore self, UnaryFunction f) -> AngleSingletonScore"""
        this = _IMP_atom.new_AngleSingletonScore(f)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(AngleSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.AngleSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(AngleSingletonScore self) -> VersionInfo"""
        return _IMP_atom.AngleSingletonScore_get_version_info(self)


    def __str__(self):
        """__str__(AngleSingletonScore self) -> std::string"""
        return _IMP_atom.AngleSingletonScore___str__(self)


    def __repr__(self):
        """__repr__(AngleSingletonScore self) -> std::string"""
        return _IMP_atom.AngleSingletonScore___repr__(self)


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

AngleSingletonScore_swigregister = _IMP_atom.AngleSingletonScore_swigregister
AngleSingletonScore_swigregister(AngleSingletonScore)

class BondEndpointsRefiner(IMP.Refiner):
    """Proxy of C++ IMP::atom::BondEndpointsRefiner 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::atom::BondEndpointsRefiner self) -> BondEndpointsRefiner"""
        this = _IMP_atom.new_BondEndpointsRefiner()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(BondEndpointsRefiner self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.BondEndpointsRefiner_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(BondEndpointsRefiner self) -> VersionInfo"""
        return _IMP_atom.BondEndpointsRefiner_get_version_info(self)


    def __str__(self):
        """__str__(BondEndpointsRefiner self) -> std::string"""
        return _IMP_atom.BondEndpointsRefiner___str__(self)


    def __repr__(self):
        """__repr__(BondEndpointsRefiner self) -> std::string"""
        return _IMP_atom.BondEndpointsRefiner___repr__(self)


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

BondEndpointsRefiner_swigregister = _IMP_atom.BondEndpointsRefiner_swigregister
BondEndpointsRefiner_swigregister(BondEndpointsRefiner)

class BondPairContainer(IMP.PairContainer):
    """Proxy of C++ IMP::atom::BondPairContainer class."""

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

    def __init__(self, sc):
        """__init__(IMP::atom::BondPairContainer self, SingletonContainer sc) -> BondPairContainer"""
        this = _IMP_atom.new_BondPairContainer(sc)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(BondPairContainer self) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.BondPairContainer_do_get_inputs(self)


    def do_apply(self, sm):
        """do_apply(BondPairContainer self, PairModifier sm)"""
        return _IMP_atom.BondPairContainer_do_apply(self, sm)


    def get_version_info(self):
        """get_version_info(BondPairContainer self) -> VersionInfo"""
        return _IMP_atom.BondPairContainer_get_version_info(self)


    def __str__(self):
        """__str__(BondPairContainer self) -> std::string"""
        return _IMP_atom.BondPairContainer___str__(self)


    def __repr__(self):
        """__repr__(BondPairContainer self) -> std::string"""
        return _IMP_atom.BondPairContainer___repr__(self)


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

BondPairContainer_swigregister = _IMP_atom.BondPairContainer_swigregister
BondPairContainer_swigregister(BondPairContainer)

class BondSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::atom::BondSingletonScore class."""

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

    def __init__(self, f):
        """__init__(IMP::atom::BondSingletonScore self, UnaryFunction f) -> BondSingletonScore"""
        this = _IMP_atom.new_BondSingletonScore(f)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_unary_function(self):
        """get_unary_function(BondSingletonScore self) -> UnaryFunction"""
        return _IMP_atom.BondSingletonScore_get_unary_function(self)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(BondSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.BondSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(BondSingletonScore self) -> VersionInfo"""
        return _IMP_atom.BondSingletonScore_get_version_info(self)


    def __str__(self):
        """__str__(BondSingletonScore self) -> std::string"""
        return _IMP_atom.BondSingletonScore___str__(self)


    def __repr__(self):
        """__repr__(BondSingletonScore self) -> std::string"""
        return _IMP_atom.BondSingletonScore___repr__(self)


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

BondSingletonScore_swigregister = _IMP_atom.BondSingletonScore_swigregister
BondSingletonScore_swigregister(BondSingletonScore)

class DihedralSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::atom::DihedralSingletonScore 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::atom::DihedralSingletonScore self) -> DihedralSingletonScore"""
        this = _IMP_atom.new_DihedralSingletonScore()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(DihedralSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.DihedralSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(DihedralSingletonScore self) -> VersionInfo"""
        return _IMP_atom.DihedralSingletonScore_get_version_info(self)


    def __str__(self):
        """__str__(DihedralSingletonScore self) -> std::string"""
        return _IMP_atom.DihedralSingletonScore___str__(self)


    def __repr__(self):
        """__repr__(DihedralSingletonScore self) -> std::string"""
        return _IMP_atom.DihedralSingletonScore___repr__(self)


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

DihedralSingletonScore_swigregister = _IMP_atom.DihedralSingletonScore_swigregister
DihedralSingletonScore_swigregister(DihedralSingletonScore)

class ImproperSingletonScore(IMP.SingletonScore):
    """Proxy of C++ IMP::atom::ImproperSingletonScore class."""

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

    def __init__(self, f):
        """__init__(IMP::atom::ImproperSingletonScore self, UnaryFunction f) -> ImproperSingletonScore"""
        this = _IMP_atom.new_ImproperSingletonScore(f)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(ImproperSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.ImproperSingletonScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(ImproperSingletonScore self) -> VersionInfo"""
        return _IMP_atom.ImproperSingletonScore_get_version_info(self)


    def __str__(self):
        """__str__(ImproperSingletonScore self) -> std::string"""
        return _IMP_atom.ImproperSingletonScore___str__(self)


    def __repr__(self):
        """__repr__(ImproperSingletonScore self) -> std::string"""
        return _IMP_atom.ImproperSingletonScore___repr__(self)


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

ImproperSingletonScore_swigregister = _IMP_atom.ImproperSingletonScore_swigregister
ImproperSingletonScore_swigregister(ImproperSingletonScore)

class CenterOfMass(IMP.Decorator):
    """Proxy of C++ IMP::atom::CenterOfMass class."""

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

    def get_constraint(self):
        """get_constraint(CenterOfMass self) -> Constraint"""
        return _IMP_atom.CenterOfMass_get_constraint(self)


    def get_mass(self):
        """get_mass(CenterOfMass self) -> IMP::Float"""
        return _IMP_atom.CenterOfMass_get_mass(self)


    def get_coordinate(self, i):
        """get_coordinate(CenterOfMass self, int i) -> IMP::Float"""
        return _IMP_atom.CenterOfMass_get_coordinate(self, i)


    def get_coordinates(self):
        """get_coordinates(CenterOfMass self) -> Vector3D"""
        return _IMP_atom.CenterOfMass_get_coordinates(self)


    def __init__(self, *args):
        """
        __init__(IMP::atom::CenterOfMass self) -> CenterOfMass
        __init__(IMP::atom::CenterOfMass self, Model m, ParticleIndex id) -> CenterOfMass
        __init__(IMP::atom::CenterOfMass self, _ParticleAdaptor d) -> CenterOfMass
        """
        this = _IMP_atom.new_CenterOfMass(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(CenterOfMass self, _ostream out)
        show(CenterOfMass self)
        """
        return _IMP_atom.CenterOfMass_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor members) -> CenterOfMass
        setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor members) -> CenterOfMass
        setup_particle(Model m, ParticleIndex pi, Refiner refiner) -> CenterOfMass
        setup_particle(_ParticleAdaptor decorator, Refiner refiner) -> CenterOfMass
        """
        return _IMP_atom.CenterOfMass_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_atom.CenterOfMass_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(CenterOfMass self, FloatKey a0)
        remove_attribute(CenterOfMass self, IntKey a0)
        remove_attribute(CenterOfMass self, StringKey a0)
        remove_attribute(CenterOfMass self, ParticleIndexKey a0)
        remove_attribute(CenterOfMass self, ObjectKey a0)
        """
        return _IMP_atom.CenterOfMass_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(CenterOfMass self, FloatKey a0) -> bool
        has_attribute(CenterOfMass self, IntKey a0) -> bool
        has_attribute(CenterOfMass self, StringKey a0) -> bool
        has_attribute(CenterOfMass self, ParticleIndexKey a0) -> bool
        has_attribute(CenterOfMass self, ObjectKey a0) -> bool
        """
        return _IMP_atom.CenterOfMass_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(CenterOfMass self, FloatKey a0) -> double"""
        return _IMP_atom.CenterOfMass_get_derivative(self, a0)


    def get_name(self):
        """get_name(CenterOfMass self) -> std::string"""
        return _IMP_atom.CenterOfMass_get_name(self)


    def clear_caches(self):
        """clear_caches(CenterOfMass self)"""
        return _IMP_atom.CenterOfMass_clear_caches(self)


    def set_name(self, a0):
        """set_name(CenterOfMass self, std::string a0)"""
        return _IMP_atom.CenterOfMass_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(CenterOfMass self, IMP::CheckLevel a0)"""
        return _IMP_atom.CenterOfMass_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(CenterOfMass self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.CenterOfMass_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(CenterOfMass self, FloatKey a0, bool a1)"""
        return _IMP_atom.CenterOfMass_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(CenterOfMass self, FloatKey a0) -> bool"""
        return _IMP_atom.CenterOfMass_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(CenterOfMass self) -> IMP::CheckLevel"""
        return _IMP_atom.CenterOfMass_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(CenterOfMass self, CenterOfMass o) -> bool
        __eq__(CenterOfMass self, Particle d) -> bool
        """
        return _IMP_atom.CenterOfMass___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(CenterOfMass self, CenterOfMass o) -> bool
        __ne__(CenterOfMass self, Particle d) -> bool
        """
        return _IMP_atom.CenterOfMass___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(CenterOfMass self, CenterOfMass o) -> bool
        __le__(CenterOfMass self, Particle d) -> bool
        """
        return _IMP_atom.CenterOfMass___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(CenterOfMass self, CenterOfMass o) -> bool
        __lt__(CenterOfMass self, Particle d) -> bool
        """
        return _IMP_atom.CenterOfMass___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(CenterOfMass self, CenterOfMass o) -> bool
        __ge__(CenterOfMass self, Particle d) -> bool
        """
        return _IMP_atom.CenterOfMass___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(CenterOfMass self, CenterOfMass o) -> bool
        __gt__(CenterOfMass self, Particle d) -> bool
        """
        return _IMP_atom.CenterOfMass___gt__(self, *args)


    def __hash__(self):
        """__hash__(CenterOfMass self) -> std::size_t"""
        return _IMP_atom.CenterOfMass___hash__(self)


    def __str__(self):
        """__str__(CenterOfMass self) -> std::string"""
        return _IMP_atom.CenterOfMass___str__(self)


    def __repr__(self):
        """__repr__(CenterOfMass self) -> std::string"""
        return _IMP_atom.CenterOfMass___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_CenterOfMass
    __del__ = lambda self: None
CenterOfMass_swigregister = _IMP_atom.CenterOfMass_swigregister
CenterOfMass_swigregister(CenterOfMass)

def CenterOfMass_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, _ParticleIndexesAdaptor members) -> CenterOfMass
    setup_particle(_ParticleAdaptor decorator, _ParticleIndexesAdaptor members) -> CenterOfMass
    setup_particle(Model m, ParticleIndex pi, Refiner refiner) -> CenterOfMass
    CenterOfMass_setup_particle(_ParticleAdaptor decorator, Refiner refiner) -> CenterOfMass
    """
    return _IMP_atom.CenterOfMass_setup_particle(*args)

def CenterOfMass_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    CenterOfMass_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.CenterOfMass_get_is_setup(*args)

class CoverBond(IMP.SingletonModifier):
    """Proxy of C++ IMP::atom::CoverBond 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::atom::CoverBond self) -> CoverBond"""
        this = _IMP_atom.new_CoverBond()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(CoverBond self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.CoverBond_do_get_inputs(self, m, pis)


    def do_get_outputs(self, m, pis):
        """do_get_outputs(CoverBond self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.CoverBond_do_get_outputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(CoverBond self) -> VersionInfo"""
        return _IMP_atom.CoverBond_get_version_info(self)


    def __str__(self):
        """__str__(CoverBond self) -> std::string"""
        return _IMP_atom.CoverBond___str__(self)


    def __repr__(self):
        """__repr__(CoverBond self) -> std::string"""
        return _IMP_atom.CoverBond___repr__(self)


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

CoverBond_swigregister = _IMP_atom.CoverBond_swigregister
CoverBond_swigregister(CoverBond)

class Simulator(IMP.Optimizer):
    """Proxy of C++ IMP::atom::Simulator 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::atom::Simulator self, Model m, std::string name, double wave_factor=1.0) -> Simulator
        __init__(IMP::atom::Simulator self, Model m, std::string name) -> Simulator
        __init__(IMP::atom::Simulator self, Model m) -> Simulator
        """
        if self.__class__ == Simulator:
            _self = None
        else:
            _self = self
        this = _IMP_atom.new_Simulator(_self, *args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

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




    def simulate(self, time_in_fs):
        """simulate(Simulator self, double time_in_fs) -> double"""
        return _IMP_atom.Simulator_simulate(self, time_in_fs)


    def simulate_wave(self, time_in_fs, max_time_step_factor=10.0, base=1.5):
        """
        simulate_wave(Simulator self, double time_in_fs, double max_time_step_factor=10.0, double base=1.5) -> double
        simulate_wave(Simulator self, double time_in_fs, double max_time_step_factor=10.0) -> double
        simulate_wave(Simulator self, double time_in_fs) -> double
        """
        return _IMP_atom.Simulator_simulate_wave(self, time_in_fs, max_time_step_factor, base)


    def get_temperature(self):
        """get_temperature(Simulator self) -> double"""
        return _IMP_atom.Simulator_get_temperature(self)


    def set_temperature(self, d):
        """set_temperature(Simulator self, double d)"""
        return _IMP_atom.Simulator_set_temperature(self, d)


    def set_maximum_time_step(self, ts):
        """set_maximum_time_step(Simulator self, double ts)"""
        return _IMP_atom.Simulator_set_maximum_time_step(self, ts)


    def get_maximum_time_step(self):
        """get_maximum_time_step(Simulator self) -> double"""
        return _IMP_atom.Simulator_get_maximum_time_step(self)


    def get_last_time_step(self):
        """get_last_time_step(Simulator self) -> double"""
        return _IMP_atom.Simulator_get_last_time_step(self)


    def set_time_step(self, ts):
        """set_time_step(Simulator self, double ts)"""
        return _IMP_atom.Simulator_set_time_step(self, ts)


    def get_kt(self):
        """get_kt(Simulator self) -> double"""
        return _IMP_atom.Simulator_get_kt(self)


    def get_current_time(self):
        """get_current_time(Simulator self) -> double"""
        return _IMP_atom.Simulator_get_current_time(self)


    def set_current_time(self, ct):
        """set_current_time(Simulator self, double ct)"""
        return _IMP_atom.Simulator_set_current_time(self, ct)


    def get_simulation_particles(self):
        """get_simulation_particles(Simulator self) -> IMP::ParticlesTemp"""
        return _IMP_atom.Simulator_get_simulation_particles(self)


    def get_simulation_particle_indexes(self):
        """get_simulation_particle_indexes(Simulator self) -> IMP::ParticleIndexes"""
        return _IMP_atom.Simulator_get_simulation_particle_indexes(self)


    def remove_particle(self, d):
        """remove_particle(Simulator self, Particle d)"""
        return _IMP_atom.Simulator_remove_particle(self, d)


    def remove_particles(self, d):
        """remove_particles(Simulator self, IMP::Particles const & d)"""
        return _IMP_atom.Simulator_remove_particles(self, d)


    def set_particles(self, ps):
        """set_particles(Simulator self, IMP::Particles const & ps)"""
        return _IMP_atom.Simulator_set_particles(self, ps)


    def set_particles_order(self, objs):
        """set_particles_order(Simulator self, IMP::Particles const & objs)"""
        return _IMP_atom.Simulator_set_particles_order(self, objs)


    def add_particle(self, obj):
        """add_particle(Simulator self, Particle obj) -> unsigned int"""
        return _IMP_atom.Simulator_add_particle(self, obj)


    def add_particles(self, objs):
        """add_particles(Simulator self, IMP::Particles const & objs)"""
        return _IMP_atom.Simulator_add_particles(self, objs)


    def clear_particles(self):
        """clear_particles(Simulator self)"""
        return _IMP_atom.Simulator_clear_particles(self)


    def get_number_of_particles(self):
        """get_number_of_particles(Simulator self) -> unsigned int"""
        return _IMP_atom.Simulator_get_number_of_particles(self)


    def get_has_particles(self):
        """get_has_particles(Simulator self) -> bool"""
        return _IMP_atom.Simulator_get_has_particles(self)


    def get_particle(self, i):
        """get_particle(Simulator self, unsigned int i) -> Particle"""
        return _IMP_atom.Simulator_get_particle(self, i)


    def get_particles(self):
        """get_particles(Simulator self) -> IMP::Particles"""
        return _IMP_atom.Simulator_get_particles(self)


    def reserve_particles(self, sz):
        """reserve_particles(Simulator self, unsigned int sz)"""
        return _IMP_atom.Simulator_reserve_particles(self, sz)


    def do_optimize(self, max_steps):
        """do_optimize(Simulator self, unsigned int max_steps) -> IMP::Float"""
        return _IMP_atom.Simulator_do_optimize(self, max_steps)


    def setup(self, arg0):
        """setup(Simulator self, IMP::ParticleIndexes const & arg0)"""
        return _IMP_atom.Simulator_setup(self, arg0)


    def do_step(self, sc, dt):
        """do_step(Simulator self, IMP::ParticleIndexes const & sc, double dt) -> double"""
        return _IMP_atom.Simulator_do_step(self, sc, dt)


    def get_is_simulation_particle(self, p):
        """get_is_simulation_particle(Simulator self, ParticleIndex p) -> bool"""
        return _IMP_atom.Simulator_get_is_simulation_particle(self, p)


    def do_simulate(self, time):
        """do_simulate(Simulator self, double time) -> double"""
        return _IMP_atom.Simulator_do_simulate(self, time)


    def do_simulate_wave(self, time_in_fs, max_time_step_factor=10.0, base=1.5):
        """
        do_simulate_wave(Simulator self, double time_in_fs, double max_time_step_factor=10.0, double base=1.5) -> double
        do_simulate_wave(Simulator self, double time_in_fs, double max_time_step_factor=10.0) -> double
        do_simulate_wave(Simulator self, double time_in_fs) -> double
        """
        return _IMP_atom.Simulator_do_simulate_wave(self, time_in_fs, max_time_step_factor, base)


    def __str__(self):
        """__str__(Simulator self) -> std::string"""
        return _IMP_atom.Simulator___str__(self)


    def __repr__(self):
        """__repr__(Simulator self) -> std::string"""
        return _IMP_atom.Simulator___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::atom" == "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_Simulator(o)

    __swig_destroy__ = _IMP_atom.delete_Simulator
    __del__ = lambda self: None
    def __disown__(self):
        self.this.disown()
        _IMP_atom.disown_Simulator(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(Simulator self)"""
        return _IMP_atom.Simulator_do_destroy(self)


    def handle_set_has_required_score_states(self, arg0):
        """handle_set_has_required_score_states(Simulator self, bool arg0)"""
        return _IMP_atom.Simulator_handle_set_has_required_score_states(self, arg0)


    def do_get_inputs(self):
        """do_get_inputs(Simulator self) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.Simulator_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(Simulator self) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.Simulator_do_get_outputs(self)


    def do_get_interactions(self):
        """do_get_interactions(Simulator self) -> IMP::ModelObjectsTemps"""
        return _IMP_atom.Simulator_do_get_interactions(self)

Simulator_swigregister = _IMP_atom.Simulator_swigregister
Simulator_swigregister(Simulator)


def get_energy_in_femto_joules(energy_in_kcal_per_mol):
    """get_energy_in_femto_joules(double energy_in_kcal_per_mol) -> double"""
    return _IMP_atom.get_energy_in_femto_joules(energy_in_kcal_per_mol)

def get_force_in_femto_newtons(force_in_kcal_per_mol_per_angstrom):
    """get_force_in_femto_newtons(double force_in_kcal_per_mol_per_angstrom) -> double"""
    return _IMP_atom.get_force_in_femto_newtons(force_in_kcal_per_mol_per_angstrom)

def get_spring_constant_in_femto_newtons_per_angstrom(k_in_kcal_per_mol_per_angstrom_square):
    """get_spring_constant_in_femto_newtons_per_angstrom(double k_in_kcal_per_mol_per_angstrom_square) -> double"""
    return _IMP_atom.get_spring_constant_in_femto_newtons_per_angstrom(k_in_kcal_per_mol_per_angstrom_square)

_IMP_atom.IMP_ATOM_DEFAULT_BD_RANDOM_POOL_SIZE_swigconstant(_IMP_atom)
IMP_ATOM_DEFAULT_BD_RANDOM_POOL_SIZE = _IMP_atom.IMP_ATOM_DEFAULT_BD_RANDOM_POOL_SIZE
class BrownianDynamics(Simulator):
    """Proxy of C++ IMP::atom::BrownianDynamics 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::atom::BrownianDynamics self, Model m, std::string name, double wave_factor=1.0, unsigned int random_pool_size=500) -> BrownianDynamics
        __init__(IMP::atom::BrownianDynamics self, Model m, std::string name, double wave_factor=1.0) -> BrownianDynamics
        __init__(IMP::atom::BrownianDynamics self, Model m, std::string name) -> BrownianDynamics
        __init__(IMP::atom::BrownianDynamics self, Model m) -> BrownianDynamics
        """
        this = _IMP_atom.new_BrownianDynamics(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_maximum_move(self, ms):
        """set_maximum_move(BrownianDynamics self, double ms)"""
        return _IMP_atom.BrownianDynamics_set_maximum_move(self, ms)


    def set_use_stochastic_runge_kutta(self, tf):
        """set_use_stochastic_runge_kutta(BrownianDynamics self, bool tf)"""
        return _IMP_atom.BrownianDynamics_set_use_stochastic_runge_kutta(self, tf)


    def get_version_info(self):
        """get_version_info(BrownianDynamics self) -> VersionInfo"""
        return _IMP_atom.BrownianDynamics_get_version_info(self)


    def __str__(self):
        """__str__(BrownianDynamics self) -> std::string"""
        return _IMP_atom.BrownianDynamics___str__(self)


    def __repr__(self):
        """__repr__(BrownianDynamics self) -> std::string"""
        return _IMP_atom.BrownianDynamics___repr__(self)


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

BrownianDynamics_swigregister = _IMP_atom.BrownianDynamics_swigregister
BrownianDynamics_swigregister(BrownianDynamics)


def get_maximum_time_step_estimate(bd):
    """get_maximum_time_step_estimate(BrownianDynamics bd) -> double"""
    return _IMP_atom.get_maximum_time_step_estimate(bd)

def get_harmonic_sigma(D, f):
    """get_harmonic_sigma(double D, double f) -> double"""
    return _IMP_atom.get_harmonic_sigma(D, f)
class BrownianDynamicsTAMD(BrownianDynamics):
    """Proxy of C++ IMP::atom::BrownianDynamicsTAMD 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::atom::BrownianDynamicsTAMD self, Model m, std::string name, double wave_factor=1.0) -> BrownianDynamicsTAMD
        __init__(IMP::atom::BrownianDynamicsTAMD self, Model m, std::string name) -> BrownianDynamicsTAMD
        __init__(IMP::atom::BrownianDynamicsTAMD self, Model m) -> BrownianDynamicsTAMD
        """
        this = _IMP_atom.new_BrownianDynamicsTAMD(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(BrownianDynamicsTAMD self) -> std::string"""
        return _IMP_atom.BrownianDynamicsTAMD___str__(self)


    def __repr__(self):
        """__repr__(BrownianDynamicsTAMD self) -> std::string"""
        return _IMP_atom.BrownianDynamicsTAMD___repr__(self)


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

    __swig_destroy__ = _IMP_atom.delete_BrownianDynamicsTAMD
    __del__ = lambda self: None
BrownianDynamicsTAMD_swigregister = _IMP_atom.BrownianDynamicsTAMD_swigregister
BrownianDynamicsTAMD_swigregister(BrownianDynamicsTAMD)

class Diffusion(IMP.core.XYZ):
    """Proxy of C++ IMP::atom::Diffusion 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::atom::Diffusion self) -> Diffusion
        __init__(IMP::atom::Diffusion self, Model m, ParticleIndex id) -> Diffusion
        __init__(IMP::atom::Diffusion self, _ParticleAdaptor d) -> Diffusion
        """
        this = _IMP_atom.new_Diffusion(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Diffusion self, _ostream out)
        show(Diffusion self)
        """
        return _IMP_atom.Diffusion_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, IMP::Float D) -> Diffusion
        setup_particle(_ParticleAdaptor decorator, IMP::Float D) -> Diffusion
        setup_particle(Model m, ParticleIndex pi, Vector3D v, IMP::Float D) -> Diffusion
        setup_particle(_ParticleAdaptor decorator, Vector3D v, IMP::Float D) -> Diffusion
        setup_particle(Model m, ParticleIndex pi) -> Diffusion
        setup_particle(_ParticleAdaptor decorator) -> Diffusion
        """
        return _IMP_atom.Diffusion_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 p) -> bool
        """
        return _IMP_atom.Diffusion_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def set_diffusion_coefficient(self, d):
        """set_diffusion_coefficient(Diffusion self, double d)"""
        return _IMP_atom.Diffusion_set_diffusion_coefficient(self, d)


    def get_diffusion_coefficient(self):
        """get_diffusion_coefficient(Diffusion self) -> double"""
        return _IMP_atom.Diffusion_get_diffusion_coefficient(self)


    def get_diffusion_coefficient_key():
        """get_diffusion_coefficient_key() -> FloatKey"""
        return _IMP_atom.Diffusion_get_diffusion_coefficient_key()

    get_diffusion_coefficient_key = staticmethod(get_diffusion_coefficient_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Diffusion self, FloatKey a0)
        remove_attribute(Diffusion self, IntKey a0)
        remove_attribute(Diffusion self, StringKey a0)
        remove_attribute(Diffusion self, ParticleIndexKey a0)
        remove_attribute(Diffusion self, ObjectKey a0)
        """
        return _IMP_atom.Diffusion_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Diffusion self, FloatKey a0) -> bool
        has_attribute(Diffusion self, IntKey a0) -> bool
        has_attribute(Diffusion self, StringKey a0) -> bool
        has_attribute(Diffusion self, ParticleIndexKey a0) -> bool
        has_attribute(Diffusion self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Diffusion_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Diffusion self, FloatKey a0) -> double"""
        return _IMP_atom.Diffusion_get_derivative(self, a0)


    def get_name(self):
        """get_name(Diffusion self) -> std::string"""
        return _IMP_atom.Diffusion_get_name(self)


    def clear_caches(self):
        """clear_caches(Diffusion self)"""
        return _IMP_atom.Diffusion_clear_caches(self)


    def set_name(self, a0):
        """set_name(Diffusion self, std::string a0)"""
        return _IMP_atom.Diffusion_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Diffusion self, IMP::CheckLevel a0)"""
        return _IMP_atom.Diffusion_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Diffusion self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Diffusion_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Diffusion self, FloatKey a0, bool a1)"""
        return _IMP_atom.Diffusion_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Diffusion self, FloatKey a0) -> bool"""
        return _IMP_atom.Diffusion_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Diffusion self) -> IMP::CheckLevel"""
        return _IMP_atom.Diffusion_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Diffusion self, Diffusion o) -> bool
        __eq__(Diffusion self, Particle d) -> bool
        """
        return _IMP_atom.Diffusion___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Diffusion self, Diffusion o) -> bool
        __ne__(Diffusion self, Particle d) -> bool
        """
        return _IMP_atom.Diffusion___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Diffusion self, Diffusion o) -> bool
        __le__(Diffusion self, Particle d) -> bool
        """
        return _IMP_atom.Diffusion___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Diffusion self, Diffusion o) -> bool
        __lt__(Diffusion self, Particle d) -> bool
        """
        return _IMP_atom.Diffusion___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Diffusion self, Diffusion o) -> bool
        __ge__(Diffusion self, Particle d) -> bool
        """
        return _IMP_atom.Diffusion___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Diffusion self, Diffusion o) -> bool
        __gt__(Diffusion self, Particle d) -> bool
        """
        return _IMP_atom.Diffusion___gt__(self, *args)


    def __hash__(self):
        """__hash__(Diffusion self) -> std::size_t"""
        return _IMP_atom.Diffusion___hash__(self)


    def __str__(self):
        """__str__(Diffusion self) -> std::string"""
        return _IMP_atom.Diffusion___str__(self)


    def __repr__(self):
        """__repr__(Diffusion self) -> std::string"""
        return _IMP_atom.Diffusion___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Diffusion
    __del__ = lambda self: None
Diffusion_swigregister = _IMP_atom.Diffusion_swigregister
Diffusion_swigregister(Diffusion)

def Diffusion_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, IMP::Float D) -> Diffusion
    setup_particle(_ParticleAdaptor decorator, IMP::Float D) -> Diffusion
    setup_particle(Model m, ParticleIndex pi, Vector3D v, IMP::Float D) -> Diffusion
    setup_particle(_ParticleAdaptor decorator, Vector3D v, IMP::Float D) -> Diffusion
    setup_particle(Model m, ParticleIndex pi) -> Diffusion
    Diffusion_setup_particle(_ParticleAdaptor decorator) -> Diffusion
    """
    return _IMP_atom.Diffusion_setup_particle(*args)

def Diffusion_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Diffusion_get_is_setup(Model m, ParticleIndex p) -> bool
    """
    return _IMP_atom.Diffusion_get_is_setup(*args)

def Diffusion_get_diffusion_coefficient_key():
    """Diffusion_get_diffusion_coefficient_key() -> FloatKey"""
    return _IMP_atom.Diffusion_get_diffusion_coefficient_key()


def get_diffusion_coefficient_from_cm2_per_second(din):
    """get_diffusion_coefficient_from_cm2_per_second(double din) -> double"""
    return _IMP_atom.get_diffusion_coefficient_from_cm2_per_second(din)
class RigidBodyDiffusion(Diffusion):
    """Proxy of C++ IMP::atom::RigidBodyDiffusion 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::atom::RigidBodyDiffusion self) -> RigidBodyDiffusion
        __init__(IMP::atom::RigidBodyDiffusion self, Model m, ParticleIndex id) -> RigidBodyDiffusion
        __init__(IMP::atom::RigidBodyDiffusion self, _ParticleAdaptor d) -> RigidBodyDiffusion
        """
        this = _IMP_atom.new_RigidBodyDiffusion(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(RigidBodyDiffusion self, _ostream out)
        show(RigidBodyDiffusion self)
        """
        return _IMP_atom.RigidBodyDiffusion_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> RigidBodyDiffusion
        setup_particle(_ParticleAdaptor decorator) -> RigidBodyDiffusion
        """
        return _IMP_atom.RigidBodyDiffusion_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_rotational_diffusion_coefficient(self):
        """get_rotational_diffusion_coefficient(RigidBodyDiffusion self) -> double"""
        return _IMP_atom.RigidBodyDiffusion_get_rotational_diffusion_coefficient(self)


    def set_rotational_diffusion_coefficient(self, d):
        """set_rotational_diffusion_coefficient(RigidBodyDiffusion self, double d)"""
        return _IMP_atom.RigidBodyDiffusion_set_rotational_diffusion_coefficient(self, d)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex p) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_rotational_diffusion_coefficient_key():
        """get_rotational_diffusion_coefficient_key() -> FloatKey"""
        return _IMP_atom.RigidBodyDiffusion_get_rotational_diffusion_coefficient_key()

    get_rotational_diffusion_coefficient_key = staticmethod(get_rotational_diffusion_coefficient_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(RigidBodyDiffusion self, FloatKey a0)
        remove_attribute(RigidBodyDiffusion self, IntKey a0)
        remove_attribute(RigidBodyDiffusion self, StringKey a0)
        remove_attribute(RigidBodyDiffusion self, ParticleIndexKey a0)
        remove_attribute(RigidBodyDiffusion self, ObjectKey a0)
        """
        return _IMP_atom.RigidBodyDiffusion_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(RigidBodyDiffusion self, FloatKey a0) -> bool
        has_attribute(RigidBodyDiffusion self, IntKey a0) -> bool
        has_attribute(RigidBodyDiffusion self, StringKey a0) -> bool
        has_attribute(RigidBodyDiffusion self, ParticleIndexKey a0) -> bool
        has_attribute(RigidBodyDiffusion self, ObjectKey a0) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(RigidBodyDiffusion self, FloatKey a0) -> double"""
        return _IMP_atom.RigidBodyDiffusion_get_derivative(self, a0)


    def get_name(self):
        """get_name(RigidBodyDiffusion self) -> std::string"""
        return _IMP_atom.RigidBodyDiffusion_get_name(self)


    def clear_caches(self):
        """clear_caches(RigidBodyDiffusion self)"""
        return _IMP_atom.RigidBodyDiffusion_clear_caches(self)


    def set_name(self, a0):
        """set_name(RigidBodyDiffusion self, std::string a0)"""
        return _IMP_atom.RigidBodyDiffusion_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(RigidBodyDiffusion self, IMP::CheckLevel a0)"""
        return _IMP_atom.RigidBodyDiffusion_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(RigidBodyDiffusion self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.RigidBodyDiffusion_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(RigidBodyDiffusion self, FloatKey a0, bool a1)"""
        return _IMP_atom.RigidBodyDiffusion_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(RigidBodyDiffusion self, FloatKey a0) -> bool"""
        return _IMP_atom.RigidBodyDiffusion_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(RigidBodyDiffusion self) -> IMP::CheckLevel"""
        return _IMP_atom.RigidBodyDiffusion_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(RigidBodyDiffusion self, RigidBodyDiffusion o) -> bool
        __eq__(RigidBodyDiffusion self, Particle d) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(RigidBodyDiffusion self, RigidBodyDiffusion o) -> bool
        __ne__(RigidBodyDiffusion self, Particle d) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(RigidBodyDiffusion self, RigidBodyDiffusion o) -> bool
        __le__(RigidBodyDiffusion self, Particle d) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(RigidBodyDiffusion self, RigidBodyDiffusion o) -> bool
        __lt__(RigidBodyDiffusion self, Particle d) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(RigidBodyDiffusion self, RigidBodyDiffusion o) -> bool
        __ge__(RigidBodyDiffusion self, Particle d) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(RigidBodyDiffusion self, RigidBodyDiffusion o) -> bool
        __gt__(RigidBodyDiffusion self, Particle d) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion___gt__(self, *args)


    def __hash__(self):
        """__hash__(RigidBodyDiffusion self) -> std::size_t"""
        return _IMP_atom.RigidBodyDiffusion___hash__(self)


    def __str__(self):
        """__str__(RigidBodyDiffusion self) -> std::string"""
        return _IMP_atom.RigidBodyDiffusion___str__(self)


    def __repr__(self):
        """__repr__(RigidBodyDiffusion self) -> std::string"""
        return _IMP_atom.RigidBodyDiffusion___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_RigidBodyDiffusion
    __del__ = lambda self: None
RigidBodyDiffusion_swigregister = _IMP_atom.RigidBodyDiffusion_swigregister
RigidBodyDiffusion_swigregister(RigidBodyDiffusion)

def RigidBodyDiffusion_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> RigidBodyDiffusion
    RigidBodyDiffusion_setup_particle(_ParticleAdaptor decorator) -> RigidBodyDiffusion
    """
    return _IMP_atom.RigidBodyDiffusion_setup_particle(*args)

def RigidBodyDiffusion_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    RigidBodyDiffusion_get_is_setup(Model m, ParticleIndex p) -> bool
    """
    return _IMP_atom.RigidBodyDiffusion_get_is_setup(*args)

def RigidBodyDiffusion_get_rotational_diffusion_coefficient_key():
    """RigidBodyDiffusion_get_rotational_diffusion_coefficient_key() -> FloatKey"""
    return _IMP_atom.RigidBodyDiffusion_get_rotational_diffusion_coefficient_key()

class TAMDParticle(IMP.Decorator):
    """Proxy of C++ IMP::atom::TAMDParticle 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::atom::TAMDParticle self) -> TAMDParticle
        __init__(IMP::atom::TAMDParticle self, Model m, ParticleIndex id) -> TAMDParticle
        __init__(IMP::atom::TAMDParticle self, _ParticleAdaptor d) -> TAMDParticle
        """
        this = _IMP_atom.new_TAMDParticle(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(TAMDParticle self, _ostream out)
        show(TAMDParticle self)
        """
        return _IMP_atom.TAMDParticle_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, ParticleIndex pi_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
        setup_particle(_ParticleAdaptor decorator, ParticleIndex pi_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
        setup_particle(Model m, ParticleIndex pi, Particle p_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
        setup_particle(_ParticleAdaptor decorator, Particle p_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
        """
        return _IMP_atom.TAMDParticle_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 p) -> bool
        """
        return _IMP_atom.TAMDParticle_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_reference_particle_index(self):
        """get_reference_particle_index(TAMDParticle self) -> ParticleIndex"""
        return _IMP_atom.TAMDParticle_get_reference_particle_index(self)


    def set_temperature_scale_factor(self, tsf):
        """set_temperature_scale_factor(TAMDParticle self, float tsf)"""
        return _IMP_atom.TAMDParticle_set_temperature_scale_factor(self, tsf)


    def get_temperature_scale_factor(self):
        """get_temperature_scale_factor(TAMDParticle self) -> double"""
        return _IMP_atom.TAMDParticle_get_temperature_scale_factor(self)


    def set_friction_scale_factor(self, tsf):
        """set_friction_scale_factor(TAMDParticle self, float tsf)"""
        return _IMP_atom.TAMDParticle_set_friction_scale_factor(self, tsf)


    def get_friction_scale_factor(self):
        """get_friction_scale_factor(TAMDParticle self) -> double"""
        return _IMP_atom.TAMDParticle_get_friction_scale_factor(self)


    def update_coordinates_from_ref(self):
        """update_coordinates_from_ref(TAMDParticle self)"""
        return _IMP_atom.TAMDParticle_update_coordinates_from_ref(self)


    def get_temperature_scale_factor_key():
        """get_temperature_scale_factor_key() -> FloatKey"""
        return _IMP_atom.TAMDParticle_get_temperature_scale_factor_key()

    get_temperature_scale_factor_key = staticmethod(get_temperature_scale_factor_key)

    def get_friction_scale_factor_key():
        """get_friction_scale_factor_key() -> FloatKey"""
        return _IMP_atom.TAMDParticle_get_friction_scale_factor_key()

    get_friction_scale_factor_key = staticmethod(get_friction_scale_factor_key)

    def get_reference_particle_index_key():
        """get_reference_particle_index_key() -> ParticleIndexKey"""
        return _IMP_atom.TAMDParticle_get_reference_particle_index_key()

    get_reference_particle_index_key = staticmethod(get_reference_particle_index_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(TAMDParticle self, FloatKey a0)
        remove_attribute(TAMDParticle self, IntKey a0)
        remove_attribute(TAMDParticle self, StringKey a0)
        remove_attribute(TAMDParticle self, ParticleIndexKey a0)
        remove_attribute(TAMDParticle self, ObjectKey a0)
        """
        return _IMP_atom.TAMDParticle_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(TAMDParticle self, FloatKey a0) -> bool
        has_attribute(TAMDParticle self, IntKey a0) -> bool
        has_attribute(TAMDParticle self, StringKey a0) -> bool
        has_attribute(TAMDParticle self, ParticleIndexKey a0) -> bool
        has_attribute(TAMDParticle self, ObjectKey a0) -> bool
        """
        return _IMP_atom.TAMDParticle_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(TAMDParticle self, FloatKey a0) -> double"""
        return _IMP_atom.TAMDParticle_get_derivative(self, a0)


    def get_name(self):
        """get_name(TAMDParticle self) -> std::string"""
        return _IMP_atom.TAMDParticle_get_name(self)


    def clear_caches(self):
        """clear_caches(TAMDParticle self)"""
        return _IMP_atom.TAMDParticle_clear_caches(self)


    def set_name(self, a0):
        """set_name(TAMDParticle self, std::string a0)"""
        return _IMP_atom.TAMDParticle_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(TAMDParticle self, IMP::CheckLevel a0)"""
        return _IMP_atom.TAMDParticle_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(TAMDParticle self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.TAMDParticle_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(TAMDParticle self, FloatKey a0, bool a1)"""
        return _IMP_atom.TAMDParticle_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(TAMDParticle self, FloatKey a0) -> bool"""
        return _IMP_atom.TAMDParticle_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(TAMDParticle self) -> IMP::CheckLevel"""
        return _IMP_atom.TAMDParticle_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(TAMDParticle self, TAMDParticle o) -> bool
        __eq__(TAMDParticle self, Particle d) -> bool
        """
        return _IMP_atom.TAMDParticle___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(TAMDParticle self, TAMDParticle o) -> bool
        __ne__(TAMDParticle self, Particle d) -> bool
        """
        return _IMP_atom.TAMDParticle___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(TAMDParticle self, TAMDParticle o) -> bool
        __le__(TAMDParticle self, Particle d) -> bool
        """
        return _IMP_atom.TAMDParticle___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(TAMDParticle self, TAMDParticle o) -> bool
        __lt__(TAMDParticle self, Particle d) -> bool
        """
        return _IMP_atom.TAMDParticle___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(TAMDParticle self, TAMDParticle o) -> bool
        __ge__(TAMDParticle self, Particle d) -> bool
        """
        return _IMP_atom.TAMDParticle___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(TAMDParticle self, TAMDParticle o) -> bool
        __gt__(TAMDParticle self, Particle d) -> bool
        """
        return _IMP_atom.TAMDParticle___gt__(self, *args)


    def __hash__(self):
        """__hash__(TAMDParticle self) -> std::size_t"""
        return _IMP_atom.TAMDParticle___hash__(self)


    def __str__(self):
        """__str__(TAMDParticle self) -> std::string"""
        return _IMP_atom.TAMDParticle___str__(self)


    def __repr__(self):
        """__repr__(TAMDParticle self) -> std::string"""
        return _IMP_atom.TAMDParticle___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_TAMDParticle
    __del__ = lambda self: None
TAMDParticle_swigregister = _IMP_atom.TAMDParticle_swigregister
TAMDParticle_swigregister(TAMDParticle)

def TAMDParticle_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, ParticleIndex pi_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
    setup_particle(_ParticleAdaptor decorator, ParticleIndex pi_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
    setup_particle(Model m, ParticleIndex pi, Particle p_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
    TAMDParticle_setup_particle(_ParticleAdaptor decorator, Particle p_ref, IMP::Float tsf, IMP::Float fsf) -> TAMDParticle
    """
    return _IMP_atom.TAMDParticle_setup_particle(*args)

def TAMDParticle_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    TAMDParticle_get_is_setup(Model m, ParticleIndex p) -> bool
    """
    return _IMP_atom.TAMDParticle_get_is_setup(*args)

def TAMDParticle_get_temperature_scale_factor_key():
    """TAMDParticle_get_temperature_scale_factor_key() -> FloatKey"""
    return _IMP_atom.TAMDParticle_get_temperature_scale_factor_key()

def TAMDParticle_get_friction_scale_factor_key():
    """TAMDParticle_get_friction_scale_factor_key() -> FloatKey"""
    return _IMP_atom.TAMDParticle_get_friction_scale_factor_key()

def TAMDParticle_get_reference_particle_index_key():
    """TAMDParticle_get_reference_particle_index_key() -> ParticleIndexKey"""
    return _IMP_atom.TAMDParticle_get_reference_particle_index_key()

class Chain(Hierarchy):
    """Proxy of C++ IMP::atom::Chain 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::atom::Chain self) -> Chain
        __init__(IMP::atom::Chain self, Model m, ParticleIndex id) -> Chain
        __init__(IMP::atom::Chain self, _ParticleAdaptor d) -> Chain
        """
        this = _IMP_atom.new_Chain(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Chain self, _ostream out)
        show(Chain self)
        """
        return _IMP_atom.Chain_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, std::string id) -> Chain
        setup_particle(_ParticleAdaptor decorator, std::string id) -> Chain
        setup_particle(Model m, ParticleIndex pi, char id) -> Chain
        setup_particle(_ParticleAdaptor decorator, char id) -> Chain
        setup_particle(Model m, ParticleIndex pi, Chain other) -> Chain
        setup_particle(_ParticleAdaptor decorator, Chain other) -> Chain
        """
        return _IMP_atom.Chain_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_atom.Chain_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_id(self):
        """get_id(Chain self) -> std::string"""
        return _IMP_atom.Chain_get_id(self)


    def set_id(self, c):
        """set_id(Chain self, std::string c)"""
        return _IMP_atom.Chain_set_id(self, c)


    def get_id_key():
        """get_id_key() -> StringKey"""
        return _IMP_atom.Chain_get_id_key()

    get_id_key = staticmethod(get_id_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Chain self, FloatKey a0)
        remove_attribute(Chain self, IntKey a0)
        remove_attribute(Chain self, StringKey a0)
        remove_attribute(Chain self, ParticleIndexKey a0)
        remove_attribute(Chain self, ObjectKey a0)
        """
        return _IMP_atom.Chain_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Chain self, FloatKey a0) -> bool
        has_attribute(Chain self, IntKey a0) -> bool
        has_attribute(Chain self, StringKey a0) -> bool
        has_attribute(Chain self, ParticleIndexKey a0) -> bool
        has_attribute(Chain self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Chain_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Chain self, FloatKey a0) -> double"""
        return _IMP_atom.Chain_get_derivative(self, a0)


    def get_name(self):
        """get_name(Chain self) -> std::string"""
        return _IMP_atom.Chain_get_name(self)


    def clear_caches(self):
        """clear_caches(Chain self)"""
        return _IMP_atom.Chain_clear_caches(self)


    def set_name(self, a0):
        """set_name(Chain self, std::string a0)"""
        return _IMP_atom.Chain_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Chain self, IMP::CheckLevel a0)"""
        return _IMP_atom.Chain_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Chain self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Chain_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Chain self, FloatKey a0, bool a1)"""
        return _IMP_atom.Chain_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Chain self, FloatKey a0) -> bool"""
        return _IMP_atom.Chain_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Chain self) -> IMP::CheckLevel"""
        return _IMP_atom.Chain_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Chain self, Chain o) -> bool
        __eq__(Chain self, Particle d) -> bool
        """
        return _IMP_atom.Chain___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Chain self, Chain o) -> bool
        __ne__(Chain self, Particle d) -> bool
        """
        return _IMP_atom.Chain___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Chain self, Chain o) -> bool
        __le__(Chain self, Particle d) -> bool
        """
        return _IMP_atom.Chain___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Chain self, Chain o) -> bool
        __lt__(Chain self, Particle d) -> bool
        """
        return _IMP_atom.Chain___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Chain self, Chain o) -> bool
        __ge__(Chain self, Particle d) -> bool
        """
        return _IMP_atom.Chain___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Chain self, Chain o) -> bool
        __gt__(Chain self, Particle d) -> bool
        """
        return _IMP_atom.Chain___gt__(self, *args)


    def __hash__(self):
        """__hash__(Chain self) -> std::size_t"""
        return _IMP_atom.Chain___hash__(self)


    def __str__(self):
        """__str__(Chain self) -> std::string"""
        return _IMP_atom.Chain___str__(self)


    def __repr__(self):
        """__repr__(Chain self) -> std::string"""
        return _IMP_atom.Chain___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Chain
    __del__ = lambda self: None
Chain_swigregister = _IMP_atom.Chain_swigregister
Chain_swigregister(Chain)

def Chain_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, std::string id) -> Chain
    setup_particle(_ParticleAdaptor decorator, std::string id) -> Chain
    setup_particle(Model m, ParticleIndex pi, char id) -> Chain
    setup_particle(_ParticleAdaptor decorator, char id) -> Chain
    setup_particle(Model m, ParticleIndex pi, Chain other) -> Chain
    Chain_setup_particle(_ParticleAdaptor decorator, Chain other) -> Chain
    """
    return _IMP_atom.Chain_setup_particle(*args)

def Chain_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Chain_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Chain_get_is_setup(*args)

def Chain_get_id_key():
    """Chain_get_id_key() -> StringKey"""
    return _IMP_atom.Chain_get_id_key()


def get_chain(h):
    """get_chain(Hierarchy h) -> Chain"""
    return _IMP_atom.get_chain(h)

def get_chain_id(h):
    """get_chain_id(Hierarchy h) -> std::string"""
    return _IMP_atom.get_chain_id(h)
class Charged(IMP.core.XYZ):
    """Proxy of C++ IMP::atom::Charged 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::atom::Charged self) -> Charged
        __init__(IMP::atom::Charged self, Model m, ParticleIndex id) -> Charged
        __init__(IMP::atom::Charged self, _ParticleAdaptor d) -> Charged
        """
        this = _IMP_atom.new_Charged(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Charged self, _ostream out)
        show(Charged self)
        """
        return _IMP_atom.Charged_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, IMP::Float charge) -> Charged
        setup_particle(_ParticleAdaptor decorator, IMP::Float charge) -> Charged
        setup_particle(Model m, ParticleIndex pi, Vector3D v, IMP::Float charge) -> Charged
        setup_particle(_ParticleAdaptor decorator, Vector3D v, IMP::Float charge) -> Charged
        """
        return _IMP_atom.Charged_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_charge(self):
        """get_charge(Charged self) -> IMP::Float"""
        return _IMP_atom.Charged_get_charge(self)


    def set_charge(self, t):
        """set_charge(Charged self, IMP::Float t)"""
        return _IMP_atom.Charged_set_charge(self, t)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_atom.Charged_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_charge_key():
        """get_charge_key() -> FloatKey"""
        return _IMP_atom.Charged_get_charge_key()

    get_charge_key = staticmethod(get_charge_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Charged self, FloatKey a0)
        remove_attribute(Charged self, IntKey a0)
        remove_attribute(Charged self, StringKey a0)
        remove_attribute(Charged self, ParticleIndexKey a0)
        remove_attribute(Charged self, ObjectKey a0)
        """
        return _IMP_atom.Charged_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Charged self, FloatKey a0) -> bool
        has_attribute(Charged self, IntKey a0) -> bool
        has_attribute(Charged self, StringKey a0) -> bool
        has_attribute(Charged self, ParticleIndexKey a0) -> bool
        has_attribute(Charged self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Charged_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Charged self, FloatKey a0) -> double"""
        return _IMP_atom.Charged_get_derivative(self, a0)


    def get_name(self):
        """get_name(Charged self) -> std::string"""
        return _IMP_atom.Charged_get_name(self)


    def clear_caches(self):
        """clear_caches(Charged self)"""
        return _IMP_atom.Charged_clear_caches(self)


    def set_name(self, a0):
        """set_name(Charged self, std::string a0)"""
        return _IMP_atom.Charged_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Charged self, IMP::CheckLevel a0)"""
        return _IMP_atom.Charged_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Charged self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Charged_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Charged self, FloatKey a0, bool a1)"""
        return _IMP_atom.Charged_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Charged self, FloatKey a0) -> bool"""
        return _IMP_atom.Charged_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Charged self) -> IMP::CheckLevel"""
        return _IMP_atom.Charged_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Charged self, Charged o) -> bool
        __eq__(Charged self, Particle d) -> bool
        """
        return _IMP_atom.Charged___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Charged self, Charged o) -> bool
        __ne__(Charged self, Particle d) -> bool
        """
        return _IMP_atom.Charged___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Charged self, Charged o) -> bool
        __le__(Charged self, Particle d) -> bool
        """
        return _IMP_atom.Charged___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Charged self, Charged o) -> bool
        __lt__(Charged self, Particle d) -> bool
        """
        return _IMP_atom.Charged___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Charged self, Charged o) -> bool
        __ge__(Charged self, Particle d) -> bool
        """
        return _IMP_atom.Charged___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Charged self, Charged o) -> bool
        __gt__(Charged self, Particle d) -> bool
        """
        return _IMP_atom.Charged___gt__(self, *args)


    def __hash__(self):
        """__hash__(Charged self) -> std::size_t"""
        return _IMP_atom.Charged___hash__(self)


    def __str__(self):
        """__str__(Charged self) -> std::string"""
        return _IMP_atom.Charged___str__(self)


    def __repr__(self):
        """__repr__(Charged self) -> std::string"""
        return _IMP_atom.Charged___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Charged
    __del__ = lambda self: None
Charged_swigregister = _IMP_atom.Charged_swigregister
Charged_swigregister(Charged)

def Charged_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, IMP::Float charge) -> Charged
    setup_particle(_ParticleAdaptor decorator, IMP::Float charge) -> Charged
    setup_particle(Model m, ParticleIndex pi, Vector3D v, IMP::Float charge) -> Charged
    Charged_setup_particle(_ParticleAdaptor decorator, Vector3D v, IMP::Float charge) -> Charged
    """
    return _IMP_atom.Charged_setup_particle(*args)

def Charged_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Charged_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Charged_get_is_setup(*args)

def Charged_get_charge_key():
    """Charged_get_charge_key() -> FloatKey"""
    return _IMP_atom.Charged_get_charge_key()

class CoulombPairScore(IMP.PairScore):
    """Proxy of C++ IMP::atom::CoulombPairScore class."""

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

    def __init__(self, f):
        """__init__(IMP::atom::CoulombPairScore self, SmoothingFunction f) -> CoulombPairScore"""
        this = _IMP_atom.new_CoulombPairScore(f)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_relative_dielectric(self, relative_dielectric):
        """set_relative_dielectric(CoulombPairScore self, double relative_dielectric)"""
        return _IMP_atom.CoulombPairScore_set_relative_dielectric(self, relative_dielectric)


    def get_relative_dielectric(self):
        """get_relative_dielectric(CoulombPairScore self) -> double"""
        return _IMP_atom.CoulombPairScore_get_relative_dielectric(self)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(CoulombPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.CoulombPairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(CoulombPairScore self) -> VersionInfo"""
        return _IMP_atom.CoulombPairScore_get_version_info(self)


    def __str__(self):
        """__str__(CoulombPairScore self) -> std::string"""
        return _IMP_atom.CoulombPairScore___str__(self)


    def __repr__(self):
        """__repr__(CoulombPairScore self) -> std::string"""
        return _IMP_atom.CoulombPairScore___repr__(self)


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

CoulombPairScore_swigregister = _IMP_atom.CoulombPairScore_swigregister
CoulombPairScore_swigregister(CoulombPairScore)

class Domain(Hierarchy):
    """Proxy of C++ IMP::atom::Domain class."""

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

    def set_index_range(self, ir):
        """set_index_range(Domain self, IMP::IntRange ir)"""
        return _IMP_atom.Domain_set_index_range(self, ir)


    def get_index_range(self):
        """get_index_range(Domain self) -> IMP::IntRange"""
        return _IMP_atom.Domain_get_index_range(self)


    def __init__(self, *args):
        """
        __init__(IMP::atom::Domain self) -> Domain
        __init__(IMP::atom::Domain self, Model m, ParticleIndex id) -> Domain
        __init__(IMP::atom::Domain self, _ParticleAdaptor d) -> Domain
        """
        this = _IMP_atom.new_Domain(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_is_setup(*args):
        """
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_atom.Domain_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(Domain self, _ostream out)
        show(Domain self)
        """
        return _IMP_atom.Domain_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, Domain other) -> Domain
        setup_particle(_ParticleAdaptor decorator, Domain other) -> Domain
        setup_particle(Model m, ParticleIndex pi, IMP::IntRange residues) -> Domain
        setup_particle(_ParticleAdaptor decorator, IMP::IntRange residues) -> Domain
        """
        return _IMP_atom.Domain_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Domain self, FloatKey a0)
        remove_attribute(Domain self, IntKey a0)
        remove_attribute(Domain self, StringKey a0)
        remove_attribute(Domain self, ParticleIndexKey a0)
        remove_attribute(Domain self, ObjectKey a0)
        """
        return _IMP_atom.Domain_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Domain self, FloatKey a0) -> bool
        has_attribute(Domain self, IntKey a0) -> bool
        has_attribute(Domain self, StringKey a0) -> bool
        has_attribute(Domain self, ParticleIndexKey a0) -> bool
        has_attribute(Domain self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Domain_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Domain self, FloatKey a0) -> double"""
        return _IMP_atom.Domain_get_derivative(self, a0)


    def get_name(self):
        """get_name(Domain self) -> std::string"""
        return _IMP_atom.Domain_get_name(self)


    def clear_caches(self):
        """clear_caches(Domain self)"""
        return _IMP_atom.Domain_clear_caches(self)


    def set_name(self, a0):
        """set_name(Domain self, std::string a0)"""
        return _IMP_atom.Domain_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Domain self, IMP::CheckLevel a0)"""
        return _IMP_atom.Domain_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Domain self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Domain_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Domain self, FloatKey a0, bool a1)"""
        return _IMP_atom.Domain_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Domain self, FloatKey a0) -> bool"""
        return _IMP_atom.Domain_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Domain self) -> IMP::CheckLevel"""
        return _IMP_atom.Domain_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Domain self, Domain o) -> bool
        __eq__(Domain self, Particle d) -> bool
        """
        return _IMP_atom.Domain___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Domain self, Domain o) -> bool
        __ne__(Domain self, Particle d) -> bool
        """
        return _IMP_atom.Domain___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Domain self, Domain o) -> bool
        __le__(Domain self, Particle d) -> bool
        """
        return _IMP_atom.Domain___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Domain self, Domain o) -> bool
        __lt__(Domain self, Particle d) -> bool
        """
        return _IMP_atom.Domain___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Domain self, Domain o) -> bool
        __ge__(Domain self, Particle d) -> bool
        """
        return _IMP_atom.Domain___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Domain self, Domain o) -> bool
        __gt__(Domain self, Particle d) -> bool
        """
        return _IMP_atom.Domain___gt__(self, *args)


    def __hash__(self):
        """__hash__(Domain self) -> std::size_t"""
        return _IMP_atom.Domain___hash__(self)


    def __str__(self):
        """__str__(Domain self) -> std::string"""
        return _IMP_atom.Domain___str__(self)


    def __repr__(self):
        """__repr__(Domain self) -> std::string"""
        return _IMP_atom.Domain___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Domain
    __del__ = lambda self: None
Domain_swigregister = _IMP_atom.Domain_swigregister
Domain_swigregister(Domain)

def Domain_get_is_setup(*args):
    """
    get_is_setup(Model m, ParticleIndex pi) -> bool
    Domain_get_is_setup(_ParticleAdaptor p) -> bool
    """
    return _IMP_atom.Domain_get_is_setup(*args)

def Domain_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, Domain other) -> Domain
    setup_particle(_ParticleAdaptor decorator, Domain other) -> Domain
    setup_particle(Model m, ParticleIndex pi, IMP::IntRange residues) -> Domain
    Domain_setup_particle(_ParticleAdaptor decorator, IMP::IntRange residues) -> Domain
    """
    return _IMP_atom.Domain_setup_particle(*args)

class LennardJones(IMP.core.XYZR):
    """Proxy of C++ IMP::atom::LennardJones 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::atom::LennardJones self) -> LennardJones
        __init__(IMP::atom::LennardJones self, Model m, ParticleIndex id) -> LennardJones
        __init__(IMP::atom::LennardJones self, _ParticleAdaptor d) -> LennardJones
        """
        this = _IMP_atom.new_LennardJones(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(LennardJones self, _ostream out)
        show(LennardJones self)
        """
        return _IMP_atom.LennardJones_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> LennardJones
        setup_particle(_ParticleAdaptor decorator) -> LennardJones
        setup_particle(Model m, ParticleIndex pi, IMP::Float well_depth) -> LennardJones
        setup_particle(_ParticleAdaptor decorator, IMP::Float well_depth) -> LennardJones
        """
        return _IMP_atom.LennardJones_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_well_depth(self):
        """get_well_depth(LennardJones self) -> IMP::Float"""
        return _IMP_atom.LennardJones_get_well_depth(self)


    def set_well_depth(self, well_depth):
        """set_well_depth(LennardJones self, IMP::Float well_depth)"""
        return _IMP_atom.LennardJones_set_well_depth(self, well_depth)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_atom.LennardJones_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_well_depth_key():
        """get_well_depth_key() -> FloatKey"""
        return _IMP_atom.LennardJones_get_well_depth_key()

    get_well_depth_key = staticmethod(get_well_depth_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(LennardJones self, FloatKey a0)
        remove_attribute(LennardJones self, IntKey a0)
        remove_attribute(LennardJones self, StringKey a0)
        remove_attribute(LennardJones self, ParticleIndexKey a0)
        remove_attribute(LennardJones self, ObjectKey a0)
        """
        return _IMP_atom.LennardJones_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(LennardJones self, FloatKey a0) -> bool
        has_attribute(LennardJones self, IntKey a0) -> bool
        has_attribute(LennardJones self, StringKey a0) -> bool
        has_attribute(LennardJones self, ParticleIndexKey a0) -> bool
        has_attribute(LennardJones self, ObjectKey a0) -> bool
        """
        return _IMP_atom.LennardJones_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(LennardJones self, FloatKey a0) -> double"""
        return _IMP_atom.LennardJones_get_derivative(self, a0)


    def get_name(self):
        """get_name(LennardJones self) -> std::string"""
        return _IMP_atom.LennardJones_get_name(self)


    def clear_caches(self):
        """clear_caches(LennardJones self)"""
        return _IMP_atom.LennardJones_clear_caches(self)


    def set_name(self, a0):
        """set_name(LennardJones self, std::string a0)"""
        return _IMP_atom.LennardJones_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(LennardJones self, IMP::CheckLevel a0)"""
        return _IMP_atom.LennardJones_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(LennardJones self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.LennardJones_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(LennardJones self, FloatKey a0, bool a1)"""
        return _IMP_atom.LennardJones_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(LennardJones self, FloatKey a0) -> bool"""
        return _IMP_atom.LennardJones_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(LennardJones self) -> IMP::CheckLevel"""
        return _IMP_atom.LennardJones_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(LennardJones self, LennardJones o) -> bool
        __eq__(LennardJones self, Particle d) -> bool
        """
        return _IMP_atom.LennardJones___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(LennardJones self, LennardJones o) -> bool
        __ne__(LennardJones self, Particle d) -> bool
        """
        return _IMP_atom.LennardJones___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(LennardJones self, LennardJones o) -> bool
        __le__(LennardJones self, Particle d) -> bool
        """
        return _IMP_atom.LennardJones___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(LennardJones self, LennardJones o) -> bool
        __lt__(LennardJones self, Particle d) -> bool
        """
        return _IMP_atom.LennardJones___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(LennardJones self, LennardJones o) -> bool
        __ge__(LennardJones self, Particle d) -> bool
        """
        return _IMP_atom.LennardJones___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(LennardJones self, LennardJones o) -> bool
        __gt__(LennardJones self, Particle d) -> bool
        """
        return _IMP_atom.LennardJones___gt__(self, *args)


    def __hash__(self):
        """__hash__(LennardJones self) -> std::size_t"""
        return _IMP_atom.LennardJones___hash__(self)


    def __str__(self):
        """__str__(LennardJones self) -> std::string"""
        return _IMP_atom.LennardJones___str__(self)


    def __repr__(self):
        """__repr__(LennardJones self) -> std::string"""
        return _IMP_atom.LennardJones___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_LennardJones
    __del__ = lambda self: None
LennardJones_swigregister = _IMP_atom.LennardJones_swigregister
LennardJones_swigregister(LennardJones)

def LennardJones_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> LennardJones
    setup_particle(_ParticleAdaptor decorator) -> LennardJones
    setup_particle(Model m, ParticleIndex pi, IMP::Float well_depth) -> LennardJones
    LennardJones_setup_particle(_ParticleAdaptor decorator, IMP::Float well_depth) -> LennardJones
    """
    return _IMP_atom.LennardJones_setup_particle(*args)

def LennardJones_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    LennardJones_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.LennardJones_get_is_setup(*args)

def LennardJones_get_well_depth_key():
    """LennardJones_get_well_depth_key() -> FloatKey"""
    return _IMP_atom.LennardJones_get_well_depth_key()

class LennardJonesPairScore(IMP.PairScore):
    """Proxy of C++ IMP::atom::LennardJonesPairScore class."""

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

    def __init__(self, f):
        """__init__(IMP::atom::LennardJonesPairScore self, SmoothingFunction f) -> LennardJonesPairScore"""
        this = _IMP_atom.new_LennardJonesPairScore(f)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_repulsive_weight(self, repulsive_weight):
        """set_repulsive_weight(LennardJonesPairScore self, double repulsive_weight)"""
        return _IMP_atom.LennardJonesPairScore_set_repulsive_weight(self, repulsive_weight)


    def get_repulsive_weight(self):
        """get_repulsive_weight(LennardJonesPairScore self) -> double"""
        return _IMP_atom.LennardJonesPairScore_get_repulsive_weight(self)


    def set_attractive_weight(self, attractive_weight):
        """set_attractive_weight(LennardJonesPairScore self, double attractive_weight)"""
        return _IMP_atom.LennardJonesPairScore_set_attractive_weight(self, attractive_weight)


    def get_attractive_weight(self):
        """get_attractive_weight(LennardJonesPairScore self) -> double"""
        return _IMP_atom.LennardJonesPairScore_get_attractive_weight(self)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(LennardJonesPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.LennardJonesPairScore_do_get_inputs(self, m, pis)


    def get_version_info(self):
        """get_version_info(LennardJonesPairScore self) -> VersionInfo"""
        return _IMP_atom.LennardJonesPairScore_get_version_info(self)


    def __str__(self):
        """__str__(LennardJonesPairScore self) -> std::string"""
        return _IMP_atom.LennardJonesPairScore___str__(self)


    def __repr__(self):
        """__repr__(LennardJonesPairScore self) -> std::string"""
        return _IMP_atom.LennardJonesPairScore___repr__(self)


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

LennardJonesPairScore_swigregister = _IMP_atom.LennardJonesPairScore_swigregister
LennardJonesPairScore_swigregister(LennardJonesPairScore)

class LinearVelocity(IMP.Decorator):
    """Proxy of C++ IMP::atom::LinearVelocity class."""

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

    def get_velocity_key(i):
        """get_velocity_key(unsigned int i) -> FloatKey"""
        return _IMP_atom.LinearVelocity_get_velocity_key(i)

    get_velocity_key = staticmethod(get_velocity_key)

    def __init__(self, *args):
        """
        __init__(IMP::atom::LinearVelocity self) -> LinearVelocity
        __init__(IMP::atom::LinearVelocity self, Model m, ParticleIndex id) -> LinearVelocity
        __init__(IMP::atom::LinearVelocity self, _ParticleAdaptor d) -> LinearVelocity
        """
        this = _IMP_atom.new_LinearVelocity(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_is_setup(*args):
        """
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_atom.LinearVelocity_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(LinearVelocity self, _ostream out)
        show(LinearVelocity self)
        """
        return _IMP_atom.LinearVelocity_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> LinearVelocity
        setup_particle(_ParticleAdaptor decorator) -> LinearVelocity
        setup_particle(Model m, ParticleIndex pi, Vector3D v) -> LinearVelocity
        setup_particle(_ParticleAdaptor decorator, Vector3D v) -> LinearVelocity
        """
        return _IMP_atom.LinearVelocity_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def set_velocity(self, v):
        """set_velocity(LinearVelocity self, Vector3D v)"""
        return _IMP_atom.LinearVelocity_set_velocity(self, v)


    def get_velocity(self):
        """get_velocity(LinearVelocity self) -> Vector3D"""
        return _IMP_atom.LinearVelocity_get_velocity(self)


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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(LinearVelocity self, FloatKey a0)
        remove_attribute(LinearVelocity self, IntKey a0)
        remove_attribute(LinearVelocity self, StringKey a0)
        remove_attribute(LinearVelocity self, ParticleIndexKey a0)
        remove_attribute(LinearVelocity self, ObjectKey a0)
        """
        return _IMP_atom.LinearVelocity_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(LinearVelocity self, FloatKey a0) -> bool
        has_attribute(LinearVelocity self, IntKey a0) -> bool
        has_attribute(LinearVelocity self, StringKey a0) -> bool
        has_attribute(LinearVelocity self, ParticleIndexKey a0) -> bool
        has_attribute(LinearVelocity self, ObjectKey a0) -> bool
        """
        return _IMP_atom.LinearVelocity_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(LinearVelocity self, FloatKey a0) -> double"""
        return _IMP_atom.LinearVelocity_get_derivative(self, a0)


    def get_name(self):
        """get_name(LinearVelocity self) -> std::string"""
        return _IMP_atom.LinearVelocity_get_name(self)


    def clear_caches(self):
        """clear_caches(LinearVelocity self)"""
        return _IMP_atom.LinearVelocity_clear_caches(self)


    def set_name(self, a0):
        """set_name(LinearVelocity self, std::string a0)"""
        return _IMP_atom.LinearVelocity_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(LinearVelocity self, IMP::CheckLevel a0)"""
        return _IMP_atom.LinearVelocity_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(LinearVelocity self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.LinearVelocity_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(LinearVelocity self, FloatKey a0, bool a1)"""
        return _IMP_atom.LinearVelocity_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(LinearVelocity self, FloatKey a0) -> bool"""
        return _IMP_atom.LinearVelocity_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(LinearVelocity self) -> IMP::CheckLevel"""
        return _IMP_atom.LinearVelocity_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(LinearVelocity self, LinearVelocity o) -> bool
        __eq__(LinearVelocity self, Particle d) -> bool
        """
        return _IMP_atom.LinearVelocity___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(LinearVelocity self, LinearVelocity o) -> bool
        __ne__(LinearVelocity self, Particle d) -> bool
        """
        return _IMP_atom.LinearVelocity___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(LinearVelocity self, LinearVelocity o) -> bool
        __le__(LinearVelocity self, Particle d) -> bool
        """
        return _IMP_atom.LinearVelocity___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(LinearVelocity self, LinearVelocity o) -> bool
        __lt__(LinearVelocity self, Particle d) -> bool
        """
        return _IMP_atom.LinearVelocity___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(LinearVelocity self, LinearVelocity o) -> bool
        __ge__(LinearVelocity self, Particle d) -> bool
        """
        return _IMP_atom.LinearVelocity___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(LinearVelocity self, LinearVelocity o) -> bool
        __gt__(LinearVelocity self, Particle d) -> bool
        """
        return _IMP_atom.LinearVelocity___gt__(self, *args)


    def __hash__(self):
        """__hash__(LinearVelocity self) -> std::size_t"""
        return _IMP_atom.LinearVelocity___hash__(self)


    def __str__(self):
        """__str__(LinearVelocity self) -> std::string"""
        return _IMP_atom.LinearVelocity___str__(self)


    def __repr__(self):
        """__repr__(LinearVelocity self) -> std::string"""
        return _IMP_atom.LinearVelocity___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_LinearVelocity
    __del__ = lambda self: None
LinearVelocity_swigregister = _IMP_atom.LinearVelocity_swigregister
LinearVelocity_swigregister(LinearVelocity)

def LinearVelocity_get_velocity_key(i):
    """LinearVelocity_get_velocity_key(unsigned int i) -> FloatKey"""
    return _IMP_atom.LinearVelocity_get_velocity_key(i)

def LinearVelocity_get_is_setup(*args):
    """
    get_is_setup(Model m, ParticleIndex pi) -> bool
    LinearVelocity_get_is_setup(_ParticleAdaptor p) -> bool
    """
    return _IMP_atom.LinearVelocity_get_is_setup(*args)

def LinearVelocity_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> LinearVelocity
    setup_particle(_ParticleAdaptor decorator) -> LinearVelocity
    setup_particle(Model m, ParticleIndex pi, Vector3D v) -> LinearVelocity
    LinearVelocity_setup_particle(_ParticleAdaptor decorator, Vector3D v) -> LinearVelocity
    """
    return _IMP_atom.LinearVelocity_setup_particle(*args)

class AngularVelocity(IMP.Decorator):
    """Proxy of C++ IMP::atom::AngularVelocity class."""

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

    def get_velocity_key(i):
        """get_velocity_key(unsigned int i) -> FloatKey"""
        return _IMP_atom.AngularVelocity_get_velocity_key(i)

    get_velocity_key = staticmethod(get_velocity_key)

    def __init__(self, *args):
        """
        __init__(IMP::atom::AngularVelocity self) -> AngularVelocity
        __init__(IMP::atom::AngularVelocity self, Model m, ParticleIndex id) -> AngularVelocity
        __init__(IMP::atom::AngularVelocity self, _ParticleAdaptor d) -> AngularVelocity
        """
        this = _IMP_atom.new_AngularVelocity(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_is_setup(*args):
        """
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_atom.AngularVelocity_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(AngularVelocity self, _ostream out)
        show(AngularVelocity self)
        """
        return _IMP_atom.AngularVelocity_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> AngularVelocity
        setup_particle(_ParticleAdaptor decorator) -> AngularVelocity
        setup_particle(Model m, ParticleIndex pi, Vector4D v) -> AngularVelocity
        setup_particle(_ParticleAdaptor decorator, Vector4D v) -> AngularVelocity
        """
        return _IMP_atom.AngularVelocity_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def set_velocity(self, v):
        """set_velocity(AngularVelocity self, Vector4D v)"""
        return _IMP_atom.AngularVelocity_set_velocity(self, v)


    def get_velocity(self):
        """get_velocity(AngularVelocity self) -> Vector4D"""
        return _IMP_atom.AngularVelocity_get_velocity(self)


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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(AngularVelocity self, FloatKey a0)
        remove_attribute(AngularVelocity self, IntKey a0)
        remove_attribute(AngularVelocity self, StringKey a0)
        remove_attribute(AngularVelocity self, ParticleIndexKey a0)
        remove_attribute(AngularVelocity self, ObjectKey a0)
        """
        return _IMP_atom.AngularVelocity_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(AngularVelocity self, FloatKey a0) -> bool
        has_attribute(AngularVelocity self, IntKey a0) -> bool
        has_attribute(AngularVelocity self, StringKey a0) -> bool
        has_attribute(AngularVelocity self, ParticleIndexKey a0) -> bool
        has_attribute(AngularVelocity self, ObjectKey a0) -> bool
        """
        return _IMP_atom.AngularVelocity_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(AngularVelocity self, FloatKey a0) -> double"""
        return _IMP_atom.AngularVelocity_get_derivative(self, a0)


    def get_name(self):
        """get_name(AngularVelocity self) -> std::string"""
        return _IMP_atom.AngularVelocity_get_name(self)


    def clear_caches(self):
        """clear_caches(AngularVelocity self)"""
        return _IMP_atom.AngularVelocity_clear_caches(self)


    def set_name(self, a0):
        """set_name(AngularVelocity self, std::string a0)"""
        return _IMP_atom.AngularVelocity_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(AngularVelocity self, IMP::CheckLevel a0)"""
        return _IMP_atom.AngularVelocity_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(AngularVelocity self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.AngularVelocity_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(AngularVelocity self, FloatKey a0, bool a1)"""
        return _IMP_atom.AngularVelocity_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(AngularVelocity self, FloatKey a0) -> bool"""
        return _IMP_atom.AngularVelocity_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(AngularVelocity self) -> IMP::CheckLevel"""
        return _IMP_atom.AngularVelocity_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(AngularVelocity self, AngularVelocity o) -> bool
        __eq__(AngularVelocity self, Particle d) -> bool
        """
        return _IMP_atom.AngularVelocity___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(AngularVelocity self, AngularVelocity o) -> bool
        __ne__(AngularVelocity self, Particle d) -> bool
        """
        return _IMP_atom.AngularVelocity___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(AngularVelocity self, AngularVelocity o) -> bool
        __le__(AngularVelocity self, Particle d) -> bool
        """
        return _IMP_atom.AngularVelocity___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(AngularVelocity self, AngularVelocity o) -> bool
        __lt__(AngularVelocity self, Particle d) -> bool
        """
        return _IMP_atom.AngularVelocity___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(AngularVelocity self, AngularVelocity o) -> bool
        __ge__(AngularVelocity self, Particle d) -> bool
        """
        return _IMP_atom.AngularVelocity___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(AngularVelocity self, AngularVelocity o) -> bool
        __gt__(AngularVelocity self, Particle d) -> bool
        """
        return _IMP_atom.AngularVelocity___gt__(self, *args)


    def __hash__(self):
        """__hash__(AngularVelocity self) -> std::size_t"""
        return _IMP_atom.AngularVelocity___hash__(self)


    def __str__(self):
        """__str__(AngularVelocity self) -> std::string"""
        return _IMP_atom.AngularVelocity___str__(self)


    def __repr__(self):
        """__repr__(AngularVelocity self) -> std::string"""
        return _IMP_atom.AngularVelocity___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_AngularVelocity
    __del__ = lambda self: None
AngularVelocity_swigregister = _IMP_atom.AngularVelocity_swigregister
AngularVelocity_swigregister(AngularVelocity)

def AngularVelocity_get_velocity_key(i):
    """AngularVelocity_get_velocity_key(unsigned int i) -> FloatKey"""
    return _IMP_atom.AngularVelocity_get_velocity_key(i)

def AngularVelocity_get_is_setup(*args):
    """
    get_is_setup(Model m, ParticleIndex pi) -> bool
    AngularVelocity_get_is_setup(_ParticleAdaptor p) -> bool
    """
    return _IMP_atom.AngularVelocity_get_is_setup(*args)

def AngularVelocity_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> AngularVelocity
    setup_particle(_ParticleAdaptor decorator) -> AngularVelocity
    setup_particle(Model m, ParticleIndex pi, Vector4D v) -> AngularVelocity
    AngularVelocity_setup_particle(_ParticleAdaptor decorator, Vector4D v) -> AngularVelocity
    """
    return _IMP_atom.AngularVelocity_setup_particle(*args)

class MolecularDynamics(Simulator):
    """Proxy of C++ IMP::atom::MolecularDynamics 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::atom::MolecularDynamics self, Model m) -> MolecularDynamics"""
        this = _IMP_atom.new_MolecularDynamics(m)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_kinetic_energy(self):
        """get_kinetic_energy(MolecularDynamics self) -> IMP::Float"""
        return _IMP_atom.MolecularDynamics_get_kinetic_energy(self)


    def get_kinetic_temperature(self, ekinetic):
        """get_kinetic_temperature(MolecularDynamics self, IMP::Float ekinetic) -> IMP::Float"""
        return _IMP_atom.MolecularDynamics_get_kinetic_temperature(self, ekinetic)


    def set_velocity_cap(self, velocity_cap):
        """set_velocity_cap(MolecularDynamics self, IMP::Float velocity_cap)"""
        return _IMP_atom.MolecularDynamics_set_velocity_cap(self, velocity_cap)


    def assign_velocities(self, temperature):
        """assign_velocities(MolecularDynamics self, IMP::Float temperature)"""
        return _IMP_atom.MolecularDynamics_assign_velocities(self, temperature)


    def setup(self, ps):
        """setup(MolecularDynamics self, IMP::ParticleIndexes const & ps)"""
        return _IMP_atom.MolecularDynamics_setup(self, ps)


    def do_step(self, sc, dt):
        """do_step(MolecularDynamics self, IMP::ParticleIndexes const & sc, double dt) -> double"""
        return _IMP_atom.MolecularDynamics_do_step(self, sc, dt)


    def get_is_simulation_particle(self, p):
        """get_is_simulation_particle(MolecularDynamics self, ParticleIndex p) -> bool"""
        return _IMP_atom.MolecularDynamics_get_is_simulation_particle(self, p)


    def get_version_info(self):
        """get_version_info(MolecularDynamics self) -> VersionInfo"""
        return _IMP_atom.MolecularDynamics_get_version_info(self)


    def __str__(self):
        """__str__(MolecularDynamics self) -> std::string"""
        return _IMP_atom.MolecularDynamics___str__(self)


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


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

MolecularDynamics_swigregister = _IMP_atom.MolecularDynamics_swigregister
MolecularDynamics_swigregister(MolecularDynamics)

class VelocityScalingOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::atom::VelocityScalingOptimizerState class."""

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

    def __init__(self, m, pis, temperature):
        """__init__(IMP::atom::VelocityScalingOptimizerState self, Model m, _ParticleIndexesAdaptor pis, double temperature) -> VelocityScalingOptimizerState"""
        this = _IMP_atom.new_VelocityScalingOptimizerState(m, pis, temperature)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_particles(self, pis):
        """set_particles(VelocityScalingOptimizerState self, IMP::Particles const & pis)"""
        return _IMP_atom.VelocityScalingOptimizerState_set_particles(self, pis)


    def set_temperature(self, temperature):
        """set_temperature(VelocityScalingOptimizerState self, IMP::Float temperature)"""
        return _IMP_atom.VelocityScalingOptimizerState_set_temperature(self, temperature)


    def rescale_velocities(self):
        """rescale_velocities(VelocityScalingOptimizerState self)"""
        return _IMP_atom.VelocityScalingOptimizerState_rescale_velocities(self)


    def get_version_info(self):
        """get_version_info(VelocityScalingOptimizerState self) -> VersionInfo"""
        return _IMP_atom.VelocityScalingOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(VelocityScalingOptimizerState self) -> std::string"""
        return _IMP_atom.VelocityScalingOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(VelocityScalingOptimizerState self) -> std::string"""
        return _IMP_atom.VelocityScalingOptimizerState___repr__(self)


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

VelocityScalingOptimizerState_swigregister = _IMP_atom.VelocityScalingOptimizerState_swigregister
VelocityScalingOptimizerState_swigregister(VelocityScalingOptimizerState)

class Fragment(Hierarchy):
    """Proxy of C++ IMP::atom::Fragment class."""

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

    def set_residue_indexes(self, o):
        """set_residue_indexes(Fragment self, IMP::Ints o)"""
        return _IMP_atom.Fragment_set_residue_indexes(self, o)


    def get_residue_indexes(self):
        """get_residue_indexes(Fragment self) -> IMP::Ints"""
        return _IMP_atom.Fragment_get_residue_indexes(self)


    def get_contains_residue(self, rindex):
        """get_contains_residue(Fragment self, int rindex) -> bool"""
        return _IMP_atom.Fragment_get_contains_residue(self, rindex)


    def __init__(self, *args):
        """
        __init__(IMP::atom::Fragment self) -> Fragment
        __init__(IMP::atom::Fragment self, Model m, ParticleIndex id) -> Fragment
        __init__(IMP::atom::Fragment self, _ParticleAdaptor d) -> Fragment
        """
        this = _IMP_atom.new_Fragment(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_is_setup(*args):
        """
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_atom.Fragment_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(Fragment self, _ostream out)
        show(Fragment self)
        """
        return _IMP_atom.Fragment_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> Fragment
        setup_particle(_ParticleAdaptor decorator) -> Fragment
        setup_particle(Model m, ParticleIndex pi, Fragment other) -> Fragment
        setup_particle(_ParticleAdaptor decorator, Fragment other) -> Fragment
        setup_particle(Model m, ParticleIndex pi, IMP::Ints residue_indexes) -> Fragment
        setup_particle(_ParticleAdaptor decorator, IMP::Ints residue_indexes) -> Fragment
        """
        return _IMP_atom.Fragment_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Fragment self, FloatKey a0)
        remove_attribute(Fragment self, IntKey a0)
        remove_attribute(Fragment self, StringKey a0)
        remove_attribute(Fragment self, ParticleIndexKey a0)
        remove_attribute(Fragment self, ObjectKey a0)
        """
        return _IMP_atom.Fragment_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Fragment self, FloatKey a0) -> bool
        has_attribute(Fragment self, IntKey a0) -> bool
        has_attribute(Fragment self, StringKey a0) -> bool
        has_attribute(Fragment self, ParticleIndexKey a0) -> bool
        has_attribute(Fragment self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Fragment_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Fragment self, FloatKey a0) -> double"""
        return _IMP_atom.Fragment_get_derivative(self, a0)


    def get_name(self):
        """get_name(Fragment self) -> std::string"""
        return _IMP_atom.Fragment_get_name(self)


    def clear_caches(self):
        """clear_caches(Fragment self)"""
        return _IMP_atom.Fragment_clear_caches(self)


    def set_name(self, a0):
        """set_name(Fragment self, std::string a0)"""
        return _IMP_atom.Fragment_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Fragment self, IMP::CheckLevel a0)"""
        return _IMP_atom.Fragment_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Fragment self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Fragment_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Fragment self, FloatKey a0, bool a1)"""
        return _IMP_atom.Fragment_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Fragment self, FloatKey a0) -> bool"""
        return _IMP_atom.Fragment_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Fragment self) -> IMP::CheckLevel"""
        return _IMP_atom.Fragment_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Fragment self, Fragment o) -> bool
        __eq__(Fragment self, Particle d) -> bool
        """
        return _IMP_atom.Fragment___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Fragment self, Fragment o) -> bool
        __ne__(Fragment self, Particle d) -> bool
        """
        return _IMP_atom.Fragment___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Fragment self, Fragment o) -> bool
        __le__(Fragment self, Particle d) -> bool
        """
        return _IMP_atom.Fragment___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Fragment self, Fragment o) -> bool
        __lt__(Fragment self, Particle d) -> bool
        """
        return _IMP_atom.Fragment___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Fragment self, Fragment o) -> bool
        __ge__(Fragment self, Particle d) -> bool
        """
        return _IMP_atom.Fragment___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Fragment self, Fragment o) -> bool
        __gt__(Fragment self, Particle d) -> bool
        """
        return _IMP_atom.Fragment___gt__(self, *args)


    def __hash__(self):
        """__hash__(Fragment self) -> std::size_t"""
        return _IMP_atom.Fragment___hash__(self)


    def __str__(self):
        """__str__(Fragment self) -> std::string"""
        return _IMP_atom.Fragment___str__(self)


    def __repr__(self):
        """__repr__(Fragment self) -> std::string"""
        return _IMP_atom.Fragment___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Fragment
    __del__ = lambda self: None
Fragment_swigregister = _IMP_atom.Fragment_swigregister
Fragment_swigregister(Fragment)

def Fragment_get_is_setup(*args):
    """
    get_is_setup(Model m, ParticleIndex pi) -> bool
    Fragment_get_is_setup(_ParticleAdaptor p) -> bool
    """
    return _IMP_atom.Fragment_get_is_setup(*args)

def Fragment_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> Fragment
    setup_particle(_ParticleAdaptor decorator) -> Fragment
    setup_particle(Model m, ParticleIndex pi, Fragment other) -> Fragment
    setup_particle(_ParticleAdaptor decorator, Fragment other) -> Fragment
    setup_particle(Model m, ParticleIndex pi, IMP::Ints residue_indexes) -> Fragment
    Fragment_setup_particle(_ParticleAdaptor decorator, IMP::Ints residue_indexes) -> Fragment
    """
    return _IMP_atom.Fragment_setup_particle(*args)

class StereochemistryPairFilter(IMP.PairPredicate):
    """Proxy of C++ IMP::atom::StereochemistryPairFilter 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::atom::StereochemistryPairFilter self) -> StereochemistryPairFilter"""
        this = _IMP_atom.new_StereochemistryPairFilter()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_bonds(self, bonds):
        """set_bonds(StereochemistryPairFilter self, IMP::Particles const & bonds)"""
        return _IMP_atom.StereochemistryPairFilter_set_bonds(self, bonds)


    def set_angles(self, angles):
        """set_angles(StereochemistryPairFilter self, IMP::Particles const & angles)"""
        return _IMP_atom.StereochemistryPairFilter_set_angles(self, angles)


    def set_dihedrals(self, dihedrals):
        """set_dihedrals(StereochemistryPairFilter self, IMP::Particles const & dihedrals)"""
        return _IMP_atom.StereochemistryPairFilter_set_dihedrals(self, dihedrals)


    def do_get_inputs(self, m, pis):
        """do_get_inputs(StereochemistryPairFilter self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.StereochemistryPairFilter_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(StereochemistryPairFilter self, IMP::ParticlePair const & a) -> int
        get_value(StereochemistryPairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_atom.StereochemistryPairFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(StereochemistryPairFilter self, Model m, IMP::ParticleIndexPair const & p) -> int
        get_value_index(StereochemistryPairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_atom.StereochemistryPairFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(StereochemistryPairFilter self) -> VersionInfo"""
        return _IMP_atom.StereochemistryPairFilter_get_version_info(self)


    def __str__(self):
        """__str__(StereochemistryPairFilter self) -> std::string"""
        return _IMP_atom.StereochemistryPairFilter___str__(self)


    def __repr__(self):
        """__repr__(StereochemistryPairFilter self) -> std::string"""
        return _IMP_atom.StereochemistryPairFilter___repr__(self)


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

StereochemistryPairFilter_swigregister = _IMP_atom.StereochemistryPairFilter_swigregister
StereochemistryPairFilter_swigregister(StereochemistryPairFilter)

class SoapPairFilter(IMP.PairPredicate):
    """Proxy of C++ IMP::atom::SoapPairFilter class."""

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

    def __init__(self, library):
        """__init__(IMP::atom::SoapPairFilter self, std::string library) -> SoapPairFilter"""
        this = _IMP_atom.new_SoapPairFilter(library)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(SoapPairFilter self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.SoapPairFilter_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(SoapPairFilter self, IMP::ParticlePair const & a) -> int
        get_value(SoapPairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_atom.SoapPairFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(SoapPairFilter self, Model m, IMP::ParticleIndexPair const & p) -> int
        get_value_index(SoapPairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_atom.SoapPairFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(SoapPairFilter self) -> VersionInfo"""
        return _IMP_atom.SoapPairFilter_get_version_info(self)


    def __str__(self):
        """__str__(SoapPairFilter self) -> std::string"""
        return _IMP_atom.SoapPairFilter___str__(self)


    def __repr__(self):
        """__repr__(SoapPairFilter self) -> std::string"""
        return _IMP_atom.SoapPairFilter___repr__(self)


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

SoapPairFilter_swigregister = _IMP_atom.SoapPairFilter_swigregister
SoapPairFilter_swigregister(SoapPairFilter)

class Mass(IMP.Decorator):
    """Proxy of C++ IMP::atom::Mass class."""

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

    def get_mass(self):
        """get_mass(Mass self) -> IMP::Float"""
        return _IMP_atom.Mass_get_mass(self)


    def set_mass(self, d):
        """set_mass(Mass self, IMP::Float d)"""
        return _IMP_atom.Mass_set_mass(self, d)


    def __init__(self, *args):
        """
        __init__(IMP::atom::Mass self) -> Mass
        __init__(IMP::atom::Mass self, Model m, ParticleIndex id) -> Mass
        __init__(IMP::atom::Mass self, _ParticleAdaptor d) -> Mass
        """
        this = _IMP_atom.new_Mass(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_is_setup(*args):
        """
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_atom.Mass_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(Mass self, _ostream out)
        show(Mass self)
        """
        return _IMP_atom.Mass_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, IMP::Float mass) -> Mass
        setup_particle(_ParticleAdaptor decorator, IMP::Float mass) -> Mass
        """
        return _IMP_atom.Mass_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_mass_key():
        """get_mass_key() -> FloatKey"""
        return _IMP_atom.Mass_get_mass_key()

    get_mass_key = staticmethod(get_mass_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Mass self, FloatKey a0)
        remove_attribute(Mass self, IntKey a0)
        remove_attribute(Mass self, StringKey a0)
        remove_attribute(Mass self, ParticleIndexKey a0)
        remove_attribute(Mass self, ObjectKey a0)
        """
        return _IMP_atom.Mass_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Mass self, FloatKey a0) -> bool
        has_attribute(Mass self, IntKey a0) -> bool
        has_attribute(Mass self, StringKey a0) -> bool
        has_attribute(Mass self, ParticleIndexKey a0) -> bool
        has_attribute(Mass self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Mass_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Mass self, FloatKey a0) -> double"""
        return _IMP_atom.Mass_get_derivative(self, a0)


    def get_name(self):
        """get_name(Mass self) -> std::string"""
        return _IMP_atom.Mass_get_name(self)


    def clear_caches(self):
        """clear_caches(Mass self)"""
        return _IMP_atom.Mass_clear_caches(self)


    def set_name(self, a0):
        """set_name(Mass self, std::string a0)"""
        return _IMP_atom.Mass_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Mass self, IMP::CheckLevel a0)"""
        return _IMP_atom.Mass_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Mass self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Mass_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Mass self, FloatKey a0, bool a1)"""
        return _IMP_atom.Mass_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Mass self, FloatKey a0) -> bool"""
        return _IMP_atom.Mass_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Mass self) -> IMP::CheckLevel"""
        return _IMP_atom.Mass_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Mass self, Mass o) -> bool
        __eq__(Mass self, Particle d) -> bool
        """
        return _IMP_atom.Mass___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Mass self, Mass o) -> bool
        __ne__(Mass self, Particle d) -> bool
        """
        return _IMP_atom.Mass___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Mass self, Mass o) -> bool
        __le__(Mass self, Particle d) -> bool
        """
        return _IMP_atom.Mass___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Mass self, Mass o) -> bool
        __lt__(Mass self, Particle d) -> bool
        """
        return _IMP_atom.Mass___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Mass self, Mass o) -> bool
        __ge__(Mass self, Particle d) -> bool
        """
        return _IMP_atom.Mass___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Mass self, Mass o) -> bool
        __gt__(Mass self, Particle d) -> bool
        """
        return _IMP_atom.Mass___gt__(self, *args)


    def __hash__(self):
        """__hash__(Mass self) -> std::size_t"""
        return _IMP_atom.Mass___hash__(self)


    def __str__(self):
        """__str__(Mass self) -> std::string"""
        return _IMP_atom.Mass___str__(self)


    def __repr__(self):
        """__repr__(Mass self) -> std::string"""
        return _IMP_atom.Mass___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Mass
    __del__ = lambda self: None
Mass_swigregister = _IMP_atom.Mass_swigregister
Mass_swigregister(Mass)

def Mass_get_is_setup(*args):
    """
    get_is_setup(Model m, ParticleIndex pi) -> bool
    Mass_get_is_setup(_ParticleAdaptor p) -> bool
    """
    return _IMP_atom.Mass_get_is_setup(*args)

def Mass_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, IMP::Float mass) -> Mass
    Mass_setup_particle(_ParticleAdaptor decorator, IMP::Float mass) -> Mass
    """
    return _IMP_atom.Mass_setup_particle(*args)

def Mass_get_mass_key():
    """Mass_get_mass_key() -> FloatKey"""
    return _IMP_atom.Mass_get_mass_key()

class BondedPairFilter(IMP.PairPredicate):
    """Proxy of C++ IMP::atom::BondedPairFilter 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::atom::BondedPairFilter self) -> BondedPairFilter"""
        this = _IMP_atom.new_BondedPairFilter()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(BondedPairFilter self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.BondedPairFilter_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(BondedPairFilter self, IMP::ParticlePair const & a) -> int
        get_value(BondedPairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_atom.BondedPairFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(BondedPairFilter self, Model m, IMP::ParticleIndexPair const & p) -> int
        get_value_index(BondedPairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_atom.BondedPairFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(BondedPairFilter self) -> VersionInfo"""
        return _IMP_atom.BondedPairFilter_get_version_info(self)


    def __str__(self):
        """__str__(BondedPairFilter self) -> std::string"""
        return _IMP_atom.BondedPairFilter___str__(self)


    def __repr__(self):
        """__repr__(BondedPairFilter self) -> std::string"""
        return _IMP_atom.BondedPairFilter___repr__(self)


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

BondedPairFilter_swigregister = _IMP_atom.BondedPairFilter_swigregister
BondedPairFilter_swigregister(BondedPairFilter)

class Mol2Selector(IMP.Object):
    """Proxy of C++ IMP::atom::Mol2Selector 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")

    def get_is_selected(self, atom_line):
        """get_is_selected(Mol2Selector self, std::string const & atom_line) -> bool"""
        return _IMP_atom.Mol2Selector_get_is_selected(self, atom_line)

    __swig_destroy__ = _IMP_atom.delete_Mol2Selector
    __del__ = lambda self: None

    def __str__(self):
        """__str__(Mol2Selector self) -> std::string"""
        return _IMP_atom.Mol2Selector___str__(self)


    def __repr__(self):
        """__repr__(Mol2Selector self) -> std::string"""
        return _IMP_atom.Mol2Selector___repr__(self)


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

Mol2Selector_swigregister = _IMP_atom.Mol2Selector_swigregister
Mol2Selector_swigregister(Mol2Selector)

class AllMol2Selector(Mol2Selector):
    """Proxy of C++ IMP::atom::AllMol2Selector class."""

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

    def __str__(self):
        """__str__(AllMol2Selector self) -> std::string"""
        return _IMP_atom.AllMol2Selector___str__(self)


    def __repr__(self):
        """__repr__(AllMol2Selector self) -> std::string"""
        return _IMP_atom.AllMol2Selector___repr__(self)


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


    def __init__(self):
        """__init__(IMP::atom::AllMol2Selector self) -> AllMol2Selector"""
        this = _IMP_atom.new_AllMol2Selector()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _IMP_atom.delete_AllMol2Selector
    __del__ = lambda self: None
AllMol2Selector_swigregister = _IMP_atom.AllMol2Selector_swigregister
AllMol2Selector_swigregister(AllMol2Selector)

class NonHydrogenMol2Selector(Mol2Selector):
    """Proxy of C++ IMP::atom::NonHydrogenMol2Selector class."""

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

    def __str__(self):
        """__str__(NonHydrogenMol2Selector self) -> std::string"""
        return _IMP_atom.NonHydrogenMol2Selector___str__(self)


    def __repr__(self):
        """__repr__(NonHydrogenMol2Selector self) -> std::string"""
        return _IMP_atom.NonHydrogenMol2Selector___repr__(self)


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


    def __init__(self):
        """__init__(IMP::atom::NonHydrogenMol2Selector self) -> NonHydrogenMol2Selector"""
        this = _IMP_atom.new_NonHydrogenMol2Selector()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _IMP_atom.delete_NonHydrogenMol2Selector
    __del__ = lambda self: None
NonHydrogenMol2Selector_swigregister = _IMP_atom.NonHydrogenMol2Selector_swigregister
NonHydrogenMol2Selector_swigregister(NonHydrogenMol2Selector)


def read_mol2(mol2_file, model, mol2sel=None):
    """
    read_mol2(TextInput mol2_file, Model model, Mol2Selector mol2sel=None) -> Hierarchy
    read_mol2(TextInput mol2_file, Model model) -> Hierarchy
    """
    return _IMP_atom.read_mol2(mol2_file, model, mol2sel)

def write_mol2(rhd, file_name):
    """write_mol2(Hierarchy rhd, TextOutput file_name)"""
    return _IMP_atom.write_mol2(rhd, file_name)
class SecondaryStructureResidue(IMP.Decorator):
    """Proxy of C++ IMP::atom::SecondaryStructureResidue 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::atom::SecondaryStructureResidue self) -> SecondaryStructureResidue
        __init__(IMP::atom::SecondaryStructureResidue self, Model m, ParticleIndex id) -> SecondaryStructureResidue
        __init__(IMP::atom::SecondaryStructureResidue self, _ParticleAdaptor d) -> SecondaryStructureResidue
        """
        this = _IMP_atom.new_SecondaryStructureResidue(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(SecondaryStructureResidue self, _ostream out)
        show(SecondaryStructureResidue self)
        """
        return _IMP_atom.SecondaryStructureResidue_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, IMP::Float prob_helix, IMP::Float prob_strand, IMP::Float prob_coil) -> SecondaryStructureResidue
        setup_particle(_ParticleAdaptor decorator, IMP::Float prob_helix, IMP::Float prob_strand, IMP::Float prob_coil) -> SecondaryStructureResidue
        setup_particle(Particle res_p) -> SecondaryStructureResidue
        """
        return _IMP_atom.SecondaryStructureResidue_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_atom.SecondaryStructureResidue_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_particle(self):
        """get_particle(SecondaryStructureResidue self) -> Particle"""
        return _IMP_atom.SecondaryStructureResidue_get_particle(self)


    def get_all_probabilities(self):
        """get_all_probabilities(SecondaryStructureResidue self) -> IMP::Floats"""
        return _IMP_atom.SecondaryStructureResidue_get_all_probabilities(self)


    def get_prob_helix(self):
        """get_prob_helix(SecondaryStructureResidue self) -> IMP::Float"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_helix(self)


    def set_prob_helix(self, t):
        """set_prob_helix(SecondaryStructureResidue self, IMP::Float t)"""
        return _IMP_atom.SecondaryStructureResidue_set_prob_helix(self, t)


    def get_prob_strand(self):
        """get_prob_strand(SecondaryStructureResidue self) -> IMP::Float"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_strand(self)


    def set_prob_strand(self, t):
        """set_prob_strand(SecondaryStructureResidue self, IMP::Float t)"""
        return _IMP_atom.SecondaryStructureResidue_set_prob_strand(self, t)


    def get_prob_coil(self):
        """get_prob_coil(SecondaryStructureResidue self) -> IMP::Float"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_coil(self)


    def set_prob_coil(self, t):
        """set_prob_coil(SecondaryStructureResidue self, IMP::Float t)"""
        return _IMP_atom.SecondaryStructureResidue_set_prob_coil(self, t)


    def get_prob_helix_key():
        """get_prob_helix_key() -> FloatKey"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_helix_key()

    get_prob_helix_key = staticmethod(get_prob_helix_key)

    def get_prob_strand_key():
        """get_prob_strand_key() -> FloatKey"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_strand_key()

    get_prob_strand_key = staticmethod(get_prob_strand_key)

    def get_prob_coil_key():
        """get_prob_coil_key() -> FloatKey"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_coil_key()

    get_prob_coil_key = staticmethod(get_prob_coil_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(SecondaryStructureResidue self, FloatKey a0)
        remove_attribute(SecondaryStructureResidue self, IntKey a0)
        remove_attribute(SecondaryStructureResidue self, StringKey a0)
        remove_attribute(SecondaryStructureResidue self, ParticleIndexKey a0)
        remove_attribute(SecondaryStructureResidue self, ObjectKey a0)
        """
        return _IMP_atom.SecondaryStructureResidue_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(SecondaryStructureResidue self, FloatKey a0) -> bool
        has_attribute(SecondaryStructureResidue self, IntKey a0) -> bool
        has_attribute(SecondaryStructureResidue self, StringKey a0) -> bool
        has_attribute(SecondaryStructureResidue self, ParticleIndexKey a0) -> bool
        has_attribute(SecondaryStructureResidue self, ObjectKey a0) -> bool
        """
        return _IMP_atom.SecondaryStructureResidue_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(SecondaryStructureResidue self, FloatKey a0) -> double"""
        return _IMP_atom.SecondaryStructureResidue_get_derivative(self, a0)


    def get_name(self):
        """get_name(SecondaryStructureResidue self) -> std::string"""
        return _IMP_atom.SecondaryStructureResidue_get_name(self)


    def clear_caches(self):
        """clear_caches(SecondaryStructureResidue self)"""
        return _IMP_atom.SecondaryStructureResidue_clear_caches(self)


    def set_name(self, a0):
        """set_name(SecondaryStructureResidue self, std::string a0)"""
        return _IMP_atom.SecondaryStructureResidue_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(SecondaryStructureResidue self, IMP::CheckLevel a0)"""
        return _IMP_atom.SecondaryStructureResidue_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(SecondaryStructureResidue self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.SecondaryStructureResidue_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(SecondaryStructureResidue self, FloatKey a0, bool a1)"""
        return _IMP_atom.SecondaryStructureResidue_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(SecondaryStructureResidue self, FloatKey a0) -> bool"""
        return _IMP_atom.SecondaryStructureResidue_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(SecondaryStructureResidue self) -> IMP::CheckLevel"""
        return _IMP_atom.SecondaryStructureResidue_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(SecondaryStructureResidue self, SecondaryStructureResidue o) -> bool
        __eq__(SecondaryStructureResidue self, Particle d) -> bool
        """
        return _IMP_atom.SecondaryStructureResidue___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(SecondaryStructureResidue self, SecondaryStructureResidue o) -> bool
        __ne__(SecondaryStructureResidue self, Particle d) -> bool
        """
        return _IMP_atom.SecondaryStructureResidue___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(SecondaryStructureResidue self, SecondaryStructureResidue o) -> bool
        __le__(SecondaryStructureResidue self, Particle d) -> bool
        """
        return _IMP_atom.SecondaryStructureResidue___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(SecondaryStructureResidue self, SecondaryStructureResidue o) -> bool
        __lt__(SecondaryStructureResidue self, Particle d) -> bool
        """
        return _IMP_atom.SecondaryStructureResidue___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(SecondaryStructureResidue self, SecondaryStructureResidue o) -> bool
        __ge__(SecondaryStructureResidue self, Particle d) -> bool
        """
        return _IMP_atom.SecondaryStructureResidue___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(SecondaryStructureResidue self, SecondaryStructureResidue o) -> bool
        __gt__(SecondaryStructureResidue self, Particle d) -> bool
        """
        return _IMP_atom.SecondaryStructureResidue___gt__(self, *args)


    def __hash__(self):
        """__hash__(SecondaryStructureResidue self) -> std::size_t"""
        return _IMP_atom.SecondaryStructureResidue___hash__(self)


    def __str__(self):
        """__str__(SecondaryStructureResidue self) -> std::string"""
        return _IMP_atom.SecondaryStructureResidue___str__(self)


    def __repr__(self):
        """__repr__(SecondaryStructureResidue self) -> std::string"""
        return _IMP_atom.SecondaryStructureResidue___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_SecondaryStructureResidue
    __del__ = lambda self: None
SecondaryStructureResidue_swigregister = _IMP_atom.SecondaryStructureResidue_swigregister
SecondaryStructureResidue_swigregister(SecondaryStructureResidue)

def SecondaryStructureResidue_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, IMP::Float prob_helix, IMP::Float prob_strand, IMP::Float prob_coil) -> SecondaryStructureResidue
    setup_particle(_ParticleAdaptor decorator, IMP::Float prob_helix, IMP::Float prob_strand, IMP::Float prob_coil) -> SecondaryStructureResidue
    SecondaryStructureResidue_setup_particle(Particle res_p) -> SecondaryStructureResidue
    """
    return _IMP_atom.SecondaryStructureResidue_setup_particle(*args)

def SecondaryStructureResidue_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    SecondaryStructureResidue_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.SecondaryStructureResidue_get_is_setup(*args)

def SecondaryStructureResidue_get_prob_helix_key():
    """SecondaryStructureResidue_get_prob_helix_key() -> FloatKey"""
    return _IMP_atom.SecondaryStructureResidue_get_prob_helix_key()

def SecondaryStructureResidue_get_prob_strand_key():
    """SecondaryStructureResidue_get_prob_strand_key() -> FloatKey"""
    return _IMP_atom.SecondaryStructureResidue_get_prob_strand_key()

def SecondaryStructureResidue_get_prob_coil_key():
    """SecondaryStructureResidue_get_prob_coil_key() -> FloatKey"""
    return _IMP_atom.SecondaryStructureResidue_get_prob_coil_key()


def setup_coarse_secondary_structure_residue(ssr_ps, mdl, winner_takes_all_per_res=False):
    """
    setup_coarse_secondary_structure_residue(IMP::Particles const & ssr_ps, Model mdl, bool winner_takes_all_per_res=False) -> SecondaryStructureResidue
    setup_coarse_secondary_structure_residue(IMP::Particles const & ssr_ps, Model mdl) -> SecondaryStructureResidue
    """
    return _IMP_atom.setup_coarse_secondary_structure_residue(ssr_ps, mdl, winner_takes_all_per_res)

def setup_coarse_secondary_structure_residues(ssr_ps, mdl, coarse_factor, start_res_num, winner_takes_all_per_res=False):
    """
    setup_coarse_secondary_structure_residues(IMP::Particles const & ssr_ps, Model mdl, int coarse_factor, int start_res_num, bool winner_takes_all_per_res=False) -> IMP::atom::SecondaryStructureResidues
    setup_coarse_secondary_structure_residues(IMP::Particles const & ssr_ps, Model mdl, int coarse_factor, int start_res_num) -> IMP::atom::SecondaryStructureResidues
    """
    return _IMP_atom.setup_coarse_secondary_structure_residues(ssr_ps, mdl, coarse_factor, start_res_num, winner_takes_all_per_res)

def get_secondary_structure_match_score(ssr1, ssr2):
    """get_secondary_structure_match_score(SecondaryStructureResidue ssr1, SecondaryStructureResidue ssr2) -> IMP::Float"""
    return _IMP_atom.get_secondary_structure_match_score(ssr1, ssr2)

def read_psipred(*args):
    """
    read_psipred(TextInput inf, Model mdl) -> IMP::atom::SecondaryStructureResidues
    read_psipred(TextInput inf, IMP::Particles ps) -> IMP::atom::SecondaryStructureResidues
    """
    return _IMP_atom.read_psipred(*args)
class _ADopeBase(IMP.PairScore):
    """Proxy of C++ IMP::score_functor::DistancePairScore<(IMP::score_functor::Dope)> 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::score_functor::DistancePairScore<(IMP::score_functor::Dope)> self, Dope t0, std::string name) -> _ADopeBase
        __init__(IMP::score_functor::DistancePairScore<(IMP::score_functor::Dope)> self, Dope t0) -> _ADopeBase
        """
        this = _IMP_atom.new__ADopeBase(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(_ADopeBase self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom._ADopeBase_do_get_inputs(self, m, pis)


    def get_score_functor(self):
        """get_score_functor(_ADopeBase self) -> Dope"""
        return _IMP_atom._ADopeBase_get_score_functor(self)


    def get_version_info(self):
        """get_version_info(_ADopeBase self) -> VersionInfo"""
        return _IMP_atom._ADopeBase_get_version_info(self)

_ADopeBase_swigregister = _IMP_atom._ADopeBase_swigregister
_ADopeBase_swigregister(_ADopeBase)

class _BDopeBase(IMP.PairScore):
    """Proxy of C++ IMP::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::DopeType,false,true,false)>)> 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::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::DopeType,false,true,false)>)> self, IMP::score_functor::DistancePairScore< IMP::score_functor::Statistical< IMP::atom::DopeType,false,true,false > >::DistanceScore const & t0, std::string name) -> _BDopeBase
        __init__(IMP::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::DopeType,false,true,false)>)> self, IMP::score_functor::DistancePairScore< IMP::score_functor::Statistical< IMP::atom::DopeType,false,true,false > >::DistanceScore const & t0) -> _BDopeBase
        """
        this = _IMP_atom.new__BDopeBase(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(_BDopeBase self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom._BDopeBase_do_get_inputs(self, m, pis)


    def get_score_functor(self):
        """get_score_functor(_BDopeBase self) -> _DopeBase"""
        return _IMP_atom._BDopeBase_get_score_functor(self)


    def get_version_info(self):
        """get_version_info(_BDopeBase self) -> VersionInfo"""
        return _IMP_atom._BDopeBase_get_version_info(self)

_BDopeBase_swigregister = _IMP_atom._BDopeBase_swigregister
_BDopeBase_swigregister(_BDopeBase)

class _OrientedSoapBase(IMP.PairScore):
    """Proxy of C++ IMP::score_functor::DistancePairScore<(IMP::score_functor::OrientedSoap)> 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::score_functor::DistancePairScore<(IMP::score_functor::OrientedSoap)> self, IMP::score_functor::DistancePairScore< IMP::score_functor::OrientedSoap >::DistanceScore const & t0, std::string name) -> _OrientedSoapBase
        __init__(IMP::score_functor::DistancePairScore<(IMP::score_functor::OrientedSoap)> self, IMP::score_functor::DistancePairScore< IMP::score_functor::OrientedSoap >::DistanceScore const & t0) -> _OrientedSoapBase
        """
        this = _IMP_atom.new__OrientedSoapBase(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(_OrientedSoapBase self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom._OrientedSoapBase_do_get_inputs(self, m, pis)


    def get_score_functor(self):
        """get_score_functor(_OrientedSoapBase self) -> IMP::score_functor::OrientedSoap &"""
        return _IMP_atom._OrientedSoapBase_get_score_functor(self)


    def get_version_info(self):
        """get_version_info(_OrientedSoapBase self) -> VersionInfo"""
        return _IMP_atom._OrientedSoapBase_get_version_info(self)

_OrientedSoapBase_swigregister = _IMP_atom._OrientedSoapBase_swigregister
_OrientedSoapBase_swigregister(_OrientedSoapBase)

class _SPSFTB(IMP.PairScore):
    """Proxy of C++ IMP::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::ProteinLigandType,true,false)>)> 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::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::ProteinLigandType,true,false)>)> self, IMP::score_functor::DistancePairScore< IMP::score_functor::Statistical< IMP::atom::ProteinLigandType,true,false > >::DistanceScore const & t0, std::string name) -> _SPSFTB
        __init__(IMP::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::ProteinLigandType,true,false)>)> self, IMP::score_functor::DistancePairScore< IMP::score_functor::Statistical< IMP::atom::ProteinLigandType,true,false > >::DistanceScore const & t0) -> _SPSFTB
        """
        this = _IMP_atom.new__SPSFTB(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(_SPSFTB self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom._SPSFTB_do_get_inputs(self, m, pis)


    def get_score_functor(self):
        """get_score_functor(_SPSFTB self) -> IMP::score_functor::Statistical< IMP::atom::ProteinLigandType,true,false,false > &"""
        return _IMP_atom._SPSFTB_get_score_functor(self)


    def get_version_info(self):
        """get_version_info(_SPSFTB self) -> VersionInfo"""
        return _IMP_atom._SPSFTB_get_version_info(self)

_SPSFTB_swigregister = _IMP_atom._SPSFTB_swigregister
_SPSFTB_swigregister(_SPSFTB)

class _SPSTF(_SPSFTB):
    """Proxy of C++ IMP::core::StatisticalPairScore<(IMP::atom::ProteinLigandType,true,false)> 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::core::StatisticalPairScore<(IMP::atom::ProteinLigandType,true,false)> self, IntKey k, double threshold, TextInput data_file) -> _SPSTF
        __init__(IMP::core::StatisticalPairScore<(IMP::atom::ProteinLigandType,true,false)> self, IntKey k, double threshold, TextInput data_file, unsigned int shift) -> _SPSTF
        """
        this = _IMP_atom.new__SPSTF(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _IMP_atom.delete__SPSTF
    __del__ = lambda self: None
_SPSTF_swigregister = _IMP_atom._SPSTF_swigregister
_SPSTF_swigregister(_SPSTF)

class _SPSFT(_BDopeBase):
    """Proxy of C++ IMP::core::StatisticalPairScore<(IMP::atom::DopeType,false,true)> 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::core::StatisticalPairScore<(IMP::atom::DopeType,false,true)> self, IntKey k, double threshold, TextInput data_file) -> _SPSFT
        __init__(IMP::core::StatisticalPairScore<(IMP::atom::DopeType,false,true)> self, IntKey k, double threshold, TextInput data_file, unsigned int shift) -> _SPSFT
        """
        this = _IMP_atom.new__SPSFT(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _IMP_atom.delete__SPSFT
    __del__ = lambda self: None
_SPSFT_swigregister = _IMP_atom._SPSFT_swigregister
_SPSFT_swigregister(_SPSFT)

class ProteinLigandAtomPairScore(_SPSTF):
    """Proxy of C++ IMP::atom::ProteinLigandAtomPairScore 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::atom::ProteinLigandAtomPairScore self, double threshold) -> ProteinLigandAtomPairScore
        __init__(IMP::atom::ProteinLigandAtomPairScore self) -> ProteinLigandAtomPairScore
        __init__(IMP::atom::ProteinLigandAtomPairScore self, double threshold, TextInput data_file) -> ProteinLigandAtomPairScore
        """
        this = _IMP_atom.new_ProteinLigandAtomPairScore(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_maximum_distance(self):
        """get_maximum_distance(ProteinLigandAtomPairScore self) -> double"""
        return _IMP_atom.ProteinLigandAtomPairScore_get_maximum_distance(self)


    def __str__(self):
        """__str__(ProteinLigandAtomPairScore self) -> std::string"""
        return _IMP_atom.ProteinLigandAtomPairScore___str__(self)


    def __repr__(self):
        """__repr__(ProteinLigandAtomPairScore self) -> std::string"""
        return _IMP_atom.ProteinLigandAtomPairScore___repr__(self)


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

    __swig_destroy__ = _IMP_atom.delete_ProteinLigandAtomPairScore
    __del__ = lambda self: None
ProteinLigandAtomPairScore_swigregister = _IMP_atom.ProteinLigandAtomPairScore_swigregister
ProteinLigandAtomPairScore_swigregister(ProteinLigandAtomPairScore)

class ProteinLigandRestraint(IMP.container.PairsRestraint):
    """Proxy of C++ IMP::atom::ProteinLigandRestraint 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::atom::ProteinLigandRestraint self, Hierarchy protein, Hierarchy ligand, double threshold) -> ProteinLigandRestraint
        __init__(IMP::atom::ProteinLigandRestraint self, Hierarchy protein, Hierarchy ligand) -> ProteinLigandRestraint
        __init__(IMP::atom::ProteinLigandRestraint self, Hierarchy protein, Hierarchy ligand, double threshold, TextInput data_file) -> ProteinLigandRestraint
        """
        this = _IMP_atom.new_ProteinLigandRestraint(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(ProteinLigandRestraint self) -> std::string"""
        return _IMP_atom.ProteinLigandRestraint___str__(self)


    def __repr__(self):
        """__repr__(ProteinLigandRestraint self) -> std::string"""
        return _IMP_atom.ProteinLigandRestraint___repr__(self)


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

    __swig_destroy__ = _IMP_atom.delete_ProteinLigandRestraint
    __del__ = lambda self: None
ProteinLigandRestraint_swigregister = _IMP_atom.ProteinLigandRestraint_swigregister
ProteinLigandRestraint_swigregister(ProteinLigandRestraint)


def add_protein_ligand_score_data(h):
    """add_protein_ligand_score_data(Hierarchy h)"""
    return _IMP_atom.add_protein_ligand_score_data(h)
class AtomType(IMP._Value):
    """Proxy of C++ IMP::Key<(8974343,false)> 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<(8974343,false)> self) -> AtomType
        __init__(IMP::Key<(8974343,false)> self, std::string c) -> AtomType
        __init__(IMP::Key<(8974343,false)> self, unsigned int i) -> AtomType
        """
        this = _IMP_atom.new_AtomType(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_atom.AtomType_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_atom.AtomType_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(AtomType self) -> std::string const"""
        return _IMP_atom.AtomType_get_string(self)


    def __cmp__(self, o):
        """__cmp__(AtomType self, AtomType o) -> int"""
        return _IMP_atom.AtomType___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___eq__(self, o)


    def __ne__(self, o):
        """__ne__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___ne__(self, o)


    def __lt__(self, o):
        """__lt__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___lt__(self, o)


    def __gt__(self, o):
        """__gt__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___gt__(self, o)


    def __ge__(self, o):
        """__ge__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___ge__(self, o)


    def __le__(self, o):
        """__le__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___le__(self, o)


    def __hash__(self):
        """__hash__(AtomType self) -> std::size_t"""
        return _IMP_atom.AtomType___hash__(self)


    def show(self, *args):
        """
        show(AtomType self, _ostream out)
        show(AtomType self)
        """
        return _IMP_atom.AtomType_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(AtomType old_key, std::string new_name) -> AtomType"""
        return _IMP_atom.AtomType_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(AtomType self) -> unsigned int"""
        return _IMP_atom.AtomType_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_atom.AtomType_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_atom.AtomType_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_atom.AtomType_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(AtomType self) -> std::string"""
        return _IMP_atom.AtomType___str__(self)


    def __repr__(self):
        """__repr__(AtomType self) -> std::string"""
        return _IMP_atom.AtomType___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_AtomType
    __del__ = lambda self: None
AtomType_swigregister = _IMP_atom.AtomType_swigregister
AtomType_swigregister(AtomType)

def AtomType_add_key(sc):
    """AtomType_add_key(std::string sc) -> unsigned int"""
    return _IMP_atom.AtomType_add_key(sc)

def AtomType_get_key_exists(sc):
    """AtomType_get_key_exists(std::string sc) -> bool"""
    return _IMP_atom.AtomType_get_key_exists(sc)

def AtomType_add_alias(old_key, new_name):
    """AtomType_add_alias(AtomType old_key, std::string new_name) -> AtomType"""
    return _IMP_atom.AtomType_add_alias(old_key, new_name)

def AtomType_show_all(out):
    """AtomType_show_all(_ostream out)"""
    return _IMP_atom.AtomType_show_all(out)

def AtomType_get_all_strings():
    """AtomType_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_atom.AtomType_get_all_strings()

def AtomType_get_number_unique():
    """AtomType_get_number_unique() -> unsigned int"""
    return _IMP_atom.AtomType_get_number_unique()

class ResidueType(IMP._Value):
    """Proxy of C++ IMP::Key<(90784334,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<(90784334,true)> self) -> ResidueType
        __init__(IMP::Key<(90784334,true)> self, std::string c) -> ResidueType
        __init__(IMP::Key<(90784334,true)> self, unsigned int i) -> ResidueType
        """
        this = _IMP_atom.new_ResidueType(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add_key(sc):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_atom.ResidueType_add_key(sc)

    add_key = staticmethod(add_key)

    def get_key_exists(sc):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_atom.ResidueType_get_key_exists(sc)

    get_key_exists = staticmethod(get_key_exists)

    def get_string(self):
        """get_string(ResidueType self) -> std::string const"""
        return _IMP_atom.ResidueType_get_string(self)


    def __cmp__(self, o):
        """__cmp__(ResidueType self, ResidueType o) -> int"""
        return _IMP_atom.ResidueType___cmp__(self, o)


    def __eq__(self, o):
        """__eq__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___eq__(self, o)


    def __ne__(self, o):
        """__ne__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___ne__(self, o)


    def __lt__(self, o):
        """__lt__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___lt__(self, o)


    def __gt__(self, o):
        """__gt__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___gt__(self, o)


    def __ge__(self, o):
        """__ge__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___ge__(self, o)


    def __le__(self, o):
        """__le__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___le__(self, o)


    def __hash__(self):
        """__hash__(ResidueType self) -> std::size_t"""
        return _IMP_atom.ResidueType___hash__(self)


    def show(self, *args):
        """
        show(ResidueType self, _ostream out)
        show(ResidueType self)
        """
        return _IMP_atom.ResidueType_show(self, *args)


    def add_alias(old_key, new_name):
        """add_alias(ResidueType old_key, std::string new_name) -> ResidueType"""
        return _IMP_atom.ResidueType_add_alias(old_key, new_name)

    add_alias = staticmethod(add_alias)

    def get_index(self):
        """get_index(ResidueType self) -> unsigned int"""
        return _IMP_atom.ResidueType_get_index(self)


    def show_all(out):
        """show_all(_ostream out)"""
        return _IMP_atom.ResidueType_show_all(out)

    show_all = staticmethod(show_all)

    def get_all_strings():
        """get_all_strings() -> IMP::Vector< std::string >"""
        return _IMP_atom.ResidueType_get_all_strings()

    get_all_strings = staticmethod(get_all_strings)

    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_atom.ResidueType_get_number_unique()

    get_number_unique = staticmethod(get_number_unique)

    def __str__(self):
        """__str__(ResidueType self) -> std::string"""
        return _IMP_atom.ResidueType___str__(self)


    def __repr__(self):
        """__repr__(ResidueType self) -> std::string"""
        return _IMP_atom.ResidueType___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_ResidueType
    __del__ = lambda self: None
ResidueType_swigregister = _IMP_atom.ResidueType_swigregister
ResidueType_swigregister(ResidueType)

def ResidueType_add_key(sc):
    """ResidueType_add_key(std::string sc) -> unsigned int"""
    return _IMP_atom.ResidueType_add_key(sc)

def ResidueType_get_key_exists(sc):
    """ResidueType_get_key_exists(std::string sc) -> bool"""
    return _IMP_atom.ResidueType_get_key_exists(sc)

def ResidueType_add_alias(old_key, new_name):
    """ResidueType_add_alias(ResidueType old_key, std::string new_name) -> ResidueType"""
    return _IMP_atom.ResidueType_add_alias(old_key, new_name)

def ResidueType_show_all(out):
    """ResidueType_show_all(_ostream out)"""
    return _IMP_atom.ResidueType_show_all(out)

def ResidueType_get_all_strings():
    """ResidueType_get_all_strings() -> IMP::Vector< std::string >"""
    return _IMP_atom.ResidueType_get_all_strings()

def ResidueType_get_number_unique():
    """ResidueType_get_number_unique() -> unsigned int"""
    return _IMP_atom.ResidueType_get_number_unique()


_IMP_atom.UNKNOWN_ELEMENT_swigconstant(_IMP_atom)
UNKNOWN_ELEMENT = _IMP_atom.UNKNOWN_ELEMENT

_IMP_atom.OH_swigconstant(_IMP_atom)
OH = _IMP_atom.OH

_IMP_atom.H2O_swigconstant(_IMP_atom)
H2O = _IMP_atom.H2O

_IMP_atom.H_swigconstant(_IMP_atom)
H = _IMP_atom.H

_IMP_atom.He_swigconstant(_IMP_atom)
He = _IMP_atom.He

_IMP_atom.Li_swigconstant(_IMP_atom)
Li = _IMP_atom.Li

_IMP_atom.Be_swigconstant(_IMP_atom)
Be = _IMP_atom.Be

_IMP_atom.B_swigconstant(_IMP_atom)
B = _IMP_atom.B

_IMP_atom.C_swigconstant(_IMP_atom)
C = _IMP_atom.C

_IMP_atom.N_swigconstant(_IMP_atom)
N = _IMP_atom.N

_IMP_atom.O_swigconstant(_IMP_atom)
O = _IMP_atom.O

_IMP_atom.F_swigconstant(_IMP_atom)
F = _IMP_atom.F

_IMP_atom.Ne_swigconstant(_IMP_atom)
Ne = _IMP_atom.Ne

_IMP_atom.Na_swigconstant(_IMP_atom)
Na = _IMP_atom.Na

_IMP_atom.Mg_swigconstant(_IMP_atom)
Mg = _IMP_atom.Mg

_IMP_atom.Al_swigconstant(_IMP_atom)
Al = _IMP_atom.Al

_IMP_atom.Si_swigconstant(_IMP_atom)
Si = _IMP_atom.Si

_IMP_atom.P_swigconstant(_IMP_atom)
P = _IMP_atom.P

_IMP_atom.S_swigconstant(_IMP_atom)
S = _IMP_atom.S

_IMP_atom.Cl_swigconstant(_IMP_atom)
Cl = _IMP_atom.Cl

_IMP_atom.Ar_swigconstant(_IMP_atom)
Ar = _IMP_atom.Ar

_IMP_atom.K_swigconstant(_IMP_atom)
K = _IMP_atom.K

_IMP_atom.Ca_swigconstant(_IMP_atom)
Ca = _IMP_atom.Ca

_IMP_atom.Sc_swigconstant(_IMP_atom)
Sc = _IMP_atom.Sc

_IMP_atom.Ti_swigconstant(_IMP_atom)
Ti = _IMP_atom.Ti

_IMP_atom.V_swigconstant(_IMP_atom)
V = _IMP_atom.V

_IMP_atom.Cr_swigconstant(_IMP_atom)
Cr = _IMP_atom.Cr

_IMP_atom.Mn_swigconstant(_IMP_atom)
Mn = _IMP_atom.Mn

_IMP_atom.Fe_swigconstant(_IMP_atom)
Fe = _IMP_atom.Fe

_IMP_atom.Co_swigconstant(_IMP_atom)
Co = _IMP_atom.Co

_IMP_atom.Ni_swigconstant(_IMP_atom)
Ni = _IMP_atom.Ni

_IMP_atom.Cu_swigconstant(_IMP_atom)
Cu = _IMP_atom.Cu

_IMP_atom.Zn_swigconstant(_IMP_atom)
Zn = _IMP_atom.Zn

_IMP_atom.Ga_swigconstant(_IMP_atom)
Ga = _IMP_atom.Ga

_IMP_atom.Ge_swigconstant(_IMP_atom)
Ge = _IMP_atom.Ge

_IMP_atom.As_swigconstant(_IMP_atom)
As = _IMP_atom.As

_IMP_atom.Se_swigconstant(_IMP_atom)
Se = _IMP_atom.Se

_IMP_atom.Br_swigconstant(_IMP_atom)
Br = _IMP_atom.Br

_IMP_atom.Kr_swigconstant(_IMP_atom)
Kr = _IMP_atom.Kr

_IMP_atom.Rb_swigconstant(_IMP_atom)
Rb = _IMP_atom.Rb

_IMP_atom.Sr_swigconstant(_IMP_atom)
Sr = _IMP_atom.Sr

_IMP_atom.Y_swigconstant(_IMP_atom)
Y = _IMP_atom.Y

_IMP_atom.Zr_swigconstant(_IMP_atom)
Zr = _IMP_atom.Zr

_IMP_atom.Nb_swigconstant(_IMP_atom)
Nb = _IMP_atom.Nb

_IMP_atom.Mo_swigconstant(_IMP_atom)
Mo = _IMP_atom.Mo

_IMP_atom.Tc_swigconstant(_IMP_atom)
Tc = _IMP_atom.Tc

_IMP_atom.Ru_swigconstant(_IMP_atom)
Ru = _IMP_atom.Ru

_IMP_atom.Rh_swigconstant(_IMP_atom)
Rh = _IMP_atom.Rh

_IMP_atom.Pd_swigconstant(_IMP_atom)
Pd = _IMP_atom.Pd

_IMP_atom.Ag_swigconstant(_IMP_atom)
Ag = _IMP_atom.Ag

_IMP_atom.Cd_swigconstant(_IMP_atom)
Cd = _IMP_atom.Cd

_IMP_atom.In_swigconstant(_IMP_atom)
In = _IMP_atom.In

_IMP_atom.Sn_swigconstant(_IMP_atom)
Sn = _IMP_atom.Sn

_IMP_atom.Sb_swigconstant(_IMP_atom)
Sb = _IMP_atom.Sb

_IMP_atom.Te_swigconstant(_IMP_atom)
Te = _IMP_atom.Te

_IMP_atom.I_swigconstant(_IMP_atom)
I = _IMP_atom.I

_IMP_atom.Xe_swigconstant(_IMP_atom)
Xe = _IMP_atom.Xe

_IMP_atom.Cs_swigconstant(_IMP_atom)
Cs = _IMP_atom.Cs

_IMP_atom.Ba_swigconstant(_IMP_atom)
Ba = _IMP_atom.Ba

_IMP_atom.La_swigconstant(_IMP_atom)
La = _IMP_atom.La

_IMP_atom.Ce_swigconstant(_IMP_atom)
Ce = _IMP_atom.Ce

_IMP_atom.Pr_swigconstant(_IMP_atom)
Pr = _IMP_atom.Pr

_IMP_atom.Nd_swigconstant(_IMP_atom)
Nd = _IMP_atom.Nd

_IMP_atom.Pm_swigconstant(_IMP_atom)
Pm = _IMP_atom.Pm

_IMP_atom.Sm_swigconstant(_IMP_atom)
Sm = _IMP_atom.Sm

_IMP_atom.Eu_swigconstant(_IMP_atom)
Eu = _IMP_atom.Eu

_IMP_atom.Gd_swigconstant(_IMP_atom)
Gd = _IMP_atom.Gd

_IMP_atom.Tb_swigconstant(_IMP_atom)
Tb = _IMP_atom.Tb

_IMP_atom.Dy_swigconstant(_IMP_atom)
Dy = _IMP_atom.Dy

_IMP_atom.Ho_swigconstant(_IMP_atom)
Ho = _IMP_atom.Ho

_IMP_atom.Er_swigconstant(_IMP_atom)
Er = _IMP_atom.Er

_IMP_atom.Tm_swigconstant(_IMP_atom)
Tm = _IMP_atom.Tm

_IMP_atom.Yb_swigconstant(_IMP_atom)
Yb = _IMP_atom.Yb

_IMP_atom.Lu_swigconstant(_IMP_atom)
Lu = _IMP_atom.Lu

_IMP_atom.Hf_swigconstant(_IMP_atom)
Hf = _IMP_atom.Hf

_IMP_atom.Ta_swigconstant(_IMP_atom)
Ta = _IMP_atom.Ta

_IMP_atom.W_swigconstant(_IMP_atom)
W = _IMP_atom.W

_IMP_atom.Re_swigconstant(_IMP_atom)
Re = _IMP_atom.Re

_IMP_atom.Os_swigconstant(_IMP_atom)
Os = _IMP_atom.Os

_IMP_atom.Ir_swigconstant(_IMP_atom)
Ir = _IMP_atom.Ir

_IMP_atom.Pt_swigconstant(_IMP_atom)
Pt = _IMP_atom.Pt

_IMP_atom.Au_swigconstant(_IMP_atom)
Au = _IMP_atom.Au

_IMP_atom.Hg_swigconstant(_IMP_atom)
Hg = _IMP_atom.Hg

_IMP_atom.Tl_swigconstant(_IMP_atom)
Tl = _IMP_atom.Tl

_IMP_atom.Pb_swigconstant(_IMP_atom)
Pb = _IMP_atom.Pb

_IMP_atom.Bi_swigconstant(_IMP_atom)
Bi = _IMP_atom.Bi

_IMP_atom.Po_swigconstant(_IMP_atom)
Po = _IMP_atom.Po

_IMP_atom.At_swigconstant(_IMP_atom)
At = _IMP_atom.At

_IMP_atom.Rn_swigconstant(_IMP_atom)
Rn = _IMP_atom.Rn

_IMP_atom.Fr_swigconstant(_IMP_atom)
Fr = _IMP_atom.Fr

_IMP_atom.Ra_swigconstant(_IMP_atom)
Ra = _IMP_atom.Ra

_IMP_atom.Ac_swigconstant(_IMP_atom)
Ac = _IMP_atom.Ac

_IMP_atom.Th_swigconstant(_IMP_atom)
Th = _IMP_atom.Th

_IMP_atom.Pa_swigconstant(_IMP_atom)
Pa = _IMP_atom.Pa

_IMP_atom.U_swigconstant(_IMP_atom)
U = _IMP_atom.U

_IMP_atom.Np_swigconstant(_IMP_atom)
Np = _IMP_atom.Np

_IMP_atom.Pu_swigconstant(_IMP_atom)
Pu = _IMP_atom.Pu

_IMP_atom.Am_swigconstant(_IMP_atom)
Am = _IMP_atom.Am

_IMP_atom.Cm_swigconstant(_IMP_atom)
Cm = _IMP_atom.Cm

_IMP_atom.Bk_swigconstant(_IMP_atom)
Bk = _IMP_atom.Bk

_IMP_atom.Cf_swigconstant(_IMP_atom)
Cf = _IMP_atom.Cf

_IMP_atom.Es_swigconstant(_IMP_atom)
Es = _IMP_atom.Es

_IMP_atom.Fm_swigconstant(_IMP_atom)
Fm = _IMP_atom.Fm

_IMP_atom.Md_swigconstant(_IMP_atom)
Md = _IMP_atom.Md

_IMP_atom.No_swigconstant(_IMP_atom)
No = _IMP_atom.No

_IMP_atom.Lr_swigconstant(_IMP_atom)
Lr = _IMP_atom.Lr

_IMP_atom.Db_swigconstant(_IMP_atom)
Db = _IMP_atom.Db

_IMP_atom.Jl_swigconstant(_IMP_atom)
Jl = _IMP_atom.Jl

_IMP_atom.Rf_swigconstant(_IMP_atom)
Rf = _IMP_atom.Rf

_IMP_atom.NUMBER_OF_ELEMENTS_swigconstant(_IMP_atom)
NUMBER_OF_ELEMENTS = _IMP_atom.NUMBER_OF_ELEMENTS

def hash_value(e):
    """hash_value(IMP::atom::Element e) -> size_t"""
    return _IMP_atom.hash_value(e)
class ElementTable(object):
    """Proxy of C++ IMP::atom::ElementTable 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::atom::ElementTable self) -> ElementTable"""
        this = _IMP_atom.new_ElementTable()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_element(self, s):
        """get_element(ElementTable self, std::string const & s) -> IMP::atom::Element"""
        return _IMP_atom.ElementTable_get_element(self, s)


    def get_name(self, e):
        """get_name(ElementTable self, IMP::atom::Element e) -> std::string"""
        return _IMP_atom.ElementTable_get_name(self, e)


    def get_mass(self, e):
        """get_mass(ElementTable self, IMP::atom::Element e) -> IMP::Float"""
        return _IMP_atom.ElementTable_get_mass(self, e)

    __swig_destroy__ = _IMP_atom.delete_ElementTable
    __del__ = lambda self: None
ElementTable_swigregister = _IMP_atom.ElementTable_swigregister
ElementTable_swigregister(ElementTable)


def get_element_table():
    """get_element_table() -> ElementTable"""
    return _IMP_atom.get_element_table()
class Atom(Hierarchy):
    """Proxy of C++ IMP::atom::Atom 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::atom::Atom self) -> Atom
        __init__(IMP::atom::Atom self, Model m, ParticleIndex id) -> Atom
        __init__(IMP::atom::Atom self, _ParticleAdaptor d) -> Atom
        """
        this = _IMP_atom.new_Atom(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Atom self, _ostream out)
        show(Atom self)
        """
        return _IMP_atom.Atom_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, Atom other) -> Atom
        setup_particle(_ParticleAdaptor decorator, Atom other) -> Atom
        setup_particle(Model m, ParticleIndex pi, AtomType atom_type) -> Atom
        setup_particle(_ParticleAdaptor decorator, AtomType atom_type) -> Atom
        """
        return _IMP_atom.Atom_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_atom.Atom_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_atom_type(self):
        """get_atom_type(Atom self) -> AtomType"""
        return _IMP_atom.Atom_get_atom_type(self)


    def set_atom_type(self, t):
        """set_atom_type(Atom self, AtomType t)"""
        return _IMP_atom.Atom_set_atom_type(self, t)


    def get_element(self):
        """get_element(Atom self) -> IMP::atom::Element"""
        return _IMP_atom.Atom_get_element(self)


    def set_element(self, e):
        """set_element(Atom self, IMP::atom::Element e)"""
        return _IMP_atom.Atom_set_element(self, e)


    def get_occupancy(self):
        """get_occupancy(Atom self) -> double"""
        return _IMP_atom.Atom_get_occupancy(self)


    def set_occupancy(self, occupancy):
        """set_occupancy(Atom self, double occupancy)"""
        return _IMP_atom.Atom_set_occupancy(self, occupancy)


    def get_temperature_factor(self):
        """get_temperature_factor(Atom self) -> double"""
        return _IMP_atom.Atom_get_temperature_factor(self)


    def set_temperature_factor(self, tempFactor):
        """set_temperature_factor(Atom self, double tempFactor)"""
        return _IMP_atom.Atom_set_temperature_factor(self, tempFactor)


    def get_input_index(self):
        """get_input_index(Atom self) -> IMP::Int"""
        return _IMP_atom.Atom_get_input_index(self)


    def set_input_index(self, t):
        """set_input_index(Atom self, IMP::Int t)"""
        return _IMP_atom.Atom_set_input_index(self, t)


    def get_atom_type_key():
        """get_atom_type_key() -> IntKey"""
        return _IMP_atom.Atom_get_atom_type_key()

    get_atom_type_key = staticmethod(get_atom_type_key)

    def get_element_key():
        """get_element_key() -> IntKey"""
        return _IMP_atom.Atom_get_element_key()

    get_element_key = staticmethod(get_element_key)

    def get_input_index_key():
        """get_input_index_key() -> IntKey"""
        return _IMP_atom.Atom_get_input_index_key()

    get_input_index_key = staticmethod(get_input_index_key)

    def get_occupancy_key():
        """get_occupancy_key() -> FloatKey"""
        return _IMP_atom.Atom_get_occupancy_key()

    get_occupancy_key = staticmethod(get_occupancy_key)

    def get_temperature_factor_key():
        """get_temperature_factor_key() -> FloatKey"""
        return _IMP_atom.Atom_get_temperature_factor_key()

    get_temperature_factor_key = staticmethod(get_temperature_factor_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Atom self, FloatKey a0)
        remove_attribute(Atom self, IntKey a0)
        remove_attribute(Atom self, StringKey a0)
        remove_attribute(Atom self, ParticleIndexKey a0)
        remove_attribute(Atom self, ObjectKey a0)
        """
        return _IMP_atom.Atom_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Atom self, FloatKey a0) -> bool
        has_attribute(Atom self, IntKey a0) -> bool
        has_attribute(Atom self, StringKey a0) -> bool
        has_attribute(Atom self, ParticleIndexKey a0) -> bool
        has_attribute(Atom self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Atom_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Atom self, FloatKey a0) -> double"""
        return _IMP_atom.Atom_get_derivative(self, a0)


    def get_name(self):
        """get_name(Atom self) -> std::string"""
        return _IMP_atom.Atom_get_name(self)


    def clear_caches(self):
        """clear_caches(Atom self)"""
        return _IMP_atom.Atom_clear_caches(self)


    def set_name(self, a0):
        """set_name(Atom self, std::string a0)"""
        return _IMP_atom.Atom_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Atom self, IMP::CheckLevel a0)"""
        return _IMP_atom.Atom_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Atom self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Atom_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Atom self, FloatKey a0, bool a1)"""
        return _IMP_atom.Atom_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Atom self, FloatKey a0) -> bool"""
        return _IMP_atom.Atom_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Atom self) -> IMP::CheckLevel"""
        return _IMP_atom.Atom_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Atom self, Atom o) -> bool
        __eq__(Atom self, Particle d) -> bool
        """
        return _IMP_atom.Atom___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Atom self, Atom o) -> bool
        __ne__(Atom self, Particle d) -> bool
        """
        return _IMP_atom.Atom___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Atom self, Atom o) -> bool
        __le__(Atom self, Particle d) -> bool
        """
        return _IMP_atom.Atom___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Atom self, Atom o) -> bool
        __lt__(Atom self, Particle d) -> bool
        """
        return _IMP_atom.Atom___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Atom self, Atom o) -> bool
        __ge__(Atom self, Particle d) -> bool
        """
        return _IMP_atom.Atom___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Atom self, Atom o) -> bool
        __gt__(Atom self, Particle d) -> bool
        """
        return _IMP_atom.Atom___gt__(self, *args)


    def __hash__(self):
        """__hash__(Atom self) -> std::size_t"""
        return _IMP_atom.Atom___hash__(self)


    def __str__(self):
        """__str__(Atom self) -> std::string"""
        return _IMP_atom.Atom___str__(self)


    def __repr__(self):
        """__repr__(Atom self) -> std::string"""
        return _IMP_atom.Atom___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Atom
    __del__ = lambda self: None
Atom_swigregister = _IMP_atom.Atom_swigregister
Atom_swigregister(Atom)
cvar = _IMP_atom.cvar
AT_UNKNOWN = cvar.AT_UNKNOWN
AT_N = cvar.AT_N
AT_CA = cvar.AT_CA
AT_C = cvar.AT_C
AT_O = cvar.AT_O
AT_H = cvar.AT_H
AT_H1 = cvar.AT_H1
AT_H2 = cvar.AT_H2
AT_H3 = cvar.AT_H3
AT_HA = cvar.AT_HA
AT_HA1 = cvar.AT_HA1
AT_HA2 = cvar.AT_HA2
AT_HA3 = cvar.AT_HA3
AT_CB = cvar.AT_CB
AT_HB = cvar.AT_HB
AT_HB1 = cvar.AT_HB1
AT_HB2 = cvar.AT_HB2
AT_HB3 = cvar.AT_HB3
AT_OXT = cvar.AT_OXT
AT_CH3 = cvar.AT_CH3
AT_CH = cvar.AT_CH
AT_CG = cvar.AT_CG
AT_CG1 = cvar.AT_CG1
AT_CG2 = cvar.AT_CG2
AT_HG = cvar.AT_HG
AT_HG1 = cvar.AT_HG1
AT_HG2 = cvar.AT_HG2
AT_HG3 = cvar.AT_HG3
AT_HG11 = cvar.AT_HG11
AT_HG21 = cvar.AT_HG21
AT_HG31 = cvar.AT_HG31
AT_HG12 = cvar.AT_HG12
AT_HG13 = cvar.AT_HG13
AT_HG22 = cvar.AT_HG22
AT_HG23 = cvar.AT_HG23
AT_HG32 = cvar.AT_HG32
AT_OG = cvar.AT_OG
AT_OG1 = cvar.AT_OG1
AT_SG = cvar.AT_SG
AT_CD = cvar.AT_CD
AT_CD1 = cvar.AT_CD1
AT_CD2 = cvar.AT_CD2
AT_HD = cvar.AT_HD
AT_HD1 = cvar.AT_HD1
AT_HD2 = cvar.AT_HD2
AT_HD3 = cvar.AT_HD3
AT_HD11 = cvar.AT_HD11
AT_HD21 = cvar.AT_HD21
AT_HD31 = cvar.AT_HD31
AT_HD12 = cvar.AT_HD12
AT_HD13 = cvar.AT_HD13
AT_HD22 = cvar.AT_HD22
AT_HD23 = cvar.AT_HD23
AT_HD32 = cvar.AT_HD32
AT_SD = cvar.AT_SD
AT_OD1 = cvar.AT_OD1
AT_OD2 = cvar.AT_OD2
AT_ND1 = cvar.AT_ND1
AT_ND2 = cvar.AT_ND2
AT_CE = cvar.AT_CE
AT_CE1 = cvar.AT_CE1
AT_CE2 = cvar.AT_CE2
AT_CE3 = cvar.AT_CE3
AT_HE = cvar.AT_HE
AT_HE1 = cvar.AT_HE1
AT_HE2 = cvar.AT_HE2
AT_HE3 = cvar.AT_HE3
AT_HE21 = cvar.AT_HE21
AT_HE22 = cvar.AT_HE22
AT_OE1 = cvar.AT_OE1
AT_OE2 = cvar.AT_OE2
AT_NE = cvar.AT_NE
AT_NE1 = cvar.AT_NE1
AT_NE2 = cvar.AT_NE2
AT_CZ = cvar.AT_CZ
AT_CZ2 = cvar.AT_CZ2
AT_CZ3 = cvar.AT_CZ3
AT_NZ = cvar.AT_NZ
AT_HZ = cvar.AT_HZ
AT_HZ1 = cvar.AT_HZ1
AT_HZ2 = cvar.AT_HZ2
AT_HZ3 = cvar.AT_HZ3
AT_CH2 = cvar.AT_CH2
AT_NH1 = cvar.AT_NH1
AT_NH2 = cvar.AT_NH2
AT_OH = cvar.AT_OH
AT_HH = cvar.AT_HH
AT_HH11 = cvar.AT_HH11
AT_HH21 = cvar.AT_HH21
AT_HH2 = cvar.AT_HH2
AT_HH12 = cvar.AT_HH12
AT_HH22 = cvar.AT_HH22
AT_HH13 = cvar.AT_HH13
AT_HH23 = cvar.AT_HH23
AT_HH33 = cvar.AT_HH33
AT_P = cvar.AT_P
AT_OP1 = cvar.AT_OP1
AT_OP2 = cvar.AT_OP2
AT_OP3 = cvar.AT_OP3
AT_O5p = cvar.AT_O5p
AT_C5p = cvar.AT_C5p
AT_H5p = cvar.AT_H5p
AT_H5pp = cvar.AT_H5pp
AT_C4p = cvar.AT_C4p
AT_H4p = cvar.AT_H4p
AT_O4p = cvar.AT_O4p
AT_C1p = cvar.AT_C1p
AT_H1p = cvar.AT_H1p
AT_C3p = cvar.AT_C3p
AT_H3p = cvar.AT_H3p
AT_O3p = cvar.AT_O3p
AT_C2p = cvar.AT_C2p
AT_H2p = cvar.AT_H2p
AT_H2pp = cvar.AT_H2pp
AT_O2p = cvar.AT_O2p
AT_HO2p = cvar.AT_HO2p
AT_N9 = cvar.AT_N9
AT_C8 = cvar.AT_C8
AT_H8 = cvar.AT_H8
AT_N7 = cvar.AT_N7
AT_C5 = cvar.AT_C5
AT_C4 = cvar.AT_C4
AT_N3 = cvar.AT_N3
AT_C2 = cvar.AT_C2
AT_N1 = cvar.AT_N1
AT_C6 = cvar.AT_C6
AT_N6 = cvar.AT_N6
AT_H61 = cvar.AT_H61
AT_H62 = cvar.AT_H62
AT_O6 = cvar.AT_O6
AT_N2 = cvar.AT_N2
AT_NT = cvar.AT_NT
AT_H21 = cvar.AT_H21
AT_H22 = cvar.AT_H22
AT_H6 = cvar.AT_H6
AT_H5 = cvar.AT_H5
AT_O2 = cvar.AT_O2
AT_N4 = cvar.AT_N4
AT_H41 = cvar.AT_H41
AT_H42 = cvar.AT_H42
AT_O4 = cvar.AT_O4
AT_C7 = cvar.AT_C7
AT_H71 = cvar.AT_H71
AT_H72 = cvar.AT_H72
AT_H73 = cvar.AT_H73
AT_O1A = cvar.AT_O1A
AT_O2A = cvar.AT_O2A
AT_O3A = cvar.AT_O3A
AT_O1B = cvar.AT_O1B
AT_O2B = cvar.AT_O2B
AT_O3B = cvar.AT_O3B

def Atom_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, Atom other) -> Atom
    setup_particle(_ParticleAdaptor decorator, Atom other) -> Atom
    setup_particle(Model m, ParticleIndex pi, AtomType atom_type) -> Atom
    Atom_setup_particle(_ParticleAdaptor decorator, AtomType atom_type) -> Atom
    """
    return _IMP_atom.Atom_setup_particle(*args)

def Atom_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Atom_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Atom_get_is_setup(*args)

def Atom_get_atom_type_key():
    """Atom_get_atom_type_key() -> IntKey"""
    return _IMP_atom.Atom_get_atom_type_key()

def Atom_get_element_key():
    """Atom_get_element_key() -> IntKey"""
    return _IMP_atom.Atom_get_element_key()

def Atom_get_input_index_key():
    """Atom_get_input_index_key() -> IntKey"""
    return _IMP_atom.Atom_get_input_index_key()

def Atom_get_occupancy_key():
    """Atom_get_occupancy_key() -> FloatKey"""
    return _IMP_atom.Atom_get_occupancy_key()

def Atom_get_temperature_factor_key():
    """Atom_get_temperature_factor_key() -> FloatKey"""
    return _IMP_atom.Atom_get_temperature_factor_key()


def get_residue(*args):
    """
    get_residue(Hierarchy mhd, unsigned int index) -> Hierarchy
    get_residue(Atom d, bool nothrow=False) -> Residue
    get_residue(Atom d) -> Residue
    """
    return _IMP_atom.get_residue(*args)

def get_atom(rd, at):
    """get_atom(Residue rd, AtomType at) -> Atom"""
    return _IMP_atom.get_atom(rd, at)

def add_atom_type(name, e):
    """add_atom_type(std::string name, IMP::atom::Element e) -> AtomType"""
    return _IMP_atom.add_atom_type(name, e)

def get_element_for_atom_type(at):
    """get_element_for_atom_type(AtomType at) -> IMP::atom::Element"""
    return _IMP_atom.get_element_for_atom_type(at)

def get_atom_type_exists(name):
    """get_atom_type_exists(std::string name) -> bool"""
    return _IMP_atom.get_atom_type_exists(name)
class Residue(Hierarchy):
    """Proxy of C++ IMP::atom::Residue 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::atom::Residue self) -> Residue
        __init__(IMP::atom::Residue self, Model m, ParticleIndex id) -> Residue
        __init__(IMP::atom::Residue self, _ParticleAdaptor d) -> Residue
        """
        this = _IMP_atom.new_Residue(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Residue self, _ostream out)
        show(Residue self)
        """
        return _IMP_atom.Residue_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, ResidueType t, int index, int insertion_code) -> Residue
        setup_particle(_ParticleAdaptor decorator, ResidueType t, int index, int insertion_code) -> Residue
        setup_particle(Model m, ParticleIndex pi, ResidueType t, int index) -> Residue
        setup_particle(_ParticleAdaptor decorator, ResidueType t, int index) -> Residue
        setup_particle(Model m, ParticleIndex pi, ResidueType t) -> Residue
        setup_particle(_ParticleAdaptor decorator, ResidueType t) -> Residue
        setup_particle(Model m, ParticleIndex pi, Residue other) -> Residue
        setup_particle(_ParticleAdaptor decorator, Residue other) -> Residue
        """
        return _IMP_atom.Residue_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_atom.Residue_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_residue_type(self):
        """get_residue_type(Residue self) -> ResidueType"""
        return _IMP_atom.Residue_get_residue_type(self)


    def set_residue_type(self, t):
        """set_residue_type(Residue self, ResidueType t)"""
        return _IMP_atom.Residue_set_residue_type(self, t)


    def get_is_protein(self):
        """get_is_protein(Residue self) -> bool"""
        return _IMP_atom.Residue_get_is_protein(self)


    def get_is_dna(self):
        """get_is_dna(Residue self) -> bool"""
        return _IMP_atom.Residue_get_is_dna(self)


    def get_is_rna(self):
        """get_is_rna(Residue self) -> bool"""
        return _IMP_atom.Residue_get_is_rna(self)


    def get_index(self):
        """get_index(Residue self) -> IMP::Int"""
        return _IMP_atom.Residue_get_index(self)


    def set_index(self, t):
        """set_index(Residue self, IMP::Int t)"""
        return _IMP_atom.Residue_set_index(self, t)


    def get_insertion_code(self):
        """get_insertion_code(Residue self) -> char"""
        return _IMP_atom.Residue_get_insertion_code(self)


    def set_insertion_code(self, insertion_code):
        """set_insertion_code(Residue self, char insertion_code)"""
        return _IMP_atom.Residue_set_insertion_code(self, insertion_code)


    def get_index_key():
        """get_index_key() -> IntKey"""
        return _IMP_atom.Residue_get_index_key()

    get_index_key = staticmethod(get_index_key)

    def get_residue_type_key():
        """get_residue_type_key() -> IntKey"""
        return _IMP_atom.Residue_get_residue_type_key()

    get_residue_type_key = staticmethod(get_residue_type_key)

    def get_insertion_code_key():
        """get_insertion_code_key() -> IntKey"""
        return _IMP_atom.Residue_get_insertion_code_key()

    get_insertion_code_key = staticmethod(get_insertion_code_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Residue self, FloatKey a0)
        remove_attribute(Residue self, IntKey a0)
        remove_attribute(Residue self, StringKey a0)
        remove_attribute(Residue self, ParticleIndexKey a0)
        remove_attribute(Residue self, ObjectKey a0)
        """
        return _IMP_atom.Residue_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Residue self, FloatKey a0) -> bool
        has_attribute(Residue self, IntKey a0) -> bool
        has_attribute(Residue self, StringKey a0) -> bool
        has_attribute(Residue self, ParticleIndexKey a0) -> bool
        has_attribute(Residue self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Residue_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Residue self, FloatKey a0) -> double"""
        return _IMP_atom.Residue_get_derivative(self, a0)


    def get_name(self):
        """get_name(Residue self) -> std::string"""
        return _IMP_atom.Residue_get_name(self)


    def clear_caches(self):
        """clear_caches(Residue self)"""
        return _IMP_atom.Residue_clear_caches(self)


    def set_name(self, a0):
        """set_name(Residue self, std::string a0)"""
        return _IMP_atom.Residue_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Residue self, IMP::CheckLevel a0)"""
        return _IMP_atom.Residue_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Residue self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Residue_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Residue self, FloatKey a0, bool a1)"""
        return _IMP_atom.Residue_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Residue self, FloatKey a0) -> bool"""
        return _IMP_atom.Residue_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Residue self) -> IMP::CheckLevel"""
        return _IMP_atom.Residue_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Residue self, Residue o) -> bool
        __eq__(Residue self, Particle d) -> bool
        """
        return _IMP_atom.Residue___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Residue self, Residue o) -> bool
        __ne__(Residue self, Particle d) -> bool
        """
        return _IMP_atom.Residue___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Residue self, Residue o) -> bool
        __le__(Residue self, Particle d) -> bool
        """
        return _IMP_atom.Residue___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Residue self, Residue o) -> bool
        __lt__(Residue self, Particle d) -> bool
        """
        return _IMP_atom.Residue___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Residue self, Residue o) -> bool
        __ge__(Residue self, Particle d) -> bool
        """
        return _IMP_atom.Residue___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Residue self, Residue o) -> bool
        __gt__(Residue self, Particle d) -> bool
        """
        return _IMP_atom.Residue___gt__(self, *args)


    def __hash__(self):
        """__hash__(Residue self) -> std::size_t"""
        return _IMP_atom.Residue___hash__(self)


    def __str__(self):
        """__str__(Residue self) -> std::string"""
        return _IMP_atom.Residue___str__(self)


    def __repr__(self):
        """__repr__(Residue self) -> std::string"""
        return _IMP_atom.Residue___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Residue
    __del__ = lambda self: None
Residue_swigregister = _IMP_atom.Residue_swigregister
Residue_swigregister(Residue)
UNK = cvar.UNK
GLY = cvar.GLY
ALA = cvar.ALA
VAL = cvar.VAL
LEU = cvar.LEU
ILE = cvar.ILE
SER = cvar.SER
THR = cvar.THR
CYS = cvar.CYS
MET = cvar.MET
PRO = cvar.PRO
ASP = cvar.ASP
ASN = cvar.ASN
GLU = cvar.GLU
GLN = cvar.GLN
LYS = cvar.LYS
ARG = cvar.ARG
HIS = cvar.HIS
PHE = cvar.PHE
TYR = cvar.TYR
TRP = cvar.TRP
ACE = cvar.ACE
NH2 = cvar.NH2
ADE = cvar.ADE
URA = cvar.URA
CYT = cvar.CYT
GUA = cvar.GUA
THY = cvar.THY
DADE = cvar.DADE
DURA = cvar.DURA
DCYT = cvar.DCYT
DGUA = cvar.DGUA
DTHY = cvar.DTHY
HOH = cvar.HOH
HEME = cvar.HEME

def Residue_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, ResidueType t, int index, int insertion_code) -> Residue
    setup_particle(_ParticleAdaptor decorator, ResidueType t, int index, int insertion_code) -> Residue
    setup_particle(Model m, ParticleIndex pi, ResidueType t, int index) -> Residue
    setup_particle(_ParticleAdaptor decorator, ResidueType t, int index) -> Residue
    setup_particle(Model m, ParticleIndex pi, ResidueType t) -> Residue
    setup_particle(_ParticleAdaptor decorator, ResidueType t) -> Residue
    setup_particle(Model m, ParticleIndex pi, Residue other) -> Residue
    Residue_setup_particle(_ParticleAdaptor decorator, Residue other) -> Residue
    """
    return _IMP_atom.Residue_setup_particle(*args)

def Residue_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Residue_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Residue_get_is_setup(*args)

def Residue_get_index_key():
    """Residue_get_index_key() -> IntKey"""
    return _IMP_atom.Residue_get_index_key()

def Residue_get_residue_type_key():
    """Residue_get_residue_type_key() -> IntKey"""
    return _IMP_atom.Residue_get_residue_type_key()

def Residue_get_insertion_code_key():
    """Residue_get_insertion_code_key() -> IntKey"""
    return _IMP_atom.Residue_get_insertion_code_key()


def get_next_residue(rd):
    """get_next_residue(Residue rd) -> Hierarchy"""
    return _IMP_atom.get_next_residue(rd)

def get_previous_residue(rd):
    """get_previous_residue(Residue rd) -> Hierarchy"""
    return _IMP_atom.get_previous_residue(rd)

def get_one_letter_code(c):
    """get_one_letter_code(ResidueType c) -> char"""
    return _IMP_atom.get_one_letter_code(c)

_IMP_atom.BALLS_swigconstant(_IMP_atom)
BALLS = _IMP_atom.BALLS

_IMP_atom.DENSITIES_swigconstant(_IMP_atom)
DENSITIES = _IMP_atom.DENSITIES
class Representation(Hierarchy):
    """Proxy of C++ IMP::atom::Representation class."""

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

    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> Representation
        setup_particle(_ParticleAdaptor decorator) -> Representation
        setup_particle(Model m, ParticleIndex pi, double resolution) -> Representation
        setup_particle(_ParticleAdaptor decorator, double resolution) -> Representation
        """
        return _IMP_atom.Representation_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def __init__(self, *args):
        """
        __init__(IMP::atom::Representation self) -> Representation
        __init__(IMP::atom::Representation self, Model m, ParticleIndex id) -> Representation
        __init__(IMP::atom::Representation self, _ParticleAdaptor d) -> Representation
        """
        this = _IMP_atom.new_Representation(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Representation self, _ostream out)
        show(Representation self)
        """
        return _IMP_atom.Representation_show(self, *args)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_atom.Representation_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_representation(self, *args):
        """
        get_representation(Representation self, double resolution, IMP::atom::RepresentationType type) -> Hierarchy
        get_representation(Representation self, double resolution) -> Hierarchy
        """
        return _IMP_atom.Representation_get_representation(self, *args)


    def get_representations(self, *args):
        """
        get_representations(Representation self, IMP::atom::RepresentationType type) -> IMP::atom::Hierarchies
        get_representations(Representation self) -> IMP::atom::Hierarchies
        """
        return _IMP_atom.Representation_get_representations(self, *args)


    def add_representation(self, *args):
        """
        add_representation(Representation self, _ParticleIndexAdaptor rep, IMP::atom::RepresentationType type, double resolution=-1)
        add_representation(Representation self, _ParticleIndexAdaptor rep, IMP::atom::RepresentationType type)
        add_representation(Representation self, _ParticleIndexAdaptor rep)
        """
        return _IMP_atom.Representation_add_representation(self, *args)


    def get_resolutions(self, *args):
        """
        get_resolutions(Representation self, IMP::atom::RepresentationType type) -> IMP::Floats
        get_resolutions(Representation self) -> IMP::Floats
        """
        return _IMP_atom.Representation_get_resolutions(self, *args)


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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Representation self, FloatKey a0)
        remove_attribute(Representation self, IntKey a0)
        remove_attribute(Representation self, StringKey a0)
        remove_attribute(Representation self, ParticleIndexKey a0)
        remove_attribute(Representation self, ObjectKey a0)
        """
        return _IMP_atom.Representation_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Representation self, FloatKey a0) -> bool
        has_attribute(Representation self, IntKey a0) -> bool
        has_attribute(Representation self, StringKey a0) -> bool
        has_attribute(Representation self, ParticleIndexKey a0) -> bool
        has_attribute(Representation self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Representation_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Representation self, FloatKey a0) -> double"""
        return _IMP_atom.Representation_get_derivative(self, a0)


    def get_name(self):
        """get_name(Representation self) -> std::string"""
        return _IMP_atom.Representation_get_name(self)


    def clear_caches(self):
        """clear_caches(Representation self)"""
        return _IMP_atom.Representation_clear_caches(self)


    def set_name(self, a0):
        """set_name(Representation self, std::string a0)"""
        return _IMP_atom.Representation_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Representation self, IMP::CheckLevel a0)"""
        return _IMP_atom.Representation_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Representation self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Representation_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Representation self, FloatKey a0, bool a1)"""
        return _IMP_atom.Representation_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Representation self, FloatKey a0) -> bool"""
        return _IMP_atom.Representation_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Representation self) -> IMP::CheckLevel"""
        return _IMP_atom.Representation_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Representation self, Representation o) -> bool
        __eq__(Representation self, Particle d) -> bool
        """
        return _IMP_atom.Representation___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Representation self, Representation o) -> bool
        __ne__(Representation self, Particle d) -> bool
        """
        return _IMP_atom.Representation___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Representation self, Representation o) -> bool
        __le__(Representation self, Particle d) -> bool
        """
        return _IMP_atom.Representation___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Representation self, Representation o) -> bool
        __lt__(Representation self, Particle d) -> bool
        """
        return _IMP_atom.Representation___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Representation self, Representation o) -> bool
        __ge__(Representation self, Particle d) -> bool
        """
        return _IMP_atom.Representation___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Representation self, Representation o) -> bool
        __gt__(Representation self, Particle d) -> bool
        """
        return _IMP_atom.Representation___gt__(self, *args)


    def __hash__(self):
        """__hash__(Representation self) -> std::size_t"""
        return _IMP_atom.Representation___hash__(self)


    def __str__(self):
        """__str__(Representation self) -> std::string"""
        return _IMP_atom.Representation___str__(self)


    def __repr__(self):
        """__repr__(Representation self) -> std::string"""
        return _IMP_atom.Representation___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Representation
    __del__ = lambda self: None
Representation_swigregister = _IMP_atom.Representation_swigregister
Representation_swigregister(Representation)
ALL_RESOLUTIONS = cvar.ALL_RESOLUTIONS

def Representation_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> Representation
    setup_particle(_ParticleAdaptor decorator) -> Representation
    setup_particle(Model m, ParticleIndex pi, double resolution) -> Representation
    Representation_setup_particle(_ParticleAdaptor decorator, double resolution) -> Representation
    """
    return _IMP_atom.Representation_setup_particle(*args)

def Representation_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Representation_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Representation_get_is_setup(*args)


def get_resolution(*args):
    """
    get_resolution(Model m, ParticleIndex pi) -> double
    get_resolution(Hierarchy h) -> double
    """
    return _IMP_atom.get_resolution(*args)

def get_representation(h, nothrow=False):
    """
    get_representation(Hierarchy h, bool nothrow=False) -> Representation
    get_representation(Hierarchy h) -> Representation
    """
    return _IMP_atom.get_representation(h, nothrow)

def show_with_representations(*args):
    """
    show_with_representations(Hierarchy h, _ostream out)
    show_with_representations(Hierarchy h)
    """
    return _IMP_atom.show_with_representations(*args)
class State(Hierarchy):
    """Proxy of C++ IMP::atom::State class."""

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

    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, unsigned int index) -> State
        setup_particle(_ParticleAdaptor decorator, unsigned int index) -> State
        """
        return _IMP_atom.State_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def __init__(self, *args):
        """
        __init__(IMP::atom::State self) -> State
        __init__(IMP::atom::State self, Model m, ParticleIndex id) -> State
        __init__(IMP::atom::State self, _ParticleAdaptor d) -> State
        """
        this = _IMP_atom.new_State(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(State self, _ostream out)
        show(State self)
        """
        return _IMP_atom.State_show(self, *args)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_atom.State_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_state_index(self):
        """get_state_index(State self) -> unsigned int"""
        return _IMP_atom.State_get_state_index(self)


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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(State self, FloatKey a0)
        remove_attribute(State self, IntKey a0)
        remove_attribute(State self, StringKey a0)
        remove_attribute(State self, ParticleIndexKey a0)
        remove_attribute(State self, ObjectKey a0)
        """
        return _IMP_atom.State_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(State self, FloatKey a0) -> bool
        has_attribute(State self, IntKey a0) -> bool
        has_attribute(State self, StringKey a0) -> bool
        has_attribute(State self, ParticleIndexKey a0) -> bool
        has_attribute(State self, ObjectKey a0) -> bool
        """
        return _IMP_atom.State_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(State self, FloatKey a0) -> double"""
        return _IMP_atom.State_get_derivative(self, a0)


    def get_name(self):
        """get_name(State self) -> std::string"""
        return _IMP_atom.State_get_name(self)


    def clear_caches(self):
        """clear_caches(State self)"""
        return _IMP_atom.State_clear_caches(self)


    def set_name(self, a0):
        """set_name(State self, std::string a0)"""
        return _IMP_atom.State_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(State self, IMP::CheckLevel a0)"""
        return _IMP_atom.State_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(State self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.State_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(State self, FloatKey a0, bool a1)"""
        return _IMP_atom.State_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(State self, FloatKey a0) -> bool"""
        return _IMP_atom.State_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(State self) -> IMP::CheckLevel"""
        return _IMP_atom.State_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(State self, State o) -> bool
        __eq__(State self, Particle d) -> bool
        """
        return _IMP_atom.State___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(State self, State o) -> bool
        __ne__(State self, Particle d) -> bool
        """
        return _IMP_atom.State___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(State self, State o) -> bool
        __le__(State self, Particle d) -> bool
        """
        return _IMP_atom.State___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(State self, State o) -> bool
        __lt__(State self, Particle d) -> bool
        """
        return _IMP_atom.State___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(State self, State o) -> bool
        __ge__(State self, Particle d) -> bool
        """
        return _IMP_atom.State___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(State self, State o) -> bool
        __gt__(State self, Particle d) -> bool
        """
        return _IMP_atom.State___gt__(self, *args)


    def __hash__(self):
        """__hash__(State self) -> std::size_t"""
        return _IMP_atom.State___hash__(self)


    def __str__(self):
        """__str__(State self) -> std::string"""
        return _IMP_atom.State___str__(self)


    def __repr__(self):
        """__repr__(State self) -> std::string"""
        return _IMP_atom.State___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_State
    __del__ = lambda self: None
State_swigregister = _IMP_atom.State_swigregister
State_swigregister(State)

def State_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, unsigned int index) -> State
    State_setup_particle(_ParticleAdaptor decorator, unsigned int index) -> State
    """
    return _IMP_atom.State_setup_particle(*args)

def State_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    State_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.State_get_is_setup(*args)


def get_state_index(h):
    """get_state_index(Hierarchy h) -> int"""
    return _IMP_atom.get_state_index(h)

def get_phi_dihedral_atoms(rd):
    """get_phi_dihedral_atoms(Residue rd) -> IMP::atom::Atoms"""
    return _IMP_atom.get_phi_dihedral_atoms(rd)

def get_psi_dihedral_atoms(rd):
    """get_psi_dihedral_atoms(Residue rd) -> IMP::atom::Atoms"""
    return _IMP_atom.get_psi_dihedral_atoms(rd)
class Molecule(Hierarchy):
    """Proxy of C++ IMP::atom::Molecule 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::atom::Molecule self) -> Molecule
        __init__(IMP::atom::Molecule self, Model m, ParticleIndex id) -> Molecule
        __init__(IMP::atom::Molecule self, _ParticleAdaptor d) -> Molecule
        """
        this = _IMP_atom.new_Molecule(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Molecule self, _ostream out)
        show(Molecule self)
        """
        return _IMP_atom.Molecule_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi) -> Molecule
        setup_particle(_ParticleAdaptor decorator) -> Molecule
        setup_particle(Model m, ParticleIndex pi, Molecule other) -> Molecule
        setup_particle(_ParticleAdaptor decorator, Molecule other) -> Molecule
        """
        return _IMP_atom.Molecule_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_atom.Molecule_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Molecule self, FloatKey a0)
        remove_attribute(Molecule self, IntKey a0)
        remove_attribute(Molecule self, StringKey a0)
        remove_attribute(Molecule self, ParticleIndexKey a0)
        remove_attribute(Molecule self, ObjectKey a0)
        """
        return _IMP_atom.Molecule_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Molecule self, FloatKey a0) -> bool
        has_attribute(Molecule self, IntKey a0) -> bool
        has_attribute(Molecule self, StringKey a0) -> bool
        has_attribute(Molecule self, ParticleIndexKey a0) -> bool
        has_attribute(Molecule self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Molecule_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Molecule self, FloatKey a0) -> double"""
        return _IMP_atom.Molecule_get_derivative(self, a0)


    def get_name(self):
        """get_name(Molecule self) -> std::string"""
        return _IMP_atom.Molecule_get_name(self)


    def clear_caches(self):
        """clear_caches(Molecule self)"""
        return _IMP_atom.Molecule_clear_caches(self)


    def set_name(self, a0):
        """set_name(Molecule self, std::string a0)"""
        return _IMP_atom.Molecule_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Molecule self, IMP::CheckLevel a0)"""
        return _IMP_atom.Molecule_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Molecule self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Molecule_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Molecule self, FloatKey a0, bool a1)"""
        return _IMP_atom.Molecule_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Molecule self, FloatKey a0) -> bool"""
        return _IMP_atom.Molecule_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Molecule self) -> IMP::CheckLevel"""
        return _IMP_atom.Molecule_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Molecule self, Molecule o) -> bool
        __eq__(Molecule self, Particle d) -> bool
        """
        return _IMP_atom.Molecule___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Molecule self, Molecule o) -> bool
        __ne__(Molecule self, Particle d) -> bool
        """
        return _IMP_atom.Molecule___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Molecule self, Molecule o) -> bool
        __le__(Molecule self, Particle d) -> bool
        """
        return _IMP_atom.Molecule___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Molecule self, Molecule o) -> bool
        __lt__(Molecule self, Particle d) -> bool
        """
        return _IMP_atom.Molecule___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Molecule self, Molecule o) -> bool
        __ge__(Molecule self, Particle d) -> bool
        """
        return _IMP_atom.Molecule___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Molecule self, Molecule o) -> bool
        __gt__(Molecule self, Particle d) -> bool
        """
        return _IMP_atom.Molecule___gt__(self, *args)


    def __hash__(self):
        """__hash__(Molecule self) -> std::size_t"""
        return _IMP_atom.Molecule___hash__(self)


    def __str__(self):
        """__str__(Molecule self) -> std::string"""
        return _IMP_atom.Molecule___str__(self)


    def __repr__(self):
        """__repr__(Molecule self) -> std::string"""
        return _IMP_atom.Molecule___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Molecule
    __del__ = lambda self: None
Molecule_swigregister = _IMP_atom.Molecule_swigregister
Molecule_swigregister(Molecule)

def Molecule_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi) -> Molecule
    setup_particle(_ParticleAdaptor decorator) -> Molecule
    setup_particle(Model m, ParticleIndex pi, Molecule other) -> Molecule
    Molecule_setup_particle(_ParticleAdaptor decorator, Molecule other) -> Molecule
    """
    return _IMP_atom.Molecule_setup_particle(*args)

def Molecule_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Molecule_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Molecule_get_is_setup(*args)


def get_molecule_name(h):
    """get_molecule_name(Hierarchy h) -> std::string"""
    return _IMP_atom.get_molecule_name(h)
class Copy(Molecule):
    """Proxy of C++ IMP::atom::Copy class."""

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

    def get_copy_index_key():
        """get_copy_index_key() -> IntKey"""
        return _IMP_atom.Copy_get_copy_index_key()

    get_copy_index_key = staticmethod(get_copy_index_key)

    def __init__(self, *args):
        """
        __init__(IMP::atom::Copy self) -> Copy
        __init__(IMP::atom::Copy self, Model m, ParticleIndex id) -> Copy
        __init__(IMP::atom::Copy self, _ParticleAdaptor d) -> Copy
        """
        this = _IMP_atom.new_Copy(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(Copy self, _ostream out)
        show(Copy self)
        """
        return _IMP_atom.Copy_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, IMP::Int number) -> Copy
        setup_particle(_ParticleAdaptor decorator, IMP::Int number) -> Copy
        """
        return _IMP_atom.Copy_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_atom.Copy_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_copy_index(self):
        """get_copy_index(Copy self) -> int"""
        return _IMP_atom.Copy_get_copy_index(self)


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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(Copy self, FloatKey a0)
        remove_attribute(Copy self, IntKey a0)
        remove_attribute(Copy self, StringKey a0)
        remove_attribute(Copy self, ParticleIndexKey a0)
        remove_attribute(Copy self, ObjectKey a0)
        """
        return _IMP_atom.Copy_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(Copy self, FloatKey a0) -> bool
        has_attribute(Copy self, IntKey a0) -> bool
        has_attribute(Copy self, StringKey a0) -> bool
        has_attribute(Copy self, ParticleIndexKey a0) -> bool
        has_attribute(Copy self, ObjectKey a0) -> bool
        """
        return _IMP_atom.Copy_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(Copy self, FloatKey a0) -> double"""
        return _IMP_atom.Copy_get_derivative(self, a0)


    def get_name(self):
        """get_name(Copy self) -> std::string"""
        return _IMP_atom.Copy_get_name(self)


    def clear_caches(self):
        """clear_caches(Copy self)"""
        return _IMP_atom.Copy_clear_caches(self)


    def set_name(self, a0):
        """set_name(Copy self, std::string a0)"""
        return _IMP_atom.Copy_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(Copy self, IMP::CheckLevel a0)"""
        return _IMP_atom.Copy_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(Copy self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Copy_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(Copy self, FloatKey a0, bool a1)"""
        return _IMP_atom.Copy_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(Copy self, FloatKey a0) -> bool"""
        return _IMP_atom.Copy_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(Copy self) -> IMP::CheckLevel"""
        return _IMP_atom.Copy_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(Copy self, Copy o) -> bool
        __eq__(Copy self, Particle d) -> bool
        """
        return _IMP_atom.Copy___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(Copy self, Copy o) -> bool
        __ne__(Copy self, Particle d) -> bool
        """
        return _IMP_atom.Copy___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(Copy self, Copy o) -> bool
        __le__(Copy self, Particle d) -> bool
        """
        return _IMP_atom.Copy___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(Copy self, Copy o) -> bool
        __lt__(Copy self, Particle d) -> bool
        """
        return _IMP_atom.Copy___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(Copy self, Copy o) -> bool
        __ge__(Copy self, Particle d) -> bool
        """
        return _IMP_atom.Copy___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(Copy self, Copy o) -> bool
        __gt__(Copy self, Particle d) -> bool
        """
        return _IMP_atom.Copy___gt__(self, *args)


    def __hash__(self):
        """__hash__(Copy self) -> std::size_t"""
        return _IMP_atom.Copy___hash__(self)


    def __str__(self):
        """__str__(Copy self) -> std::string"""
        return _IMP_atom.Copy___str__(self)


    def __repr__(self):
        """__repr__(Copy self) -> std::string"""
        return _IMP_atom.Copy___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_Copy
    __del__ = lambda self: None
Copy_swigregister = _IMP_atom.Copy_swigregister
Copy_swigregister(Copy)

def Copy_get_copy_index_key():
    """Copy_get_copy_index_key() -> IntKey"""
    return _IMP_atom.Copy_get_copy_index_key()

def Copy_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, IMP::Int number) -> Copy
    Copy_setup_particle(_ParticleAdaptor decorator, IMP::Int number) -> Copy
    """
    return _IMP_atom.Copy_setup_particle(*args)

def Copy_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    Copy_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.Copy_get_is_setup(*args)


def get_copy_index(h):
    """get_copy_index(Hierarchy h) -> int"""
    return _IMP_atom.get_copy_index(h)
class Selection(IMP._ParticleIndexesAdaptor):
    """Proxy of C++ IMP::atom::Selection class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    NONE = _IMP_atom.Selection_NONE
    C = _IMP_atom.Selection_C
    N = _IMP_atom.Selection_N

    def __init__(self, *args):
        """
        __init__(IMP::atom::Selection self) -> Selection
        __init__(IMP::atom::Selection self, Hierarchy h) -> Selection
        __init__(IMP::atom::Selection self, Particle h) -> Selection
        __init__(IMP::atom::Selection self, Model m, IMP::ParticleIndexes const & pis) -> Selection
        __init__(IMP::atom::Selection self, IMP::ParticlesTemp const & h) -> Selection
        """
        this = _IMP_atom.new_Selection(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def create_clone(self):
        """create_clone(Selection self) -> Selection"""
        return _IMP_atom.Selection_create_clone(self)


    def get_hierarchies(self):
        """get_hierarchies(Selection self) -> IMP::atom::Hierarchies"""
        return _IMP_atom.Selection_get_hierarchies(self)


    def set_molecules(self, mols):
        """set_molecules(Selection self, IMP::Strings mols)"""
        return _IMP_atom.Selection_set_molecules(self, mols)


    def set_resolution(self, r):
        """set_resolution(Selection self, double r)"""
        return _IMP_atom.Selection_set_resolution(self, r)


    def set_representation_type(self, t):
        """set_representation_type(Selection self, IMP::atom::RepresentationType t)"""
        return _IMP_atom.Selection_set_representation_type(self, t)


    def set_state_index(self, state):
        """set_state_index(Selection self, int state)"""
        return _IMP_atom.Selection_set_state_index(self, state)


    def set_state_indexes(self, states):
        """set_state_indexes(Selection self, IMP::Ints states)"""
        return _IMP_atom.Selection_set_state_indexes(self, states)


    def set_terminus(self, t):
        """set_terminus(Selection self, IMP::atom::Selection::Terminus t)"""
        return _IMP_atom.Selection_set_terminus(self, t)


    def set_element(self, e):
        """set_element(Selection self, IMP::atom::Element e)"""
        return _IMP_atom.Selection_set_element(self, e)


    def set_chain_ids(self, chains):
        """set_chain_ids(Selection self, IMP::Strings chains)"""
        return _IMP_atom.Selection_set_chain_ids(self, chains)


    def set_chains(self, chains):
        """set_chains(Selection self, IMP::Strings chains)"""
        return _IMP_atom.Selection_set_chains(self, chains)


    def set_residue_indexes(self, indexes):
        """set_residue_indexes(Selection self, IMP::Ints indexes)"""
        return _IMP_atom.Selection_set_residue_indexes(self, indexes)


    def set_atom_types(self, types):
        """set_atom_types(Selection self, IMP::atom::AtomTypes types)"""
        return _IMP_atom.Selection_set_atom_types(self, types)


    def set_residue_types(self, types):
        """set_residue_types(Selection self, IMP::atom::ResidueTypes types)"""
        return _IMP_atom.Selection_set_residue_types(self, types)


    def set_domains(self, names):
        """set_domains(Selection self, IMP::Strings names)"""
        return _IMP_atom.Selection_set_domains(self, names)


    def set_molecule(self, mol):
        """set_molecule(Selection self, std::string mol)"""
        return _IMP_atom.Selection_set_molecule(self, mol)


    def set_chain_id(self, c):
        """set_chain_id(Selection self, std::string c)"""
        return _IMP_atom.Selection_set_chain_id(self, c)


    def set_chain(self, c):
        """set_chain(Selection self, std::string c)"""
        return _IMP_atom.Selection_set_chain(self, c)


    def set_residue_index(self, i):
        """set_residue_index(Selection self, int i)"""
        return _IMP_atom.Selection_set_residue_index(self, i)


    def set_atom_type(self, types):
        """set_atom_type(Selection self, AtomType types)"""
        return _IMP_atom.Selection_set_atom_type(self, types)


    def set_residue_type(self, type):
        """set_residue_type(Selection self, ResidueType type)"""
        return _IMP_atom.Selection_set_residue_type(self, type)


    def set_domain(self, name):
        """set_domain(Selection self, std::string name)"""
        return _IMP_atom.Selection_set_domain(self, name)


    def set_copy_index(self, copy):
        """set_copy_index(Selection self, unsigned int copy)"""
        return _IMP_atom.Selection_set_copy_index(self, copy)


    def set_copy_indexes(self, copies):
        """set_copy_indexes(Selection self, IMP::Ints copies)"""
        return _IMP_atom.Selection_set_copy_indexes(self, copies)


    def set_particle_type(self, t):
        """set_particle_type(Selection self, ParticleType t)"""
        return _IMP_atom.Selection_set_particle_type(self, t)


    def set_particle_types(self, t):
        """set_particle_types(Selection self, IMP::core::ParticleTypes t)"""
        return _IMP_atom.Selection_set_particle_types(self, t)


    def set_hierarchy_types(self, types):
        """set_hierarchy_types(Selection self, IMP::Ints types)"""
        return _IMP_atom.Selection_set_hierarchy_types(self, types)


    def set_intersection(self, s):
        """set_intersection(Selection self, Selection s)"""
        return _IMP_atom.Selection_set_intersection(self, s)


    def set_union(self, s):
        """set_union(Selection self, Selection s)"""
        return _IMP_atom.Selection_set_union(self, s)


    def set_symmetric_difference(self, s):
        """set_symmetric_difference(Selection self, Selection s)"""
        return _IMP_atom.Selection_set_symmetric_difference(self, s)


    def set_difference(self, s):
        """set_difference(Selection self, Selection s)"""
        return _IMP_atom.Selection_set_difference(self, s)


    def get_selected_particles(self, with_representation=True):
        """
        get_selected_particles(Selection self, bool with_representation=True) -> IMP::ParticlesTemp
        get_selected_particles(Selection self) -> IMP::ParticlesTemp
        """
        return _IMP_atom.Selection_get_selected_particles(self, with_representation)


    def get_selected_particle_indexes(self, with_representation=True):
        """
        get_selected_particle_indexes(Selection self, bool with_representation=True) -> IMP::ParticleIndexes
        get_selected_particle_indexes(Selection self) -> IMP::ParticleIndexes
        """
        return _IMP_atom.Selection_get_selected_particle_indexes(self, with_representation)


    def show(self, *args):
        """
        show(Selection self, _ostream out)
        show(Selection self)
        """
        return _IMP_atom.Selection_show(self, *args)


    def __str__(self):
        """__str__(Selection self) -> std::string"""
        return _IMP_atom.Selection___str__(self)


    def __repr__(self):
        """__repr__(Selection self) -> std::string"""
        return _IMP_atom.Selection___repr__(self)


    def __init__(self, hierarchy=None,
                 hierarchies=None, **params):
        if hierarchy and hierarchies:
          raise RuntimeError("You can't pass both hierarchy and hierarchies to Selection")
        if hierarchy:
          this = _IMP_atom.new_Selection(hierarchy)
          try: self.this.append(this)
          except: self.this = this
        elif hierarchies:
          this = _IMP_atom.new_Selection(hierarchies)
          try: self.this.append(this)
          except: self.this = this
        else:
          raise ValueError("Either hierarchy or hierarchies must be provided.")
        for k in params.keys():
          eval("self.set_%s(params[k])"%k)

    def union(self, s):
        news = self.create_clone()
        news.union_update(s)
        return news
    def intersection(self, s):
        news = self.create_clone()
        news.intersection_update(s)
        return news
    def symmetric_difference(self, s):
        news = self.create_clone()
        news.symmetric_difference_update(s)
        return news
    def difference(self, s):
        news = self.create_clone()
        news.difference_update(s)
        return news
    def union_update(self, s):
        self.set_union(s)
        return self
    def intersection_update(self, s):
        self.set_intersection(s)
        return self
    def symmetric_difference_update(self, s):
        self.set_symmetric_difference(s)
        return self
    def difference_update(self, s):
        self.set_difference(s)
        return self
    __or__ = union
    __and__ = intersection
    __xor__ = symmetric_difference
    __sub__ = difference
    __ior__ = union_update
    __iand__ = intersection_update
    __ixor__ = symmetric_difference_update
    __isub__ = difference_update

    __swig_destroy__ = _IMP_atom.delete_Selection
    __del__ = lambda self: None
Selection_swigregister = _IMP_atom.Selection_swigregister
Selection_swigregister(Selection)


def create_distance_restraint(*args):
    """
    create_distance_restraint(Selection n0, Selection n1, double x0, double k, std::string name) -> Restraint
    create_distance_restraint(Selection n0, Selection n1, double x0, double k) -> Restraint
    """
    return _IMP_atom.create_distance_restraint(*args)

def create_connectivity_restraint(*args):
    """
    create_connectivity_restraint(IMP::atom::Selections const & s, double k, std::string name) -> Restraint
    create_connectivity_restraint(IMP::atom::Selections const & s, double k) -> Restraint
    create_connectivity_restraint(IMP::atom::Selections const & s, double x0, double k, std::string name) -> Restraint
    create_connectivity_restraint(IMP::atom::Selections const & s, double x0, double k) -> Restraint
    """
    return _IMP_atom.create_connectivity_restraint(*args)

def create_internal_connectivity_restraint(*args):
    """
    create_internal_connectivity_restraint(Selection s, double k, std::string name) -> Restraint
    create_internal_connectivity_restraint(Selection s, double k) -> Restraint
    create_internal_connectivity_restraint(Selection s, double x0, double k, std::string name) -> Restraint
    create_internal_connectivity_restraint(Selection s, double x0, double k) -> Restraint
    """
    return _IMP_atom.create_internal_connectivity_restraint(*args)

def create_cover(*args):
    """
    create_cover(Selection s, std::string name) -> XYZR
    create_cover(Selection s) -> XYZR
    """
    return _IMP_atom.create_cover(*args)

def get_mass(*args):
    """
    get_mass(ResidueType c) -> double
    get_mass(Selection s) -> double
    """
    return _IMP_atom.get_mass(*args)

def get_volume(s):
    """get_volume(Selection s) -> double"""
    return _IMP_atom.get_volume(s)

def get_surface_area(s):
    """get_surface_area(Selection s) -> double"""
    return _IMP_atom.get_surface_area(s)

def get_leaves(*args):
    """
    get_leaves(Hierarchy h) -> IMP::atom::Hierarchies
    get_leaves(IMP::atom::Hierarchies const & h) -> IMP::atom::Hierarchies
    get_leaves(Selection h) -> IMP::atom::Hierarchies
    """
    return _IMP_atom.get_leaves(*args)
class SelectionGeometry(IMP.display.Geometry):
    """Proxy of C++ IMP::atom::SelectionGeometry 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::atom::SelectionGeometry self, Selection d, std::string name) -> SelectionGeometry
        __init__(IMP::atom::SelectionGeometry self, Selection d) -> SelectionGeometry
        """
        this = _IMP_atom.new_SelectionGeometry(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(SelectionGeometry self) -> VersionInfo"""
        return _IMP_atom.SelectionGeometry_get_version_info(self)


    def __str__(self):
        """__str__(SelectionGeometry self) -> std::string"""
        return _IMP_atom.SelectionGeometry___str__(self)


    def __repr__(self):
        """__repr__(SelectionGeometry self) -> std::string"""
        return _IMP_atom.SelectionGeometry___repr__(self)


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

SelectionGeometry_swigregister = _IMP_atom.SelectionGeometry_swigregister
SelectionGeometry_swigregister(SelectionGeometry)


def get_rmsd(*args):
    """
    get_rmsd(IMP::core::XYZs const & s0, IMP::core::XYZs const & s1) -> double
    get_rmsd(Selection s0, Selection s1) -> double
    """
    return _IMP_atom.get_rmsd(*args)

def get_rmsd_transforming_first(*args):
    """
    get_rmsd_transforming_first(Transformation3D tr, IMP::core::XYZs const & s0, IMP::core::XYZs const & s1) -> double
    get_rmsd_transforming_first(Transformation3D tr, Selection s0, Selection s1) -> double
    """
    return _IMP_atom.get_rmsd_transforming_first(*args)

def get_placement_score(source, target):
    """get_placement_score(IMP::core::XYZs const & source, IMP::core::XYZs const & target) -> IMP::FloatPair"""
    return _IMP_atom.get_placement_score(source, target)

def get_component_placement_score(ref1, ref2, mdl1, mdl2):
    """get_component_placement_score(IMP::core::XYZs const & ref1, IMP::core::XYZs const & ref2, IMP::core::XYZs const & mdl1, IMP::core::XYZs const & mdl2) -> IMP::FloatPair"""
    return _IMP_atom.get_component_placement_score(ref1, ref2, mdl1, mdl2)

def get_pairwise_rmsd_score(ref1, ref2, mdl1, mdl2):
    """get_pairwise_rmsd_score(IMP::core::XYZs const & ref1, IMP::core::XYZs const & ref2, IMP::core::XYZs const & mdl1, IMP::core::XYZs const & mdl2) -> double"""
    return _IMP_atom.get_pairwise_rmsd_score(ref1, ref2, mdl1, mdl2)

def get_radius_of_gyration(*args):
    """
    get_radius_of_gyration(Selection s) -> double
    get_radius_of_gyration(IMP::ParticlesTemp const & ps) -> double
    """
    return _IMP_atom.get_radius_of_gyration(*args)
class ForceFieldParameters(IMP.Object):
    """Proxy of C++ IMP::atom::ForceFieldParameters 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::atom::ForceFieldParameters self) -> ForceFieldParameters"""
        this = _IMP_atom.new_ForceFieldParameters()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_radius(self, atom):
        """get_radius(ForceFieldParameters self, Atom atom) -> IMP::Float"""
        return _IMP_atom.ForceFieldParameters_get_radius(self, atom)


    def get_epsilon(self, atom):
        """get_epsilon(ForceFieldParameters self, Atom atom) -> IMP::Float"""
        return _IMP_atom.ForceFieldParameters_get_epsilon(self, atom)


    def add_radii(self, *args):
        """
        add_radii(ForceFieldParameters self, Hierarchy mhd, double scale=1.0, FloatKey radius_key)
        add_radii(ForceFieldParameters self, Hierarchy mhd, double scale=1.0)
        add_radii(ForceFieldParameters self, Hierarchy mhd)
        """
        return _IMP_atom.ForceFieldParameters_add_radii(self, *args)


    def add_well_depths(self, mhd):
        """add_well_depths(ForceFieldParameters self, Hierarchy mhd)"""
        return _IMP_atom.ForceFieldParameters_add_well_depths(self, mhd)


    def add_bonds(self, mhd):
        """add_bonds(ForceFieldParameters self, Hierarchy mhd)"""
        return _IMP_atom.ForceFieldParameters_add_bonds(self, mhd)

    __swig_destroy__ = _IMP_atom.delete_ForceFieldParameters
    __del__ = lambda self: None

    def __str__(self):
        """__str__(ForceFieldParameters self) -> std::string"""
        return _IMP_atom.ForceFieldParameters___str__(self)


    def __repr__(self):
        """__repr__(ForceFieldParameters self) -> std::string"""
        return _IMP_atom.ForceFieldParameters___repr__(self)


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

ForceFieldParameters_swigregister = _IMP_atom.ForceFieldParameters_swigregister
ForceFieldParameters_swigregister(ForceFieldParameters)

class CHARMMAtomTopology(object):
    """Proxy of C++ IMP::atom::CHARMMAtomTopology 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::atom::CHARMMAtomTopology self, std::string name) -> CHARMMAtomTopology
        __init__(IMP::atom::CHARMMAtomTopology self, std::string name, CHARMMAtomTopology other) -> CHARMMAtomTopology
        """
        this = _IMP_atom.new_CHARMMAtomTopology(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_name(self):
        """get_name(CHARMMAtomTopology self) -> std::string"""
        return _IMP_atom.CHARMMAtomTopology_get_name(self)


    def get_charmm_type(self):
        """get_charmm_type(CHARMMAtomTopology self) -> std::string"""
        return _IMP_atom.CHARMMAtomTopology_get_charmm_type(self)


    def get_charge(self):
        """get_charge(CHARMMAtomTopology self) -> double"""
        return _IMP_atom.CHARMMAtomTopology_get_charge(self)


    def set_charmm_type(self, charmm_type):
        """set_charmm_type(CHARMMAtomTopology self, std::string charmm_type)"""
        return _IMP_atom.CHARMMAtomTopology_set_charmm_type(self, charmm_type)


    def set_charge(self, charge):
        """set_charge(CHARMMAtomTopology self, double charge)"""
        return _IMP_atom.CHARMMAtomTopology_set_charge(self, charge)


    def show(self, *args):
        """
        show(CHARMMAtomTopology self, _ostream out)
        show(CHARMMAtomTopology self)
        """
        return _IMP_atom.CHARMMAtomTopology_show(self, *args)


    def __str__(self):
        """__str__(CHARMMAtomTopology self) -> std::string"""
        return _IMP_atom.CHARMMAtomTopology___str__(self)


    def __repr__(self):
        """__repr__(CHARMMAtomTopology self) -> std::string"""
        return _IMP_atom.CHARMMAtomTopology___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_CHARMMAtomTopology
    __del__ = lambda self: None
CHARMMAtomTopology_swigregister = _IMP_atom.CHARMMAtomTopology_swigregister
CHARMMAtomTopology_swigregister(CHARMMAtomTopology)

class CHARMMBondEndpoint(object):
    """Proxy of C++ IMP::atom::CHARMMBondEndpoint class."""

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

    def __init__(self, atom_name, residue=None):
        """
        __init__(IMP::atom::CHARMMBondEndpoint self, std::string atom_name, CHARMMResidueTopology residue=None) -> CHARMMBondEndpoint
        __init__(IMP::atom::CHARMMBondEndpoint self, std::string atom_name) -> CHARMMBondEndpoint
        """
        this = _IMP_atom.new_CHARMMBondEndpoint(atom_name, residue)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_atom_name(self):
        """get_atom_name(CHARMMBondEndpoint self) -> std::string"""
        return _IMP_atom.CHARMMBondEndpoint_get_atom_name(self)


    def get_atom(self, current_residue, previous_residue, next_residue, resmap):
        """get_atom(CHARMMBondEndpoint self, CHARMMResidueTopology current_residue, CHARMMResidueTopology previous_residue, CHARMMResidueTopology next_residue, std::map< IMP::atom::CHARMMResidueTopology const *,IMP::atom::Hierarchy > const & resmap) -> Atom"""
        return _IMP_atom.CHARMMBondEndpoint_get_atom(self, current_residue, previous_residue, next_residue, resmap)


    def show(self, *args):
        """
        show(CHARMMBondEndpoint self, _ostream out)
        show(CHARMMBondEndpoint self)
        """
        return _IMP_atom.CHARMMBondEndpoint_show(self, *args)


    def __str__(self):
        """__str__(CHARMMBondEndpoint self) -> std::string"""
        return _IMP_atom.CHARMMBondEndpoint___str__(self)


    def __repr__(self):
        """__repr__(CHARMMBondEndpoint self) -> std::string"""
        return _IMP_atom.CHARMMBondEndpoint___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_CHARMMBondEndpoint
    __del__ = lambda self: None
CHARMMBondEndpoint_swigregister = _IMP_atom.CHARMMBondEndpoint_swigregister
CHARMMBondEndpoint_swigregister(CHARMMBondEndpoint)

class CHARMMDihedral(object):
    """Proxy of C++ IMP::atom::CHARMMConnection<(4)> 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, atoms):
        """__init__(IMP::atom::CHARMMConnection<(4)> self, IMP::Strings const & atoms) -> CHARMMDihedral"""
        this = _IMP_atom.new_CHARMMDihedral(atoms)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_endpoint(self, i):
        """get_endpoint(CHARMMDihedral self, unsigned int i) -> CHARMMBondEndpoint"""
        return _IMP_atom.CHARMMDihedral_get_endpoint(self, i)


    def get_contains_atom(self, name):
        """get_contains_atom(CHARMMDihedral self, std::string name) -> bool"""
        return _IMP_atom.CHARMMDihedral_get_contains_atom(self, name)


    def show(self, *args):
        """
        show(CHARMMDihedral self, _ostream out)
        show(CHARMMDihedral self)
        """
        return _IMP_atom.CHARMMDihedral_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete_CHARMMDihedral
    __del__ = lambda self: None
CHARMMDihedral_swigregister = _IMP_atom.CHARMMDihedral_swigregister
CHARMMDihedral_swigregister(CHARMMDihedral)

class CHARMMInternalCoordinate(CHARMMDihedral):
    """Proxy of C++ IMP::atom::CHARMMInternalCoordinate 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::atom::CHARMMInternalCoordinate self, IMP::Strings const & atoms, float first_distance, float first_angle, float dihedral, float second_angle, float second_distance, bool improper) -> CHARMMInternalCoordinate
        __init__(IMP::atom::CHARMMInternalCoordinate self, IMP::Vector< IMP::atom::CHARMMBondEndpoint > const endpoints, float first_distance, float first_angle, float dihedral, float second_angle, float second_distance, bool improper) -> CHARMMInternalCoordinate
        """
        this = _IMP_atom.new_CHARMMInternalCoordinate(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_first_distance(self):
        """get_first_distance(CHARMMInternalCoordinate self) -> float"""
        return _IMP_atom.CHARMMInternalCoordinate_get_first_distance(self)


    def get_second_distance(self):
        """get_second_distance(CHARMMInternalCoordinate self) -> float"""
        return _IMP_atom.CHARMMInternalCoordinate_get_second_distance(self)


    def get_first_angle(self):
        """get_first_angle(CHARMMInternalCoordinate self) -> float"""
        return _IMP_atom.CHARMMInternalCoordinate_get_first_angle(self)


    def get_second_angle(self):
        """get_second_angle(CHARMMInternalCoordinate self) -> float"""
        return _IMP_atom.CHARMMInternalCoordinate_get_second_angle(self)


    def get_dihedral(self):
        """get_dihedral(CHARMMInternalCoordinate self) -> float"""
        return _IMP_atom.CHARMMInternalCoordinate_get_dihedral(self)


    def get_improper(self):
        """get_improper(CHARMMInternalCoordinate self) -> bool"""
        return _IMP_atom.CHARMMInternalCoordinate_get_improper(self)


    def show(self, *args):
        """
        show(CHARMMInternalCoordinate self, _ostream out)
        show(CHARMMInternalCoordinate self)
        """
        return _IMP_atom.CHARMMInternalCoordinate_show(self, *args)


    def __str__(self):
        """__str__(CHARMMInternalCoordinate self) -> std::string"""
        return _IMP_atom.CHARMMInternalCoordinate___str__(self)


    def __repr__(self):
        """__repr__(CHARMMInternalCoordinate self) -> std::string"""
        return _IMP_atom.CHARMMInternalCoordinate___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_CHARMMInternalCoordinate
    __del__ = lambda self: None
CHARMMInternalCoordinate_swigregister = _IMP_atom.CHARMMInternalCoordinate_swigregister
CHARMMInternalCoordinate_swigregister(CHARMMInternalCoordinate)

class CHARMMResidueTopologyBase(IMP.Object):
    """Proxy of C++ IMP::atom::CHARMMResidueTopologyBase 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 get_type(self):
        """get_type(CHARMMResidueTopologyBase self) -> std::string"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_type(self)


    def get_number_of_atoms(self):
        """get_number_of_atoms(CHARMMResidueTopologyBase self) -> unsigned int"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_number_of_atoms(self)


    def add_atom(self, atom):
        """add_atom(CHARMMResidueTopologyBase self, CHARMMAtomTopology atom)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_atom(self, atom)


    def get_atom(self, *args):
        """
        get_atom(CHARMMResidueTopologyBase self, unsigned int i) -> CHARMMAtomTopology
        get_atom(CHARMMResidueTopologyBase self, AtomType type) -> CHARMMAtomTopology
        get_atom(CHARMMResidueTopologyBase self, std::string name) -> CHARMMAtomTopology
        """
        return _IMP_atom.CHARMMResidueTopologyBase_get_atom(self, *args)


    def get_number_of_bonds(self):
        """get_number_of_bonds(CHARMMResidueTopologyBase self) -> unsigned int"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_number_of_bonds(self)


    def add_bond(self, bond):
        """add_bond(CHARMMResidueTopologyBase self, IMP::atom::CHARMMBond const & bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_bond(self, bond)


    def get_number_of_angles(self):
        """get_number_of_angles(CHARMMResidueTopologyBase self) -> unsigned int"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_number_of_angles(self)


    def add_angle(self, bond):
        """add_angle(CHARMMResidueTopologyBase self, IMP::atom::CHARMMAngle const & bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_angle(self, bond)


    def get_number_of_dihedrals(self):
        """get_number_of_dihedrals(CHARMMResidueTopologyBase self) -> unsigned int"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_number_of_dihedrals(self)


    def add_dihedral(self, bond):
        """add_dihedral(CHARMMResidueTopologyBase self, CHARMMDihedral bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_dihedral(self, bond)


    def get_number_of_impropers(self):
        """get_number_of_impropers(CHARMMResidueTopologyBase self) -> unsigned int"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_number_of_impropers(self)


    def add_improper(self, bond):
        """add_improper(CHARMMResidueTopologyBase self, CHARMMDihedral bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_improper(self, bond)


    def get_number_of_internal_coordinates(self):
        """get_number_of_internal_coordinates(CHARMMResidueTopologyBase self) -> unsigned int"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_number_of_internal_coordinates(self)


    def add_internal_coordinate(self, ic):
        """add_internal_coordinate(CHARMMResidueTopologyBase self, CHARMMInternalCoordinate ic)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_internal_coordinate(self, ic)


    def get_internal_coordinate(self, index):
        """get_internal_coordinate(CHARMMResidueTopologyBase self, unsigned int index) -> CHARMMInternalCoordinate"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_internal_coordinate(self, index)


    def get_bond(self, index):
        """get_bond(CHARMMResidueTopologyBase self, unsigned int index) -> IMP::atom::CHARMMBond const &"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_bond(self, index)


    def get_angle(self, index):
        """get_angle(CHARMMResidueTopologyBase self, unsigned int index) -> IMP::atom::CHARMMAngle const &"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_angle(self, index)


    def get_dihedral(self, index):
        """get_dihedral(CHARMMResidueTopologyBase self, unsigned int index) -> CHARMMDihedral"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_dihedral(self, index)


    def get_improper(self, index):
        """get_improper(CHARMMResidueTopologyBase self, unsigned int index) -> CHARMMDihedral"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_improper(self, index)


    def get_version_info(self):
        """get_version_info(CHARMMResidueTopologyBase self) -> VersionInfo"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_version_info(self)


    def __str__(self):
        """__str__(CHARMMResidueTopologyBase self) -> std::string"""
        return _IMP_atom.CHARMMResidueTopologyBase___str__(self)


    def __repr__(self):
        """__repr__(CHARMMResidueTopologyBase self) -> std::string"""
        return _IMP_atom.CHARMMResidueTopologyBase___repr__(self)


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

CHARMMResidueTopologyBase_swigregister = _IMP_atom.CHARMMResidueTopologyBase_swigregister
CHARMMResidueTopologyBase_swigregister(CHARMMResidueTopologyBase)

class CHARMMIdealResidueTopology(CHARMMResidueTopologyBase):
    """Proxy of C++ IMP::atom::CHARMMIdealResidueTopology 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::atom::CHARMMIdealResidueTopology self, std::string type) -> CHARMMIdealResidueTopology
        __init__(IMP::atom::CHARMMIdealResidueTopology self, ResidueType type) -> CHARMMIdealResidueTopology
        """
        this = _IMP_atom.new_CHARMMIdealResidueTopology(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def remove_atom(self, name):
        """remove_atom(CHARMMIdealResidueTopology self, std::string name)"""
        return _IMP_atom.CHARMMIdealResidueTopology_remove_atom(self, name)


    def set_default_first_patch(self, patch):
        """set_default_first_patch(CHARMMIdealResidueTopology self, std::string patch)"""
        return _IMP_atom.CHARMMIdealResidueTopology_set_default_first_patch(self, patch)


    def set_default_last_patch(self, patch):
        """set_default_last_patch(CHARMMIdealResidueTopology self, std::string patch)"""
        return _IMP_atom.CHARMMIdealResidueTopology_set_default_last_patch(self, patch)


    def get_default_first_patch(self):
        """get_default_first_patch(CHARMMIdealResidueTopology self) -> std::string"""
        return _IMP_atom.CHARMMIdealResidueTopology_get_default_first_patch(self)


    def get_default_last_patch(self):
        """get_default_last_patch(CHARMMIdealResidueTopology self) -> std::string"""
        return _IMP_atom.CHARMMIdealResidueTopology_get_default_last_patch(self)


    def __str__(self):
        """__str__(CHARMMIdealResidueTopology self) -> std::string"""
        return _IMP_atom.CHARMMIdealResidueTopology___str__(self)


    def __repr__(self):
        """__repr__(CHARMMIdealResidueTopology self) -> std::string"""
        return _IMP_atom.CHARMMIdealResidueTopology___repr__(self)


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

CHARMMIdealResidueTopology_swigregister = _IMP_atom.CHARMMIdealResidueTopology_swigregister
CHARMMIdealResidueTopology_swigregister(CHARMMIdealResidueTopology)

class CHARMMPatch(CHARMMResidueTopologyBase):
    """Proxy of C++ IMP::atom::CHARMMPatch class."""

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

    def __init__(self, type):
        """__init__(IMP::atom::CHARMMPatch self, std::string type) -> CHARMMPatch"""
        this = _IMP_atom.new_CHARMMPatch(type)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add_removed_atom(self, name):
        """add_removed_atom(CHARMMPatch self, std::string name)"""
        return _IMP_atom.CHARMMPatch_add_removed_atom(self, name)


    def get_number_of_removed_atoms(self):
        """get_number_of_removed_atoms(CHARMMPatch self) -> unsigned int"""
        return _IMP_atom.CHARMMPatch_get_number_of_removed_atoms(self)


    def get_removed_atom(self, i):
        """get_removed_atom(CHARMMPatch self, unsigned int i) -> std::string"""
        return _IMP_atom.CHARMMPatch_get_removed_atom(self, i)


    def apply(self, *args):
        """
        apply(CHARMMPatch self, CHARMMResidueTopology res)
        apply(CHARMMPatch self, CHARMMResidueTopology res1, CHARMMResidueTopology res2)
        """
        return _IMP_atom.CHARMMPatch_apply(self, *args)


    def __str__(self):
        """__str__(CHARMMPatch self) -> std::string"""
        return _IMP_atom.CHARMMPatch___str__(self)


    def __repr__(self):
        """__repr__(CHARMMPatch self) -> std::string"""
        return _IMP_atom.CHARMMPatch___repr__(self)


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

CHARMMPatch_swigregister = _IMP_atom.CHARMMPatch_swigregister
CHARMMPatch_swigregister(CHARMMPatch)

class CHARMMResidueTopology(CHARMMIdealResidueTopology):
    """Proxy of C++ IMP::atom::CHARMMResidueTopology 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::atom::CHARMMResidueTopology self, ResidueType type) -> CHARMMResidueTopology
        __init__(IMP::atom::CHARMMResidueTopology self, CHARMMIdealResidueTopology ideal) -> CHARMMResidueTopology
        """
        this = _IMP_atom.new_CHARMMResidueTopology(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_patched(self):
        """get_patched(CHARMMResidueTopology self) -> bool"""
        return _IMP_atom.CHARMMResidueTopology_get_patched(self)


    def set_patched(self, patched):
        """set_patched(CHARMMResidueTopology self, bool patched)"""
        return _IMP_atom.CHARMMResidueTopology_set_patched(self, patched)


    def __str__(self):
        """__str__(CHARMMResidueTopology self) -> std::string"""
        return _IMP_atom.CHARMMResidueTopology___str__(self)


    def __repr__(self):
        """__repr__(CHARMMResidueTopology self) -> std::string"""
        return _IMP_atom.CHARMMResidueTopology___repr__(self)


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

CHARMMResidueTopology_swigregister = _IMP_atom.CHARMMResidueTopology_swigregister
CHARMMResidueTopology_swigregister(CHARMMResidueTopology)

class CHARMMAtom(Atom):
    """Proxy of C++ IMP::atom::CHARMMAtom 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::atom::CHARMMAtom self) -> CHARMMAtom
        __init__(IMP::atom::CHARMMAtom self, Model m, ParticleIndex id) -> CHARMMAtom
        __init__(IMP::atom::CHARMMAtom self, _ParticleAdaptor d) -> CHARMMAtom
        """
        this = _IMP_atom.new_CHARMMAtom(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(CHARMMAtom self, _ostream out)
        show(CHARMMAtom self)
        """
        return _IMP_atom.CHARMMAtom_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, IMP::String charmm_type) -> CHARMMAtom
        setup_particle(_ParticleAdaptor decorator, IMP::String charmm_type) -> CHARMMAtom
        """
        return _IMP_atom.CHARMMAtom_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

    def get_charmm_type(self):
        """get_charmm_type(CHARMMAtom self) -> IMP::String"""
        return _IMP_atom.CHARMMAtom_get_charmm_type(self)


    def set_charmm_type(self, t):
        """set_charmm_type(CHARMMAtom self, IMP::String t)"""
        return _IMP_atom.CHARMMAtom_set_charmm_type(self, t)


    def get_is_setup(*args):
        """
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_atom.CHARMMAtom_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def get_charmm_type_key():
        """get_charmm_type_key() -> StringKey"""
        return _IMP_atom.CHARMMAtom_get_charmm_type_key()

    get_charmm_type_key = staticmethod(get_charmm_type_key)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(CHARMMAtom self, FloatKey a0)
        remove_attribute(CHARMMAtom self, IntKey a0)
        remove_attribute(CHARMMAtom self, StringKey a0)
        remove_attribute(CHARMMAtom self, ParticleIndexKey a0)
        remove_attribute(CHARMMAtom self, ObjectKey a0)
        """
        return _IMP_atom.CHARMMAtom_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(CHARMMAtom self, FloatKey a0) -> bool
        has_attribute(CHARMMAtom self, IntKey a0) -> bool
        has_attribute(CHARMMAtom self, StringKey a0) -> bool
        has_attribute(CHARMMAtom self, ParticleIndexKey a0) -> bool
        has_attribute(CHARMMAtom self, ObjectKey a0) -> bool
        """
        return _IMP_atom.CHARMMAtom_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(CHARMMAtom self, FloatKey a0) -> double"""
        return _IMP_atom.CHARMMAtom_get_derivative(self, a0)


    def get_name(self):
        """get_name(CHARMMAtom self) -> std::string"""
        return _IMP_atom.CHARMMAtom_get_name(self)


    def clear_caches(self):
        """clear_caches(CHARMMAtom self)"""
        return _IMP_atom.CHARMMAtom_clear_caches(self)


    def set_name(self, a0):
        """set_name(CHARMMAtom self, std::string a0)"""
        return _IMP_atom.CHARMMAtom_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(CHARMMAtom self, IMP::CheckLevel a0)"""
        return _IMP_atom.CHARMMAtom_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(CHARMMAtom self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.CHARMMAtom_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(CHARMMAtom self, FloatKey a0, bool a1)"""
        return _IMP_atom.CHARMMAtom_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(CHARMMAtom self, FloatKey a0) -> bool"""
        return _IMP_atom.CHARMMAtom_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(CHARMMAtom self) -> IMP::CheckLevel"""
        return _IMP_atom.CHARMMAtom_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(CHARMMAtom self, CHARMMAtom o) -> bool
        __eq__(CHARMMAtom self, Particle d) -> bool
        """
        return _IMP_atom.CHARMMAtom___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(CHARMMAtom self, CHARMMAtom o) -> bool
        __ne__(CHARMMAtom self, Particle d) -> bool
        """
        return _IMP_atom.CHARMMAtom___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(CHARMMAtom self, CHARMMAtom o) -> bool
        __le__(CHARMMAtom self, Particle d) -> bool
        """
        return _IMP_atom.CHARMMAtom___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(CHARMMAtom self, CHARMMAtom o) -> bool
        __lt__(CHARMMAtom self, Particle d) -> bool
        """
        return _IMP_atom.CHARMMAtom___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(CHARMMAtom self, CHARMMAtom o) -> bool
        __ge__(CHARMMAtom self, Particle d) -> bool
        """
        return _IMP_atom.CHARMMAtom___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(CHARMMAtom self, CHARMMAtom o) -> bool
        __gt__(CHARMMAtom self, Particle d) -> bool
        """
        return _IMP_atom.CHARMMAtom___gt__(self, *args)


    def __hash__(self):
        """__hash__(CHARMMAtom self) -> std::size_t"""
        return _IMP_atom.CHARMMAtom___hash__(self)


    def __str__(self):
        """__str__(CHARMMAtom self) -> std::string"""
        return _IMP_atom.CHARMMAtom___str__(self)


    def __repr__(self):
        """__repr__(CHARMMAtom self) -> std::string"""
        return _IMP_atom.CHARMMAtom___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_CHARMMAtom
    __del__ = lambda self: None
CHARMMAtom_swigregister = _IMP_atom.CHARMMAtom_swigregister
CHARMMAtom_swigregister(CHARMMAtom)

def CHARMMAtom_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, IMP::String charmm_type) -> CHARMMAtom
    CHARMMAtom_setup_particle(_ParticleAdaptor decorator, IMP::String charmm_type) -> CHARMMAtom
    """
    return _IMP_atom.CHARMMAtom_setup_particle(*args)

def CHARMMAtom_get_is_setup(*args):
    """
    get_is_setup(_ParticleAdaptor p) -> bool
    CHARMMAtom_get_is_setup(Model m, ParticleIndex pi) -> bool
    """
    return _IMP_atom.CHARMMAtom_get_is_setup(*args)

def CHARMMAtom_get_charmm_type_key():
    """CHARMMAtom_get_charmm_type_key() -> StringKey"""
    return _IMP_atom.CHARMMAtom_get_charmm_type_key()


def get_charmm_untyped_atoms(hierarchy):
    """get_charmm_untyped_atoms(Hierarchy hierarchy) -> IMP::atom::Atoms"""
    return _IMP_atom.get_charmm_untyped_atoms(hierarchy)

def remove_charmm_untyped_atoms(hierarchy):
    """remove_charmm_untyped_atoms(Hierarchy hierarchy)"""
    return _IMP_atom.remove_charmm_untyped_atoms(hierarchy)
class CHARMMBondParameters(object):
    """Proxy of C++ IMP::atom::CHARMMBondParameters class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    force_constant = _swig_property(_IMP_atom.CHARMMBondParameters_force_constant_get, _IMP_atom.CHARMMBondParameters_force_constant_set)
    ideal = _swig_property(_IMP_atom.CHARMMBondParameters_ideal_get, _IMP_atom.CHARMMBondParameters_ideal_set)

    def __init__(self):
        """__init__(IMP::atom::CHARMMBondParameters self) -> CHARMMBondParameters"""
        this = _IMP_atom.new_CHARMMBondParameters()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(CHARMMBondParameters self, _ostream out)
        show(CHARMMBondParameters self)
        """
        return _IMP_atom.CHARMMBondParameters_show(self, *args)


    def __str__(self):
        """__str__(CHARMMBondParameters self) -> std::string"""
        return _IMP_atom.CHARMMBondParameters___str__(self)


    def __repr__(self):
        """__repr__(CHARMMBondParameters self) -> std::string"""
        return _IMP_atom.CHARMMBondParameters___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_CHARMMBondParameters
    __del__ = lambda self: None
CHARMMBondParameters_swigregister = _IMP_atom.CHARMMBondParameters_swigregister
CHARMMBondParameters_swigregister(CHARMMBondParameters)

class CHARMMDihedralParameters(object):
    """Proxy of C++ IMP::atom::CHARMMDihedralParameters class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    force_constant = _swig_property(_IMP_atom.CHARMMDihedralParameters_force_constant_get, _IMP_atom.CHARMMDihedralParameters_force_constant_set)
    multiplicity = _swig_property(_IMP_atom.CHARMMDihedralParameters_multiplicity_get, _IMP_atom.CHARMMDihedralParameters_multiplicity_set)
    ideal = _swig_property(_IMP_atom.CHARMMDihedralParameters_ideal_get, _IMP_atom.CHARMMDihedralParameters_ideal_set)

    def __init__(self):
        """__init__(IMP::atom::CHARMMDihedralParameters self) -> CHARMMDihedralParameters"""
        this = _IMP_atom.new_CHARMMDihedralParameters()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, *args):
        """
        show(CHARMMDihedralParameters self, _ostream out)
        show(CHARMMDihedralParameters self)
        """
        return _IMP_atom.CHARMMDihedralParameters_show(self, *args)


    def __str__(self):
        """__str__(CHARMMDihedralParameters self) -> std::string"""
        return _IMP_atom.CHARMMDihedralParameters___str__(self)


    def __repr__(self):
        """__repr__(CHARMMDihedralParameters self) -> std::string"""
        return _IMP_atom.CHARMMDihedralParameters___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_CHARMMDihedralParameters
    __del__ = lambda self: None
CHARMMDihedralParameters_swigregister = _IMP_atom.CHARMMDihedralParameters_swigregister
CHARMMDihedralParameters_swigregister(CHARMMDihedralParameters)

class CHARMMParameters(ForceFieldParameters):
    """Proxy of C++ IMP::atom::CHARMMParameters 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::atom::CHARMMParameters self, TextInput topology_file_name, TextInput par_file_name, bool translate_names_to_pdb=False) -> CHARMMParameters
        __init__(IMP::atom::CHARMMParameters self, TextInput topology_file_name, TextInput par_file_name) -> CHARMMParameters
        __init__(IMP::atom::CHARMMParameters self, TextInput topology_file_name) -> CHARMMParameters
        """
        this = _IMP_atom.new_CHARMMParameters(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add_residue_topology(self, res):
        """add_residue_topology(CHARMMParameters self, CHARMMIdealResidueTopology res)"""
        return _IMP_atom.CHARMMParameters_add_residue_topology(self, res)


    def get_residue_topology(self, type):
        """get_residue_topology(CHARMMParameters self, ResidueType type) -> CHARMMIdealResidueTopology"""
        return _IMP_atom.CHARMMParameters_get_residue_topology(self, type)


    def add_patch(self, patch):
        """add_patch(CHARMMParameters self, CHARMMPatch patch)"""
        return _IMP_atom.CHARMMParameters_add_patch(self, patch)


    def get_patch(self, name):
        """get_patch(CHARMMParameters self, std::string name) -> CHARMMPatch"""
        return _IMP_atom.CHARMMParameters_get_patch(self, name)


    def create_topology(self, hierarchy):
        """create_topology(CHARMMParameters self, Hierarchy hierarchy) -> CHARMMTopology"""
        return _IMP_atom.CHARMMParameters_create_topology(self, hierarchy)


    def get_bond_parameters(self, type1, type2):
        """get_bond_parameters(CHARMMParameters self, std::string type1, std::string type2) -> CHARMMBondParameters"""
        return _IMP_atom.CHARMMParameters_get_bond_parameters(self, type1, type2)


    def get_angle_parameters(self, type1, type2, type3):
        """get_angle_parameters(CHARMMParameters self, std::string type1, std::string type2, std::string type3) -> CHARMMBondParameters"""
        return _IMP_atom.CHARMMParameters_get_angle_parameters(self, type1, type2, type3)


    def get_dihedral_parameters(self, type1, type2, type3, type4):
        """get_dihedral_parameters(CHARMMParameters self, std::string type1, std::string type2, std::string type3, std::string type4) -> IMP::atom::CHARMMDihedralParametersList"""
        return _IMP_atom.CHARMMParameters_get_dihedral_parameters(self, type1, type2, type3, type4)


    def get_improper_parameters(self, type1, type2, type3, type4):
        """get_improper_parameters(CHARMMParameters self, std::string type1, std::string type2, std::string type3, std::string type4) -> CHARMMDihedralParameters"""
        return _IMP_atom.CHARMMParameters_get_improper_parameters(self, type1, type2, type3, type4)


    def create_angles(self, bonds):
        """create_angles(CHARMMParameters self, IMP::Particles bonds) -> IMP::Particles"""
        return _IMP_atom.CHARMMParameters_create_angles(self, bonds)


    def create_dihedrals(self, bonds):
        """create_dihedrals(CHARMMParameters self, IMP::Particles bonds) -> IMP::Particles"""
        return _IMP_atom.CHARMMParameters_create_dihedrals(self, bonds)


    def get_version_info(self):
        """get_version_info(CHARMMParameters self) -> VersionInfo"""
        return _IMP_atom.CHARMMParameters_get_version_info(self)


    def __str__(self):
        """__str__(CHARMMParameters self) -> std::string"""
        return _IMP_atom.CHARMMParameters___str__(self)


    def __repr__(self):
        """__repr__(CHARMMParameters self) -> std::string"""
        return _IMP_atom.CHARMMParameters___repr__(self)


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

CHARMMParameters_swigregister = _IMP_atom.CHARMMParameters_swigregister
CHARMMParameters_swigregister(CHARMMParameters)


def get_heavy_atom_CHARMM_parameters():
    """get_heavy_atom_CHARMM_parameters() -> CHARMMParameters"""
    return _IMP_atom.get_heavy_atom_CHARMM_parameters()

def get_all_atom_CHARMM_parameters():
    """get_all_atom_CHARMM_parameters() -> CHARMMParameters"""
    return _IMP_atom.get_all_atom_CHARMM_parameters()
class CHARMMSegmentTopology(IMP.Object):
    """Proxy of C++ IMP::atom::CHARMMSegmentTopology class."""

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

    def remove_residue(self, d):
        """remove_residue(CHARMMSegmentTopology self, CHARMMResidueTopology d)"""
        return _IMP_atom.CHARMMSegmentTopology_remove_residue(self, d)


    def remove_residues(self, d):
        """remove_residues(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & d)"""
        return _IMP_atom.CHARMMSegmentTopology_remove_residues(self, d)


    def set_residues(self, ps):
        """set_residues(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & ps)"""
        return _IMP_atom.CHARMMSegmentTopology_set_residues(self, ps)


    def set_residues_order(self, objs):
        """set_residues_order(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & objs)"""
        return _IMP_atom.CHARMMSegmentTopology_set_residues_order(self, objs)


    def add_residue(self, obj):
        """add_residue(CHARMMSegmentTopology self, CHARMMResidueTopology obj) -> unsigned int"""
        return _IMP_atom.CHARMMSegmentTopology_add_residue(self, obj)


    def add_residues(self, objs):
        """add_residues(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & objs)"""
        return _IMP_atom.CHARMMSegmentTopology_add_residues(self, objs)


    def clear_residues(self):
        """clear_residues(CHARMMSegmentTopology self)"""
        return _IMP_atom.CHARMMSegmentTopology_clear_residues(self)


    def get_number_of_residues(self):
        """get_number_of_residues(CHARMMSegmentTopology self) -> unsigned int"""
        return _IMP_atom.CHARMMSegmentTopology_get_number_of_residues(self)


    def get_has_residues(self):
        """get_has_residues(CHARMMSegmentTopology self) -> bool"""
        return _IMP_atom.CHARMMSegmentTopology_get_has_residues(self)


    def get_residue(self, i):
        """get_residue(CHARMMSegmentTopology self, unsigned int i) -> CHARMMResidueTopology"""
        return _IMP_atom.CHARMMSegmentTopology_get_residue(self, i)


    def get_residues(self):
        """get_residues(CHARMMSegmentTopology self) -> IMP::atom::CHARMMResidueTopologies"""
        return _IMP_atom.CHARMMSegmentTopology_get_residues(self)


    def reserve_residues(self, sz):
        """reserve_residues(CHARMMSegmentTopology self, unsigned int sz)"""
        return _IMP_atom.CHARMMSegmentTopology_reserve_residues(self, sz)


    def get_version_info(self):
        """get_version_info(CHARMMSegmentTopology self) -> VersionInfo"""
        return _IMP_atom.CHARMMSegmentTopology_get_version_info(self)


    def __init__(self, *args):
        """
        __init__(IMP::atom::CHARMMSegmentTopology self, std::string name) -> CHARMMSegmentTopology
        __init__(IMP::atom::CHARMMSegmentTopology self) -> CHARMMSegmentTopology
        """
        this = _IMP_atom.new_CHARMMSegmentTopology(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def apply_default_patches(self, ff):
        """apply_default_patches(CHARMMSegmentTopology self, CHARMMParameters ff)"""
        return _IMP_atom.CHARMMSegmentTopology_apply_default_patches(self, ff)


    def __str__(self):
        """__str__(CHARMMSegmentTopology self) -> std::string"""
        return _IMP_atom.CHARMMSegmentTopology___str__(self)


    def __repr__(self):
        """__repr__(CHARMMSegmentTopology self) -> std::string"""
        return _IMP_atom.CHARMMSegmentTopology___repr__(self)


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

CHARMMSegmentTopology_swigregister = _IMP_atom.CHARMMSegmentTopology_swigregister
CHARMMSegmentTopology_swigregister(CHARMMSegmentTopology)

class CHARMMTopology(IMP.Object):
    """Proxy of C++ IMP::atom::CHARMMTopology 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::atom::CHARMMTopology self, CHARMMParameters force_field, std::string name) -> CHARMMTopology
        __init__(IMP::atom::CHARMMTopology self, CHARMMParameters force_field) -> CHARMMTopology
        """
        this = _IMP_atom.new_CHARMMTopology(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_parameters(self):
        """get_parameters(CHARMMTopology self) -> CHARMMParameters"""
        return _IMP_atom.CHARMMTopology_get_parameters(self)


    def add_sequence(self, sequence):
        """add_sequence(CHARMMTopology self, std::string sequence)"""
        return _IMP_atom.CHARMMTopology_add_sequence(self, sequence)


    def apply_default_patches(self):
        """apply_default_patches(CHARMMTopology self)"""
        return _IMP_atom.CHARMMTopology_apply_default_patches(self)


    def create_hierarchy(self, model):
        """create_hierarchy(CHARMMTopology self, Model model) -> Hierarchy"""
        return _IMP_atom.CHARMMTopology_create_hierarchy(self, model)


    def add_atom_types(self, hierarchy):
        """add_atom_types(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_atom_types(self, hierarchy)


    def add_coordinates(self, hierarchy):
        """add_coordinates(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_coordinates(self, hierarchy)


    def add_missing_atoms(self, hierarchy):
        """add_missing_atoms(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_missing_atoms(self, hierarchy)


    def setup_hierarchy(self, hierarchy):
        """setup_hierarchy(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_setup_hierarchy(self, hierarchy)


    def add_charges(self, hierarchy):
        """add_charges(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_charges(self, hierarchy)


    def add_bonds(self, hierarchy):
        """add_bonds(CHARMMTopology self, Hierarchy hierarchy) -> IMP::Particles"""
        return _IMP_atom.CHARMMTopology_add_bonds(self, hierarchy)


    def add_dihedrals(self, hierarchy):
        """add_dihedrals(CHARMMTopology self, Hierarchy hierarchy) -> IMP::Particles"""
        return _IMP_atom.CHARMMTopology_add_dihedrals(self, hierarchy)


    def add_impropers(self, hierarchy):
        """add_impropers(CHARMMTopology self, Hierarchy hierarchy) -> IMP::Particles"""
        return _IMP_atom.CHARMMTopology_add_impropers(self, hierarchy)


    def remove_segment(self, d):
        """remove_segment(CHARMMTopology self, CHARMMSegmentTopology d)"""
        return _IMP_atom.CHARMMTopology_remove_segment(self, d)


    def remove_segments(self, d):
        """remove_segments(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & d)"""
        return _IMP_atom.CHARMMTopology_remove_segments(self, d)


    def set_segments(self, ps):
        """set_segments(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & ps)"""
        return _IMP_atom.CHARMMTopology_set_segments(self, ps)


    def set_segments_order(self, objs):
        """set_segments_order(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & objs)"""
        return _IMP_atom.CHARMMTopology_set_segments_order(self, objs)


    def add_segment(self, obj):
        """add_segment(CHARMMTopology self, CHARMMSegmentTopology obj) -> unsigned int"""
        return _IMP_atom.CHARMMTopology_add_segment(self, obj)


    def add_segments(self, objs):
        """add_segments(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & objs)"""
        return _IMP_atom.CHARMMTopology_add_segments(self, objs)


    def clear_segments(self):
        """clear_segments(CHARMMTopology self)"""
        return _IMP_atom.CHARMMTopology_clear_segments(self)


    def get_number_of_segments(self):
        """get_number_of_segments(CHARMMTopology self) -> unsigned int"""
        return _IMP_atom.CHARMMTopology_get_number_of_segments(self)


    def get_has_segments(self):
        """get_has_segments(CHARMMTopology self) -> bool"""
        return _IMP_atom.CHARMMTopology_get_has_segments(self)


    def get_segment(self, i):
        """get_segment(CHARMMTopology self, unsigned int i) -> CHARMMSegmentTopology"""
        return _IMP_atom.CHARMMTopology_get_segment(self, i)


    def get_segments(self):
        """get_segments(CHARMMTopology self) -> IMP::atom::CHARMMSegmentTopologies"""
        return _IMP_atom.CHARMMTopology_get_segments(self)


    def reserve_segments(self, sz):
        """reserve_segments(CHARMMTopology self, unsigned int sz)"""
        return _IMP_atom.CHARMMTopology_reserve_segments(self, sz)


    def get_version_info(self):
        """get_version_info(CHARMMTopology self) -> VersionInfo"""
        return _IMP_atom.CHARMMTopology_get_version_info(self)


    def __str__(self):
        """__str__(CHARMMTopology self) -> std::string"""
        return _IMP_atom.CHARMMTopology___str__(self)


    def __repr__(self):
        """__repr__(CHARMMTopology self) -> std::string"""
        return _IMP_atom.CHARMMTopology___repr__(self)


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

CHARMMTopology_swigregister = _IMP_atom.CHARMMTopology_swigregister
CHARMMTopology_swigregister(CHARMMTopology)

class CHARMMStereochemistryRestraint(IMP.Restraint):
    """Proxy of C++ IMP::atom::CHARMMStereochemistryRestraint 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::atom::CHARMMStereochemistryRestraint self, Hierarchy h, CHARMMTopology topology) -> CHARMMStereochemistryRestraint
        __init__(IMP::atom::CHARMMStereochemistryRestraint self, Hierarchy h, CHARMMTopology topology, IMP::ParticlesTemp limit_to_these_particles) -> CHARMMStereochemistryRestraint
        """
        this = _IMP_atom.new_CHARMMStereochemistryRestraint(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_pair_filter(self):
        """get_pair_filter(CHARMMStereochemistryRestraint self) -> StereochemistryPairFilter"""
        return _IMP_atom.CHARMMStereochemistryRestraint_get_pair_filter(self)


    def get_full_pair_filter(self):
        """get_full_pair_filter(CHARMMStereochemistryRestraint self) -> StereochemistryPairFilter"""
        return _IMP_atom.CHARMMStereochemistryRestraint_get_full_pair_filter(self)


    def do_get_inputs(self):
        """do_get_inputs(CHARMMStereochemistryRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.CHARMMStereochemistryRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(CHARMMStereochemistryRestraint self) -> VersionInfo"""
        return _IMP_atom.CHARMMStereochemistryRestraint_get_version_info(self)


    def __str__(self):
        """__str__(CHARMMStereochemistryRestraint self) -> std::string"""
        return _IMP_atom.CHARMMStereochemistryRestraint___str__(self)


    def __repr__(self):
        """__repr__(CHARMMStereochemistryRestraint self) -> std::string"""
        return _IMP_atom.CHARMMStereochemistryRestraint___repr__(self)


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

CHARMMStereochemistryRestraint_swigregister = _IMP_atom.CHARMMStereochemistryRestraint_swigregister
CHARMMStereochemistryRestraint_swigregister(CHARMMStereochemistryRestraint)


def add_bonds(*args):
    """
    add_bonds(Hierarchy d, ForceFieldParameters ffp)
    add_bonds(Hierarchy d)
    """
    return _IMP_atom.add_bonds(*args)

def add_radii(*args):
    """
    add_radii(Hierarchy d, ForceFieldParameters ffp, FloatKey radius_key)
    add_radii(Hierarchy d, ForceFieldParameters ffp)
    add_radii(Hierarchy d)
    """
    return _IMP_atom.add_radii(*args)

_IMP_atom.ALBER_swigconstant(_IMP_atom)
ALBER = _IMP_atom.ALBER

_IMP_atom.HARPAZ_swigconstant(_IMP_atom)
HARPAZ = _IMP_atom.HARPAZ

_IMP_atom.ANDERSSON_swigconstant(_IMP_atom)
ANDERSSON = _IMP_atom.ANDERSSON

_IMP_atom.TSAI_swigconstant(_IMP_atom)
TSAI = _IMP_atom.TSAI

_IMP_atom.QUILLIN_swigconstant(_IMP_atom)
QUILLIN = _IMP_atom.QUILLIN

_IMP_atom.SQUIRE_swigconstant(_IMP_atom)
SQUIRE = _IMP_atom.SQUIRE

def get_protein_density_from_reference(densityReference):
    """get_protein_density_from_reference(IMP::atom::ProteinDensityReference densityReference) -> double"""
    return _IMP_atom.get_protein_density_from_reference(densityReference)

def get_volume_from_mass(*args):
    """
    get_volume_from_mass(double m, IMP::atom::ProteinDensityReference ref) -> double
    get_volume_from_mass(double m) -> double
    """
    return _IMP_atom.get_volume_from_mass(*args)

def get_mass_from_volume(*args):
    """
    get_mass_from_volume(double v, IMP::atom::ProteinDensityReference ref) -> double
    get_mass_from_volume(double v) -> double
    """
    return _IMP_atom.get_mass_from_volume(*args)

def get_mass_from_number_of_residues(num_aa):
    """get_mass_from_number_of_residues(unsigned int num_aa) -> double"""
    return _IMP_atom.get_mass_from_number_of_residues(num_aa)

def get_volume_from_residue_type(rt):
    """get_volume_from_residue_type(ResidueType rt) -> double"""
    return _IMP_atom.get_volume_from_residue_type(rt)

def get_molarity(n, volume):
    """get_molarity(double n, double volume) -> double"""
    return _IMP_atom.get_molarity(n, volume)

def get_kd(na, nb, nab, volume):
    """get_kd(double na, double nb, double nab, double volume) -> double"""
    return _IMP_atom.get_kd(na, nb, nab, volume)

def get_einstein_diffusion_coefficient(r):
    """get_einstein_diffusion_coefficient(double r) -> double"""
    return _IMP_atom.get_einstein_diffusion_coefficient(r)

def get_einstein_rotational_diffusion_coefficient(r):
    """get_einstein_rotational_diffusion_coefficient(double r) -> double"""
    return _IMP_atom.get_einstein_rotational_diffusion_coefficient(r)

def get_diffusion_length(*args):
    """
    get_diffusion_length(double D, double t) -> double
    get_diffusion_length(double D, double force, double t, double temp=273) -> double
    get_diffusion_length(double D, double force, double t) -> double
    """
    return _IMP_atom.get_diffusion_length(*args)

def get_diffusion_angle(D, dtfs):
    """get_diffusion_angle(double D, double dtfs) -> double"""
    return _IMP_atom.get_diffusion_angle(D, dtfs)

def get_diffusion_coefficient(displacements, dt):
    """get_diffusion_coefficient(IMP::algebra::Vector3Ds const & displacements, double dt) -> double"""
    return _IMP_atom.get_diffusion_coefficient(displacements, dt)

def get_rotational_diffusion_coefficient(displacements, dt):
    """get_rotational_diffusion_coefficient(IMP::algebra::Rotation3Ds const & displacements, double dt) -> double"""
    return _IMP_atom.get_rotational_diffusion_coefficient(displacements, dt)
class EzRestraint(IMP.Restraint):
    """Proxy of C++ IMP::atom::EzRestraint class."""

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

    def __init__(self, m, ps):
        """__init__(IMP::atom::EzRestraint self, Model m, _ParticleIndexesAdaptor ps) -> EzRestraint"""
        this = _IMP_atom.new_EzRestraint(m, ps)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(EzRestraint self) -> VersionInfo"""
        return _IMP_atom.EzRestraint_get_version_info(self)


    def __str__(self):
        """__str__(EzRestraint self) -> std::string"""
        return _IMP_atom.EzRestraint___str__(self)


    def __repr__(self):
        """__repr__(EzRestraint self) -> std::string"""
        return _IMP_atom.EzRestraint___repr__(self)


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

EzRestraint_swigregister = _IMP_atom.EzRestraint_swigregister
EzRestraint_swigregister(EzRestraint)


def create_protein(*args):
    """
    create_protein(Model m, std::string name, double target_radius, int number_of_residues, int first_residue_index=0, double volume=-1, bool ismol=True) -> Hierarchy
    create_protein(Model m, std::string name, double target_radius, int number_of_residues, int first_residue_index=0, double volume=-1) -> Hierarchy
    create_protein(Model m, std::string name, double target_radius, int number_of_residues, int first_residue_index=0) -> Hierarchy
    create_protein(Model m, std::string name, double target_radius, int number_of_residues) -> Hierarchy
    create_protein(Model m, std::string name, double target_radius, IMP::Ints const domain_boundaries) -> Hierarchy
    """
    return _IMP_atom.create_protein(*args)

def create_simplified_along_backbone(*args):
    """
    create_simplified_along_backbone(Hierarchy input, int num_res, bool keep_detailed=False) -> Hierarchy
    create_simplified_along_backbone(Hierarchy input, int num_res) -> Hierarchy
    create_simplified_along_backbone(Chain input, IMP::IntRanges const & residue_segments, bool keep_detailed=False) -> Hierarchy
    create_simplified_along_backbone(Chain input, IMP::IntRanges const & residue_segments) -> Hierarchy
    """
    return _IMP_atom.create_simplified_along_backbone(*args)

def create_simplified_from_volume(h, resolution):
    """create_simplified_from_volume(Hierarchy h, double resolution) -> Hierarchy"""
    return _IMP_atom.create_simplified_from_volume(h, resolution)

def create_simplified_assembly_from_volume(h, resolution):
    """create_simplified_assembly_from_volume(Hierarchy h, double resolution) -> Hierarchy"""
    return _IMP_atom.create_simplified_assembly_from_volume(h, resolution)

def get_residue_indexes(h):
    """get_residue_indexes(Hierarchy h) -> IMP::Ints"""
    return _IMP_atom.get_residue_indexes(h)

def get_residue_type(*args):
    """
    get_residue_type(char c) -> ResidueType
    get_residue_type(Hierarchy h) -> ResidueType
    """
    return _IMP_atom.get_residue_type(*args)

def get_atom_type(h):
    """get_atom_type(Hierarchy h) -> AtomType"""
    return _IMP_atom.get_atom_type(h)

def get_domain_name(h):
    """get_domain_name(Hierarchy h) -> std::string"""
    return _IMP_atom.get_domain_name(h)

def create_excluded_volume_restraint(*args):
    """
    create_excluded_volume_restraint(IMP::atom::Selections const & s) -> Restraint
    create_excluded_volume_restraint(IMP::atom::Hierarchies const & hs, double resolution=-1) -> Restraint
    create_excluded_volume_restraint(IMP::atom::Hierarchies const & hs) -> Restraint
    """
    return _IMP_atom.create_excluded_volume_restraint(*args)

def setup_as_approximation(*args):
    """
    setup_as_approximation(Particle h, IMP::ParticlesTemp const & other, double resolution=-1)
    setup_as_approximation(Particle h, IMP::ParticlesTemp const & other)
    setup_as_approximation(Hierarchy h, double resolution=-1)
    setup_as_approximation(Hierarchy h)
    """
    return _IMP_atom.setup_as_approximation(*args)
class _HierarchyTreeVertexIndex(object):
    """Proxy of C++ IMP::atom::HierarchyTreeVertexIndex 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::atom::HierarchyTreeVertexIndex self) -> _HierarchyTreeVertexIndex"""
        this = _IMP_atom.new__HierarchyTreeVertexIndex()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _IMP_atom.delete__HierarchyTreeVertexIndex
    __del__ = lambda self: None
_HierarchyTreeVertexIndex_swigregister = _IMP_atom._HierarchyTreeVertexIndex_swigregister
_HierarchyTreeVertexIndex_swigregister(_HierarchyTreeVertexIndex)


def show_as_graphviz(name, out):
    """show_as_graphviz(IMP::atom::HierarchyTree const & name, TextOutput out)"""
    return _IMP_atom.show_as_graphviz(name, out)

def get_vertex_index(g):
    """get_vertex_index(IMP::atom::HierarchyTree const & g) -> _HierarchyTreeVertexIndex"""
    return _IMP_atom.get_vertex_index(g)

def get_hierarchy_tree(h):
    """get_hierarchy_tree(Hierarchy h) -> IMP::atom::HierarchyTree"""
    return _IMP_atom.get_hierarchy_tree(h)
class HierarchyGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::atom::HierarchyGeometry class."""

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

    def __init__(self, d, resolution=0):
        """
        __init__(IMP::atom::HierarchyGeometry self, Hierarchy d, double resolution=0) -> HierarchyGeometry
        __init__(IMP::atom::HierarchyGeometry self, Hierarchy d) -> HierarchyGeometry
        """
        this = _IMP_atom.new_HierarchyGeometry(d, resolution)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(HierarchyGeometry self) -> VersionInfo"""
        return _IMP_atom.HierarchyGeometry_get_version_info(self)


    def __str__(self):
        """__str__(HierarchyGeometry self) -> std::string"""
        return _IMP_atom.HierarchyGeometry___str__(self)


    def __repr__(self):
        """__repr__(HierarchyGeometry self) -> std::string"""
        return _IMP_atom.HierarchyGeometry___repr__(self)


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

HierarchyGeometry_swigregister = _IMP_atom.HierarchyGeometry_swigregister
HierarchyGeometry_swigregister(HierarchyGeometry)

class HierarchiesGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::atom::HierarchiesGeometry class."""

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

    def __init__(self, sc, resolution=-1):
        """
        __init__(IMP::atom::HierarchiesGeometry self, SingletonContainer sc, double resolution=-1) -> HierarchiesGeometry
        __init__(IMP::atom::HierarchiesGeometry self, SingletonContainer sc) -> HierarchiesGeometry
        """
        this = _IMP_atom.new_HierarchiesGeometry(sc, resolution)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(HierarchiesGeometry self) -> VersionInfo"""
        return _IMP_atom.HierarchiesGeometry_get_version_info(self)


    def __str__(self):
        """__str__(HierarchiesGeometry self) -> std::string"""
        return _IMP_atom.HierarchiesGeometry___str__(self)


    def __repr__(self):
        """__repr__(HierarchiesGeometry self) -> std::string"""
        return _IMP_atom.HierarchiesGeometry___repr__(self)


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

HierarchiesGeometry_swigregister = _IMP_atom.HierarchiesGeometry_swigregister
HierarchiesGeometry_swigregister(HierarchiesGeometry)


def transform(*args):
    """
    transform(Hierarchy h, Transformation3D tr)
    transform(Hierarchy h, Transformation3D tr)
    """
    return _IMP_atom.transform(*args)
class DopePairScore(_ADopeBase):
    """Proxy of C++ IMP::atom::DopePairScore 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::atom::DopePairScore self, double threshold) -> DopePairScore
        __init__(IMP::atom::DopePairScore self) -> DopePairScore
        __init__(IMP::atom::DopePairScore self, double threshold, TextInput data_file) -> DopePairScore
        """
        this = _IMP_atom.new_DopePairScore(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(DopePairScore self) -> std::string"""
        return _IMP_atom.DopePairScore___str__(self)


    def __repr__(self):
        """__repr__(DopePairScore self) -> std::string"""
        return _IMP_atom.DopePairScore___repr__(self)


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

    __swig_destroy__ = _IMP_atom.delete_DopePairScore
    __del__ = lambda self: None
DopePairScore_swigregister = _IMP_atom.DopePairScore_swigregister
DopePairScore_swigregister(DopePairScore)


def add_dope_score_data(h):
    """add_dope_score_data(Hierarchy h)"""
    return _IMP_atom.add_dope_score_data(h)
class OrientedSoapPairScore(_OrientedSoapBase):
    """Proxy of C++ IMP::atom::OrientedSoapPairScore class."""

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

    def __init__(self, library):
        """__init__(IMP::atom::OrientedSoapPairScore self, std::string library) -> OrientedSoapPairScore"""
        this = _IMP_atom.new_OrientedSoapPairScore(library)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_pair_filter(self):
        """get_pair_filter(OrientedSoapPairScore self) -> SoapPairFilter"""
        return _IMP_atom.OrientedSoapPairScore_get_pair_filter(self)


    def __str__(self):
        """__str__(OrientedSoapPairScore self) -> std::string"""
        return _IMP_atom.OrientedSoapPairScore___str__(self)


    def __repr__(self):
        """__repr__(OrientedSoapPairScore self) -> std::string"""
        return _IMP_atom.OrientedSoapPairScore___repr__(self)


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

    __swig_destroy__ = _IMP_atom.delete_OrientedSoapPairScore
    __del__ = lambda self: None
OrientedSoapPairScore_swigregister = _IMP_atom.OrientedSoapPairScore_swigregister
OrientedSoapPairScore_swigregister(OrientedSoapPairScore)

class SameResiduePairFilter(IMP.PairPredicate):
    """Proxy of C++ IMP::atom::SameResiduePairFilter 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::atom::SameResiduePairFilter self) -> SameResiduePairFilter"""
        this = _IMP_atom.new_SameResiduePairFilter()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self, m, pis):
        """do_get_inputs(SameResiduePairFilter self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.SameResiduePairFilter_do_get_inputs(self, m, pis)


    def get_value(self, *args):
        """
        get_value(SameResiduePairFilter self, IMP::ParticlePair const & a) -> int
        get_value(SameResiduePairFilter self, IMP::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_atom.SameResiduePairFilter_get_value(self, *args)


    def get_value_index(self, *args):
        """
        get_value_index(SameResiduePairFilter self, Model m, IMP::ParticleIndexPair const & p) -> int
        get_value_index(SameResiduePairFilter self, Model m, IMP::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_atom.SameResiduePairFilter_get_value_index(self, *args)


    def get_version_info(self):
        """get_version_info(SameResiduePairFilter self) -> VersionInfo"""
        return _IMP_atom.SameResiduePairFilter_get_version_info(self)


    def __str__(self):
        """__str__(SameResiduePairFilter self) -> std::string"""
        return _IMP_atom.SameResiduePairFilter___str__(self)


    def __repr__(self):
        """__repr__(SameResiduePairFilter self) -> std::string"""
        return _IMP_atom.SameResiduePairFilter___repr__(self)


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

SameResiduePairFilter_swigregister = _IMP_atom.SameResiduePairFilter_swigregister
SameResiduePairFilter_swigregister(SameResiduePairFilter)

class RemoveRigidMotionOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::atom::RemoveRigidMotionOptimizerState class."""

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

    def __init__(self, m, pis):
        """__init__(IMP::atom::RemoveRigidMotionOptimizerState self, Model m, _ParticleIndexesAdaptor pis) -> RemoveRigidMotionOptimizerState"""
        this = _IMP_atom.new_RemoveRigidMotionOptimizerState(m, pis)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_particles(self, pis):
        """set_particles(RemoveRigidMotionOptimizerState self, IMP::Particles const & pis)"""
        return _IMP_atom.RemoveRigidMotionOptimizerState_set_particles(self, pis)


    def remove_rigid_motion(self):
        """remove_rigid_motion(RemoveRigidMotionOptimizerState self)"""
        return _IMP_atom.RemoveRigidMotionOptimizerState_remove_rigid_motion(self)


    def get_version_info(self):
        """get_version_info(RemoveRigidMotionOptimizerState self) -> VersionInfo"""
        return _IMP_atom.RemoveRigidMotionOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(RemoveRigidMotionOptimizerState self) -> std::string"""
        return _IMP_atom.RemoveRigidMotionOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(RemoveRigidMotionOptimizerState self) -> std::string"""
        return _IMP_atom.RemoveRigidMotionOptimizerState___repr__(self)


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

RemoveRigidMotionOptimizerState_swigregister = _IMP_atom.RemoveRigidMotionOptimizerState_swigregister
RemoveRigidMotionOptimizerState_swigregister(RemoveRigidMotionOptimizerState)

class BerendsenThermostatOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::atom::BerendsenThermostatOptimizerState class."""

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

    def __init__(self, pis, temperature, tau):
        """__init__(IMP::atom::BerendsenThermostatOptimizerState self, IMP::Particles const & pis, double temperature, double tau) -> BerendsenThermostatOptimizerState"""
        this = _IMP_atom.new_BerendsenThermostatOptimizerState(pis, temperature, tau)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_particles(self, pis):
        """set_particles(BerendsenThermostatOptimizerState self, IMP::Particles const & pis)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_set_particles(self, pis)


    def get_temperature(self):
        """get_temperature(BerendsenThermostatOptimizerState self) -> double"""
        return _IMP_atom.BerendsenThermostatOptimizerState_get_temperature(self)


    def get_tau(self):
        """get_tau(BerendsenThermostatOptimizerState self) -> double"""
        return _IMP_atom.BerendsenThermostatOptimizerState_get_tau(self)


    def set_temperature(self, temperature):
        """set_temperature(BerendsenThermostatOptimizerState self, double temperature)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_set_temperature(self, temperature)


    def set_tau(self, tau):
        """set_tau(BerendsenThermostatOptimizerState self, double tau)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_set_tau(self, tau)


    def rescale_velocities(self):
        """rescale_velocities(BerendsenThermostatOptimizerState self)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_rescale_velocities(self)


    def get_version_info(self):
        """get_version_info(BerendsenThermostatOptimizerState self) -> VersionInfo"""
        return _IMP_atom.BerendsenThermostatOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(BerendsenThermostatOptimizerState self) -> std::string"""
        return _IMP_atom.BerendsenThermostatOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(BerendsenThermostatOptimizerState self) -> std::string"""
        return _IMP_atom.BerendsenThermostatOptimizerState___repr__(self)


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

BerendsenThermostatOptimizerState_swigregister = _IMP_atom.BerendsenThermostatOptimizerState_swigregister
BerendsenThermostatOptimizerState_swigregister(BerendsenThermostatOptimizerState)

class LangevinThermostatOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::atom::LangevinThermostatOptimizerState class."""

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

    def __init__(self, m, pis, temperature, gamma):
        """__init__(IMP::atom::LangevinThermostatOptimizerState self, Model m, _ParticleIndexesAdaptor pis, double temperature, double gamma) -> LangevinThermostatOptimizerState"""
        this = _IMP_atom.new_LangevinThermostatOptimizerState(m, pis, temperature, gamma)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set_particles(self, pis):
        """set_particles(LangevinThermostatOptimizerState self, IMP::Particles const & pis)"""
        return _IMP_atom.LangevinThermostatOptimizerState_set_particles(self, pis)


    def get_temperature(self):
        """get_temperature(LangevinThermostatOptimizerState self) -> double"""
        return _IMP_atom.LangevinThermostatOptimizerState_get_temperature(self)


    def get_gamma(self):
        """get_gamma(LangevinThermostatOptimizerState self) -> double"""
        return _IMP_atom.LangevinThermostatOptimizerState_get_gamma(self)


    def set_temperature(self, temperature):
        """set_temperature(LangevinThermostatOptimizerState self, double temperature)"""
        return _IMP_atom.LangevinThermostatOptimizerState_set_temperature(self, temperature)


    def set_gamma(self, gamma):
        """set_gamma(LangevinThermostatOptimizerState self, double gamma)"""
        return _IMP_atom.LangevinThermostatOptimizerState_set_gamma(self, gamma)


    def rescale_velocities(self):
        """rescale_velocities(LangevinThermostatOptimizerState self)"""
        return _IMP_atom.LangevinThermostatOptimizerState_rescale_velocities(self)


    def get_version_info(self):
        """get_version_info(LangevinThermostatOptimizerState self) -> VersionInfo"""
        return _IMP_atom.LangevinThermostatOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(LangevinThermostatOptimizerState self) -> std::string"""
        return _IMP_atom.LangevinThermostatOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(LangevinThermostatOptimizerState self) -> std::string"""
        return _IMP_atom.LangevinThermostatOptimizerState___repr__(self)


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

LangevinThermostatOptimizerState_swigregister = _IMP_atom.LangevinThermostatOptimizerState_swigregister
LangevinThermostatOptimizerState_swigregister(LangevinThermostatOptimizerState)

class PDBSelector(IMP.Object):
    """Proxy of C++ IMP::atom::PDBSelector 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::atom::PDBSelector self, std::string name) -> PDBSelector"""
        if self.__class__ == PDBSelector:
            _self = None
        else:
            _self = self
        this = _IMP_atom.new_PDBSelector(_self, name)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

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




    def get_is_selected(self, pdb_line):
        """get_is_selected(PDBSelector self, std::string const & pdb_line) -> bool"""
        return _IMP_atom.PDBSelector_get_is_selected(self, pdb_line)

    __swig_destroy__ = _IMP_atom.delete_PDBSelector
    __del__ = lambda self: None

    def __str__(self):
        """__str__(PDBSelector self) -> std::string"""
        return _IMP_atom.PDBSelector___str__(self)


    def __repr__(self):
        """__repr__(PDBSelector self) -> std::string"""
        return _IMP_atom.PDBSelector___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::atom" == "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_PDBSelector(o)


    def __and__(self, s):
        return AndPDBSelector(self, s)
    def __or__(self, s):
        return OrPDBSelector(self, s)
    def __xor__(self, s):
        return XorPDBSelector(self, s)
    def __invert__(self):
        return NotPDBSelector(self)
    def __sub__(self, s):
        return AndPDBSelector(self, NotPDBSelector(s))

    def __disown__(self):
        self.this.disown()
        _IMP_atom.disown_PDBSelector(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(PDBSelector self)"""
        return _IMP_atom.PDBSelector_do_destroy(self)

PDBSelector_swigregister = _IMP_atom.PDBSelector_swigregister
PDBSelector_swigregister(PDBSelector)

class NonAlternativePDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::NonAlternativePDBSelector 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::atom::NonAlternativePDBSelector self, std::string name) -> NonAlternativePDBSelector
        __init__(IMP::atom::NonAlternativePDBSelector self) -> NonAlternativePDBSelector
        """
        this = _IMP_atom.new_NonAlternativePDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(NonAlternativePDBSelector self) -> VersionInfo"""
        return _IMP_atom.NonAlternativePDBSelector_get_version_info(self)


    def __str__(self):
        """__str__(NonAlternativePDBSelector self) -> std::string"""
        return _IMP_atom.NonAlternativePDBSelector___str__(self)


    def __repr__(self):
        """__repr__(NonAlternativePDBSelector self) -> std::string"""
        return _IMP_atom.NonAlternativePDBSelector___repr__(self)


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

NonAlternativePDBSelector_swigregister = _IMP_atom.NonAlternativePDBSelector_swigregister
NonAlternativePDBSelector_swigregister(NonAlternativePDBSelector)

class ATOMPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::ATOMPDBSelector 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::atom::ATOMPDBSelector self, std::string name) -> ATOMPDBSelector
        __init__(IMP::atom::ATOMPDBSelector self) -> ATOMPDBSelector
        """
        this = _IMP_atom.new_ATOMPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(ATOMPDBSelector self) -> std::string"""
        return _IMP_atom.ATOMPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(ATOMPDBSelector self) -> std::string"""
        return _IMP_atom.ATOMPDBSelector___repr__(self)


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

ATOMPDBSelector_swigregister = _IMP_atom.ATOMPDBSelector_swigregister
ATOMPDBSelector_swigregister(ATOMPDBSelector)

class CAlphaPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::CAlphaPDBSelector 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::atom::CAlphaPDBSelector self, std::string name) -> CAlphaPDBSelector
        __init__(IMP::atom::CAlphaPDBSelector self) -> CAlphaPDBSelector
        """
        this = _IMP_atom.new_CAlphaPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(CAlphaPDBSelector self) -> std::string"""
        return _IMP_atom.CAlphaPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(CAlphaPDBSelector self) -> std::string"""
        return _IMP_atom.CAlphaPDBSelector___repr__(self)


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

CAlphaPDBSelector_swigregister = _IMP_atom.CAlphaPDBSelector_swigregister
CAlphaPDBSelector_swigregister(CAlphaPDBSelector)

class CBetaPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::CBetaPDBSelector 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::atom::CBetaPDBSelector self, std::string name) -> CBetaPDBSelector
        __init__(IMP::atom::CBetaPDBSelector self) -> CBetaPDBSelector
        """
        this = _IMP_atom.new_CBetaPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(CBetaPDBSelector self) -> std::string"""
        return _IMP_atom.CBetaPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(CBetaPDBSelector self) -> std::string"""
        return _IMP_atom.CBetaPDBSelector___repr__(self)


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

CBetaPDBSelector_swigregister = _IMP_atom.CBetaPDBSelector_swigregister
CBetaPDBSelector_swigregister(CBetaPDBSelector)

class AtomTypePDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::AtomTypePDBSelector 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::atom::AtomTypePDBSelector self, IMP::Strings atom_types, std::string name) -> AtomTypePDBSelector
        __init__(IMP::atom::AtomTypePDBSelector self, IMP::Strings atom_types) -> AtomTypePDBSelector
        """
        this = _IMP_atom.new_AtomTypePDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(AtomTypePDBSelector self) -> VersionInfo"""
        return _IMP_atom.AtomTypePDBSelector_get_version_info(self)


    def __str__(self):
        """__str__(AtomTypePDBSelector self) -> std::string"""
        return _IMP_atom.AtomTypePDBSelector___str__(self)


    def __repr__(self):
        """__repr__(AtomTypePDBSelector self) -> std::string"""
        return _IMP_atom.AtomTypePDBSelector___repr__(self)


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

AtomTypePDBSelector_swigregister = _IMP_atom.AtomTypePDBSelector_swigregister
AtomTypePDBSelector_swigregister(AtomTypePDBSelector)

class ResidueTypePDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::ResidueTypePDBSelector 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::atom::ResidueTypePDBSelector self, IMP::Strings residue_types, std::string name) -> ResidueTypePDBSelector
        __init__(IMP::atom::ResidueTypePDBSelector self, IMP::Strings residue_types) -> ResidueTypePDBSelector
        """
        this = _IMP_atom.new_ResidueTypePDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(ResidueTypePDBSelector self) -> VersionInfo"""
        return _IMP_atom.ResidueTypePDBSelector_get_version_info(self)


    def __str__(self):
        """__str__(ResidueTypePDBSelector self) -> std::string"""
        return _IMP_atom.ResidueTypePDBSelector___str__(self)


    def __repr__(self):
        """__repr__(ResidueTypePDBSelector self) -> std::string"""
        return _IMP_atom.ResidueTypePDBSelector___repr__(self)


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

ResidueTypePDBSelector_swigregister = _IMP_atom.ResidueTypePDBSelector_swigregister
ResidueTypePDBSelector_swigregister(ResidueTypePDBSelector)

class CPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::CPDBSelector 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::atom::CPDBSelector self, std::string name) -> CPDBSelector
        __init__(IMP::atom::CPDBSelector self) -> CPDBSelector
        """
        this = _IMP_atom.new_CPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(CPDBSelector self) -> std::string"""
        return _IMP_atom.CPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(CPDBSelector self) -> std::string"""
        return _IMP_atom.CPDBSelector___repr__(self)


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

CPDBSelector_swigregister = _IMP_atom.CPDBSelector_swigregister
CPDBSelector_swigregister(CPDBSelector)

class NPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::NPDBSelector 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::atom::NPDBSelector self, std::string name) -> NPDBSelector
        __init__(IMP::atom::NPDBSelector self) -> NPDBSelector
        """
        this = _IMP_atom.new_NPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(NPDBSelector self) -> std::string"""
        return _IMP_atom.NPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(NPDBSelector self) -> std::string"""
        return _IMP_atom.NPDBSelector___repr__(self)


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

NPDBSelector_swigregister = _IMP_atom.NPDBSelector_swigregister
NPDBSelector_swigregister(NPDBSelector)

class AllPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::AllPDBSelector 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::atom::AllPDBSelector self, std::string name) -> AllPDBSelector
        __init__(IMP::atom::AllPDBSelector self) -> AllPDBSelector
        """
        this = _IMP_atom.new_AllPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(AllPDBSelector self) -> VersionInfo"""
        return _IMP_atom.AllPDBSelector_get_version_info(self)


    def __str__(self):
        """__str__(AllPDBSelector self) -> std::string"""
        return _IMP_atom.AllPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(AllPDBSelector self) -> std::string"""
        return _IMP_atom.AllPDBSelector___repr__(self)


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

AllPDBSelector_swigregister = _IMP_atom.AllPDBSelector_swigregister
AllPDBSelector_swigregister(AllPDBSelector)

class ChainPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::ChainPDBSelector 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::atom::ChainPDBSelector self, std::string const & chains, std::string name) -> ChainPDBSelector
        __init__(IMP::atom::ChainPDBSelector self, std::string const & chains) -> ChainPDBSelector
        """
        this = _IMP_atom.new_ChainPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(ChainPDBSelector self) -> std::string"""
        return _IMP_atom.ChainPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(ChainPDBSelector self) -> std::string"""
        return _IMP_atom.ChainPDBSelector___repr__(self)


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

ChainPDBSelector_swigregister = _IMP_atom.ChainPDBSelector_swigregister
ChainPDBSelector_swigregister(ChainPDBSelector)

class WaterPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::WaterPDBSelector 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::atom::WaterPDBSelector self, std::string name) -> WaterPDBSelector
        __init__(IMP::atom::WaterPDBSelector self) -> WaterPDBSelector
        """
        this = _IMP_atom.new_WaterPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(WaterPDBSelector self) -> std::string"""
        return _IMP_atom.WaterPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(WaterPDBSelector self) -> std::string"""
        return _IMP_atom.WaterPDBSelector___repr__(self)


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

WaterPDBSelector_swigregister = _IMP_atom.WaterPDBSelector_swigregister
WaterPDBSelector_swigregister(WaterPDBSelector)

class HydrogenPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::HydrogenPDBSelector 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::atom::HydrogenPDBSelector self, std::string name) -> HydrogenPDBSelector
        __init__(IMP::atom::HydrogenPDBSelector self) -> HydrogenPDBSelector
        """
        this = _IMP_atom.new_HydrogenPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(HydrogenPDBSelector self) -> std::string"""
        return _IMP_atom.HydrogenPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(HydrogenPDBSelector self) -> std::string"""
        return _IMP_atom.HydrogenPDBSelector___repr__(self)


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

HydrogenPDBSelector_swigregister = _IMP_atom.HydrogenPDBSelector_swigregister
HydrogenPDBSelector_swigregister(HydrogenPDBSelector)

class NonWaterNonHydrogenPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::NonWaterNonHydrogenPDBSelector 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::atom::NonWaterNonHydrogenPDBSelector self, std::string name) -> NonWaterNonHydrogenPDBSelector
        __init__(IMP::atom::NonWaterNonHydrogenPDBSelector self) -> NonWaterNonHydrogenPDBSelector
        """
        this = _IMP_atom.new_NonWaterNonHydrogenPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(NonWaterNonHydrogenPDBSelector self) -> std::string"""
        return _IMP_atom.NonWaterNonHydrogenPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(NonWaterNonHydrogenPDBSelector self) -> std::string"""
        return _IMP_atom.NonWaterNonHydrogenPDBSelector___repr__(self)


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

NonWaterNonHydrogenPDBSelector_swigregister = _IMP_atom.NonWaterNonHydrogenPDBSelector_swigregister
NonWaterNonHydrogenPDBSelector_swigregister(NonWaterNonHydrogenPDBSelector)

class NonWaterPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::NonWaterPDBSelector 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::atom::NonWaterPDBSelector self, std::string name) -> NonWaterPDBSelector
        __init__(IMP::atom::NonWaterPDBSelector self) -> NonWaterPDBSelector
        """
        this = _IMP_atom.new_NonWaterPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(NonWaterPDBSelector self) -> std::string"""
        return _IMP_atom.NonWaterPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(NonWaterPDBSelector self) -> std::string"""
        return _IMP_atom.NonWaterPDBSelector___repr__(self)


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

NonWaterPDBSelector_swigregister = _IMP_atom.NonWaterPDBSelector_swigregister
NonWaterPDBSelector_swigregister(NonWaterPDBSelector)

class BackbonePDBSelector(NonWaterNonHydrogenPDBSelector):
    """Proxy of C++ IMP::atom::BackbonePDBSelector 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::atom::BackbonePDBSelector self, std::string name) -> BackbonePDBSelector
        __init__(IMP::atom::BackbonePDBSelector self) -> BackbonePDBSelector
        """
        this = _IMP_atom.new_BackbonePDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(BackbonePDBSelector self) -> std::string"""
        return _IMP_atom.BackbonePDBSelector___str__(self)


    def __repr__(self):
        """__repr__(BackbonePDBSelector self) -> std::string"""
        return _IMP_atom.BackbonePDBSelector___repr__(self)


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

BackbonePDBSelector_swigregister = _IMP_atom.BackbonePDBSelector_swigregister
BackbonePDBSelector_swigregister(BackbonePDBSelector)

class PPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::PPDBSelector 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::atom::PPDBSelector self, std::string name) -> PPDBSelector
        __init__(IMP::atom::PPDBSelector self) -> PPDBSelector
        """
        this = _IMP_atom.new_PPDBSelector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(PPDBSelector self) -> std::string"""
        return _IMP_atom.PPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(PPDBSelector self) -> std::string"""
        return _IMP_atom.PPDBSelector___repr__(self)


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

PPDBSelector_swigregister = _IMP_atom.PPDBSelector_swigregister
PPDBSelector_swigregister(PPDBSelector)

class AndPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::AndPDBSelector 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(AndPDBSelector self) -> VersionInfo"""
        return _IMP_atom.AndPDBSelector_get_version_info(self)


    def __init__(self, a, b):
        """__init__(IMP::atom::AndPDBSelector self, PDBSelector a, PDBSelector b) -> AndPDBSelector"""
        this = _IMP_atom.new_AndPDBSelector(a, b)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(AndPDBSelector self) -> std::string"""
        return _IMP_atom.AndPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(AndPDBSelector self) -> std::string"""
        return _IMP_atom.AndPDBSelector___repr__(self)


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

AndPDBSelector_swigregister = _IMP_atom.AndPDBSelector_swigregister
AndPDBSelector_swigregister(AndPDBSelector)

class OrPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::OrPDBSelector 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(OrPDBSelector self) -> VersionInfo"""
        return _IMP_atom.OrPDBSelector_get_version_info(self)


    def __init__(self, a, b):
        """__init__(IMP::atom::OrPDBSelector self, PDBSelector a, PDBSelector b) -> OrPDBSelector"""
        this = _IMP_atom.new_OrPDBSelector(a, b)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(OrPDBSelector self) -> std::string"""
        return _IMP_atom.OrPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(OrPDBSelector self) -> std::string"""
        return _IMP_atom.OrPDBSelector___repr__(self)


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

OrPDBSelector_swigregister = _IMP_atom.OrPDBSelector_swigregister
OrPDBSelector_swigregister(OrPDBSelector)

class XorPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::XorPDBSelector 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(XorPDBSelector self) -> VersionInfo"""
        return _IMP_atom.XorPDBSelector_get_version_info(self)


    def __init__(self, a, b):
        """__init__(IMP::atom::XorPDBSelector self, PDBSelector a, PDBSelector b) -> XorPDBSelector"""
        this = _IMP_atom.new_XorPDBSelector(a, b)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(XorPDBSelector self) -> std::string"""
        return _IMP_atom.XorPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(XorPDBSelector self) -> std::string"""
        return _IMP_atom.XorPDBSelector___repr__(self)


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

XorPDBSelector_swigregister = _IMP_atom.XorPDBSelector_swigregister
XorPDBSelector_swigregister(XorPDBSelector)

class NotPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::NotPDBSelector 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(NotPDBSelector self) -> VersionInfo"""
        return _IMP_atom.NotPDBSelector_get_version_info(self)


    def __init__(self, a):
        """__init__(IMP::atom::NotPDBSelector self, PDBSelector a) -> NotPDBSelector"""
        this = _IMP_atom.new_NotPDBSelector(a)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __str__(self):
        """__str__(NotPDBSelector self) -> std::string"""
        return _IMP_atom.NotPDBSelector___str__(self)


    def __repr__(self):
        """__repr__(NotPDBSelector self) -> std::string"""
        return _IMP_atom.NotPDBSelector___repr__(self)


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

NotPDBSelector_swigregister = _IMP_atom.NotPDBSelector_swigregister
NotPDBSelector_swigregister(NotPDBSelector)


def get_default_pdb_selector():
    """get_default_pdb_selector() -> PDBSelector"""
    return _IMP_atom.get_default_pdb_selector()

def read_pdb(*args):
    """
    read_pdb(TextInput input, Model model, PDBSelector selector, bool select_first_model=True, bool no_radii=False) -> Hierarchy
    read_pdb(TextInput input, Model model, PDBSelector selector, bool select_first_model=True) -> Hierarchy
    read_pdb(TextInput input, Model model, PDBSelector selector) -> Hierarchy
    read_pdb(TextInput input, Model model) -> Hierarchy
    read_pdb(TextInput input, int model, Hierarchy h)
    """
    return _IMP_atom.read_pdb(*args)

def read_multimodel_pdb(*args):
    """
    read_multimodel_pdb(TextInput input, Model model, PDBSelector selector, bool noradii=False) -> IMP::atom::Hierarchies
    read_multimodel_pdb(TextInput input, Model model, PDBSelector selector) -> IMP::atom::Hierarchies
    read_multimodel_pdb(TextInput input, Model model) -> IMP::atom::Hierarchies
    """
    return _IMP_atom.read_multimodel_pdb(*args)

def write_pdb(mhd, out, model=1):
    """
    write_pdb(Selection mhd, TextOutput out, unsigned int model=1)
    write_pdb(Selection mhd, TextOutput out)
    """
    return _IMP_atom.write_pdb(mhd, out, model)

def write_pdb_of_c_alphas(mhd, out, model=1):
    """
    write_pdb_of_c_alphas(Selection mhd, TextOutput out, unsigned int model=1)
    write_pdb_of_c_alphas(Selection mhd, TextOutput out)
    """
    return _IMP_atom.write_pdb_of_c_alphas(mhd, out, model)

def write_multimodel_pdb(mhd, out):
    """write_multimodel_pdb(IMP::atom::Hierarchies const & mhd, TextOutput out)"""
    return _IMP_atom.write_multimodel_pdb(mhd, out)

def get_pdb_string(*args):
    """
    get_pdb_string(Vector3D v, int index=-1, AtomType at, ResidueType rt, char chain, int res_index=1, char res_icode, double occpancy=1.00, double tempFactor=0.00, IMP::atom::Element e) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at, ResidueType rt, char chain, int res_index=1, char res_icode, double occpancy=1.00, double tempFactor=0.00) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at, ResidueType rt, char chain, int res_index=1, char res_icode, double occpancy=1.00) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at, ResidueType rt, char chain, int res_index=1, char res_icode) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at, ResidueType rt, char chain, int res_index=1) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at, ResidueType rt, char chain) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at, ResidueType rt) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at) -> std::string
    get_pdb_string(Vector3D v, int index=-1) -> std::string
    get_pdb_string(Vector3D v) -> std::string
    """
    return _IMP_atom.get_pdb_string(*args)

def get_pdb_conect_record_string(arg1, arg2):
    """get_pdb_conect_record_string(int arg1, int arg2) -> std::string"""
    return _IMP_atom.get_pdb_conect_record_string(arg1, arg2)
class WritePDBOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::atom::WritePDBOptimizerState 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::atom::WritePDBOptimizerState self, Model m, _ParticleIndexesAdaptor pis, std::string filename) -> WritePDBOptimizerState
        __init__(IMP::atom::WritePDBOptimizerState self, IMP::atom::Hierarchies const mh, std::string filename) -> WritePDBOptimizerState
        """
        this = _IMP_atom.new_WritePDBOptimizerState(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_version_info(self):
        """get_version_info(WritePDBOptimizerState self) -> VersionInfo"""
        return _IMP_atom.WritePDBOptimizerState_get_version_info(self)


    def __str__(self):
        """__str__(WritePDBOptimizerState self) -> std::string"""
        return _IMP_atom.WritePDBOptimizerState___str__(self)


    def __repr__(self):
        """__repr__(WritePDBOptimizerState self) -> std::string"""
        return _IMP_atom.WritePDBOptimizerState___repr__(self)


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

WritePDBOptimizerState_swigregister = _IMP_atom.WritePDBOptimizerState_swigregister
WritePDBOptimizerState_swigregister(WritePDBOptimizerState)


def get_kt(T):
    """get_kt(double T) -> double"""
    return _IMP_atom.get_kt(T)
class CAAngleRestraint(IMP.Restraint):
    """Proxy of C++ IMP::atom::CAAngleRestraint class."""

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

    def __init__(self, m, p1, p2, p3, phi0, score):
        """__init__(IMP::atom::CAAngleRestraint self, Model m, _ParticleIndexAdaptor p1, _ParticleIndexAdaptor p2, _ParticleIndexAdaptor p3, IMP::Floats phi0, IMP::Floats score) -> CAAngleRestraint"""
        this = _IMP_atom.new_CAAngleRestraint(m, p1, p2, p3, phi0, score)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(CAAngleRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.CAAngleRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(CAAngleRestraint self) -> VersionInfo"""
        return _IMP_atom.CAAngleRestraint_get_version_info(self)


    def __str__(self):
        """__str__(CAAngleRestraint self) -> std::string"""
        return _IMP_atom.CAAngleRestraint___str__(self)


    def __repr__(self):
        """__repr__(CAAngleRestraint self) -> std::string"""
        return _IMP_atom.CAAngleRestraint___repr__(self)


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

CAAngleRestraint_swigregister = _IMP_atom.CAAngleRestraint_swigregister
CAAngleRestraint_swigregister(CAAngleRestraint)

class CADihedralRestraint(IMP.Restraint):
    """Proxy of C++ IMP::atom::CADihedralRestraint class."""

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

    def __init__(self, m, p1, p2, p3, p4, p5, phi0, phi1, score):
        """__init__(IMP::atom::CADihedralRestraint self, Model m, _ParticleIndexAdaptor p1, _ParticleIndexAdaptor p2, _ParticleIndexAdaptor p3, _ParticleIndexAdaptor p4, _ParticleIndexAdaptor p5, IMP::Floats phi0, IMP::Floats phi1, IMP::Floats score) -> CADihedralRestraint"""
        this = _IMP_atom.new_CADihedralRestraint(m, p1, p2, p3, p4, p5, phi0, phi1, score)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def do_get_inputs(self):
        """do_get_inputs(CADihedralRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_atom.CADihedralRestraint_do_get_inputs(self)


    def get_version_info(self):
        """get_version_info(CADihedralRestraint self) -> VersionInfo"""
        return _IMP_atom.CADihedralRestraint_get_version_info(self)


    def __str__(self):
        """__str__(CADihedralRestraint self) -> std::string"""
        return _IMP_atom.CADihedralRestraint___str__(self)


    def __repr__(self):
        """__repr__(CADihedralRestraint self) -> std::string"""
        return _IMP_atom.CADihedralRestraint___repr__(self)


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

CADihedralRestraint_swigregister = _IMP_atom.CADihedralRestraint_swigregister
CADihedralRestraint_swigregister(CADihedralRestraint)

class StructureSource(IMP.Decorator):
    """Proxy of C++ IMP::atom::StructureSource class."""

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

    def get_source_id(self):
        """get_source_id(StructureSource self) -> std::string"""
        return _IMP_atom.StructureSource_get_source_id(self)


    def get_source_chain_id(self):
        """get_source_chain_id(StructureSource self) -> std::string"""
        return _IMP_atom.StructureSource_get_source_chain_id(self)


    def set_source_id(self, source_id):
        """set_source_id(StructureSource self, std::string source_id)"""
        return _IMP_atom.StructureSource_set_source_id(self, source_id)


    def set_source_chain_id(self, source_chain_id):
        """set_source_chain_id(StructureSource self, std::string source_chain_id)"""
        return _IMP_atom.StructureSource_set_source_chain_id(self, source_chain_id)


    def __init__(self, *args):
        """
        __init__(IMP::atom::StructureSource self) -> StructureSource
        __init__(IMP::atom::StructureSource self, Model m, ParticleIndex id) -> StructureSource
        __init__(IMP::atom::StructureSource self, _ParticleAdaptor d) -> StructureSource
        """
        this = _IMP_atom.new_StructureSource(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_is_setup(*args):
        """
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_atom.StructureSource_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(StructureSource self, _ostream out)
        show(StructureSource self)
        """
        return _IMP_atom.StructureSource_show(self, *args)


    def setup_particle(*args):
        """
        setup_particle(Model m, ParticleIndex pi, std::string source_id, std::string source_chain_id) -> StructureSource
        setup_particle(_ParticleAdaptor decorator, std::string source_id, std::string source_chain_id) -> StructureSource
        """
        return _IMP_atom.StructureSource_setup_particle(*args)

    setup_particle = staticmethod(setup_particle)

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


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


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


    def remove_attribute(self, *args):
        """
        remove_attribute(StructureSource self, FloatKey a0)
        remove_attribute(StructureSource self, IntKey a0)
        remove_attribute(StructureSource self, StringKey a0)
        remove_attribute(StructureSource self, ParticleIndexKey a0)
        remove_attribute(StructureSource self, ObjectKey a0)
        """
        return _IMP_atom.StructureSource_remove_attribute(self, *args)


    def has_attribute(self, *args):
        """
        has_attribute(StructureSource self, FloatKey a0) -> bool
        has_attribute(StructureSource self, IntKey a0) -> bool
        has_attribute(StructureSource self, StringKey a0) -> bool
        has_attribute(StructureSource self, ParticleIndexKey a0) -> bool
        has_attribute(StructureSource self, ObjectKey a0) -> bool
        """
        return _IMP_atom.StructureSource_has_attribute(self, *args)


    def get_derivative(self, a0):
        """get_derivative(StructureSource self, FloatKey a0) -> double"""
        return _IMP_atom.StructureSource_get_derivative(self, a0)


    def get_name(self):
        """get_name(StructureSource self) -> std::string"""
        return _IMP_atom.StructureSource_get_name(self)


    def clear_caches(self):
        """clear_caches(StructureSource self)"""
        return _IMP_atom.StructureSource_clear_caches(self)


    def set_name(self, a0):
        """set_name(StructureSource self, std::string a0)"""
        return _IMP_atom.StructureSource_set_name(self, a0)


    def set_check_level(self, a0):
        """set_check_level(StructureSource self, IMP::CheckLevel a0)"""
        return _IMP_atom.StructureSource_set_check_level(self, a0)


    def add_to_derivative(self, a0, a1, a2):
        """add_to_derivative(StructureSource self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.StructureSource_add_to_derivative(self, a0, a1, a2)


    def set_is_optimized(self, a0, a1):
        """set_is_optimized(StructureSource self, FloatKey a0, bool a1)"""
        return _IMP_atom.StructureSource_set_is_optimized(self, a0, a1)


    def get_is_optimized(self, a0):
        """get_is_optimized(StructureSource self, FloatKey a0) -> bool"""
        return _IMP_atom.StructureSource_get_is_optimized(self, a0)


    def get_check_level(self):
        """get_check_level(StructureSource self) -> IMP::CheckLevel"""
        return _IMP_atom.StructureSource_get_check_level(self)


    def __eq__(self, *args):
        """
        __eq__(StructureSource self, StructureSource o) -> bool
        __eq__(StructureSource self, Particle d) -> bool
        """
        return _IMP_atom.StructureSource___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(StructureSource self, StructureSource o) -> bool
        __ne__(StructureSource self, Particle d) -> bool
        """
        return _IMP_atom.StructureSource___ne__(self, *args)


    def __le__(self, *args):
        """
        __le__(StructureSource self, StructureSource o) -> bool
        __le__(StructureSource self, Particle d) -> bool
        """
        return _IMP_atom.StructureSource___le__(self, *args)


    def __lt__(self, *args):
        """
        __lt__(StructureSource self, StructureSource o) -> bool
        __lt__(StructureSource self, Particle d) -> bool
        """
        return _IMP_atom.StructureSource___lt__(self, *args)


    def __ge__(self, *args):
        """
        __ge__(StructureSource self, StructureSource o) -> bool
        __ge__(StructureSource self, Particle d) -> bool
        """
        return _IMP_atom.StructureSource___ge__(self, *args)


    def __gt__(self, *args):
        """
        __gt__(StructureSource self, StructureSource o) -> bool
        __gt__(StructureSource self, Particle d) -> bool
        """
        return _IMP_atom.StructureSource___gt__(self, *args)


    def __hash__(self):
        """__hash__(StructureSource self) -> std::size_t"""
        return _IMP_atom.StructureSource___hash__(self)


    def __str__(self):
        """__str__(StructureSource self) -> std::string"""
        return _IMP_atom.StructureSource___str__(self)


    def __repr__(self):
        """__repr__(StructureSource self) -> std::string"""
        return _IMP_atom.StructureSource___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_StructureSource
    __del__ = lambda self: None
StructureSource_swigregister = _IMP_atom.StructureSource_swigregister
StructureSource_swigregister(StructureSource)

def StructureSource_get_is_setup(*args):
    """
    get_is_setup(Model m, ParticleIndex pi) -> bool
    StructureSource_get_is_setup(_ParticleAdaptor p) -> bool
    """
    return _IMP_atom.StructureSource_get_is_setup(*args)

def StructureSource_setup_particle(*args):
    """
    setup_particle(Model m, ParticleIndex pi, std::string source_id, std::string source_chain_id) -> StructureSource
    StructureSource_setup_particle(_ParticleAdaptor decorator, std::string source_id, std::string source_chain_id) -> StructureSource
    """
    return _IMP_atom.StructureSource_setup_particle(*args)


def __lshift__(*args):
    """
    __lshift__(_ostream out, Bonded n) -> _ostream
    __lshift__(_ostream out, Bond n) -> _ostream
    __lshift__(_ostream out, Hierarchy n) -> _ostream
    __lshift__(_ostream out, Angle n) -> _ostream
    __lshift__(_ostream out, Dihedral n) -> _ostream
    __lshift__(_ostream out, CenterOfMass n) -> _ostream
    __lshift__(_ostream out, Diffusion n) -> _ostream
    __lshift__(_ostream out, RigidBodyDiffusion n) -> _ostream
    __lshift__(_ostream out, TAMDParticle n) -> _ostream
    __lshift__(_ostream out, Chain n) -> _ostream
    __lshift__(_ostream out, Charged n) -> _ostream
    __lshift__(_ostream out, Domain n) -> _ostream
    __lshift__(_ostream out, LennardJones n) -> _ostream
    __lshift__(_ostream out, Fragment n) -> _ostream
    __lshift__(_ostream out, SecondaryStructureResidue n) -> _ostream
    __lshift__(_ostream out, Atom n) -> _ostream
    __lshift__(_ostream out, Residue n) -> _ostream
    __lshift__(_ostream out, Representation n) -> _ostream
    __lshift__(_ostream out, State n) -> _ostream
    __lshift__(_ostream out, Molecule n) -> _ostream
    __lshift__(_ostream out, Copy n) -> _ostream
    __lshift__(_ostream out, StructureSource n) -> _ostream
    """
    return _IMP_atom.__lshift__(*args)

def show_molecular_hierarchy(*args):
    """
    show_molecular_hierarchy(Hierarchy h, _ostream out) -> _ostream
    show_molecular_hierarchy(Hierarchy h) -> _ostream
    """
    return _IMP_atom.show_molecular_hierarchy(*args)
class CHARMMBond(object):
    """Proxy of C++ IMP::atom::CHARMMConnection<(2)> 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, atoms):
        """__init__(IMP::atom::CHARMMConnection<(2)> self, IMP::Strings const & atoms) -> CHARMMBond"""
        this = _IMP_atom.new_CHARMMBond(atoms)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_endpoint(self, i):
        """get_endpoint(CHARMMBond self, unsigned int i) -> CHARMMBondEndpoint"""
        return _IMP_atom.CHARMMBond_get_endpoint(self, i)


    def get_contains_atom(self, name):
        """get_contains_atom(CHARMMBond self, std::string name) -> bool"""
        return _IMP_atom.CHARMMBond_get_contains_atom(self, name)


    def show(self, *args):
        """
        show(CHARMMBond self, _ostream out)
        show(CHARMMBond self)
        """
        return _IMP_atom.CHARMMBond_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete_CHARMMBond
    __del__ = lambda self: None
CHARMMBond_swigregister = _IMP_atom.CHARMMBond_swigregister
CHARMMBond_swigregister(CHARMMBond)

class CHARMMAngle(object):
    """Proxy of C++ IMP::atom::CHARMMConnection<(3)> 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, atoms):
        """__init__(IMP::atom::CHARMMConnection<(3)> self, IMP::Strings const & atoms) -> CHARMMAngle"""
        this = _IMP_atom.new_CHARMMAngle(atoms)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def get_endpoint(self, i):
        """get_endpoint(CHARMMAngle self, unsigned int i) -> CHARMMBondEndpoint"""
        return _IMP_atom.CHARMMAngle_get_endpoint(self, i)


    def get_contains_atom(self, name):
        """get_contains_atom(CHARMMAngle self, std::string name) -> bool"""
        return _IMP_atom.CHARMMAngle_get_contains_atom(self, name)


    def show(self, *args):
        """
        show(CHARMMAngle self, _ostream out)
        show(CHARMMAngle self)
        """
        return _IMP_atom.CHARMMAngle_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete_CHARMMAngle
    __del__ = lambda self: None
CHARMMAngle_swigregister = _IMP_atom.CHARMMAngle_swigregister
CHARMMAngle_swigregister(CHARMMAngle)


def _get_native_overlap_cpp(m1, m2, threshold):
    """_get_native_overlap_cpp(IMP::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::Vector< IMP::algebra::VectorD< 3 > > const & m2, double threshold) -> double"""
    return _IMP_atom._get_native_overlap_cpp(m1, m2, threshold)

def _get_drmsd_cpp(m0, m1):
    """_get_drmsd_cpp(IMP::Vector< IMP::algebra::VectorD< 3 > > const & m0, IMP::Vector< IMP::algebra::VectorD< 3 > > const & m1) -> double"""
    return _IMP_atom._get_drmsd_cpp(m0, m1)

def _get_drmsd_Q_cpp(m0, m1, threshold):
    """_get_drmsd_Q_cpp(IMP::Vector< IMP::algebra::VectorD< 3 > > const & m0, IMP::Vector< IMP::algebra::VectorD< 3 > > const & m1, double threshold) -> double"""
    return _IMP_atom._get_drmsd_Q_cpp(m0, m1, threshold)

def _get_drms_cpp(m1, m2):
    """_get_drms_cpp(IMP::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::Vector< IMP::algebra::VectorD< 3 > > const & m2) -> double"""
    return _IMP_atom._get_drms_cpp(m1, m2)

def _get_rigid_bodies_drms_cpp(m1, m2, ranges):
    """_get_rigid_bodies_drms_cpp(IMP::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::Vector< IMP::algebra::VectorD< 3 > > const & m2, IMP::IntRanges const & ranges) -> double"""
    return _IMP_atom._get_rigid_bodies_drms_cpp(m1, m2, ranges)

def get_native_overlap(a, b, d):
   va= [IMP.algebra.get_vector(x) for x in a]
   vb= [IMP.algebra.get_vector(x) for x in b]
   return _get_native_overlap_cpp(va, vb, d)

def get_drmsd(a, b):
   va= [IMP.algebra.get_vector(x) for x in a]
   vb= [IMP.algebra.get_vector(x) for x in b]
   return _get_drmsd_cpp(va, vb)

def get_drms(a, b):
   va= [IMP.algebra.get_vector(x) for x in a]
   vb= [IMP.algebra.get_vector(x) for x in b]
   return _get_drms_cpp(va, vb)

def get_drmsd_Q(a, b, t):
   va= [IMP.algebra.get_vector(x) for x in a]
   vb= [IMP.algebra.get_vector(x) for x in b]
   return _get_drmsd_Q_cpp(va, vb, t)

def get_rigid_bodies_drms(a, b, ranges):
    va= [IMP.algebra.get_vector(x) for x in a]
    vb= [IMP.algebra.get_vector(x) for x in b]
#rs = [IMP.IntRange(r[0],r[1]) for r in ranges]
    return _get_rigid_bodies_drms_cpp(va, vb, ranges)



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

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

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

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