atom/__init__.py

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



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

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


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


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

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

    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, *args):
        """advance(IMP_ATOM_SwigPyIterator self, ptrdiff_t n) -> IMP_ATOM_SwigPyIterator"""
        return _IMP_atom.IMP_ATOM_SwigPyIterator_advance(self, *args)

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

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

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

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

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

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

DEFAULT_CHECK = _IMP_atom.DEFAULT_CHECK
NONE = _IMP_atom.NONE
USAGE = _IMP_atom.USAGE
USAGE_AND_INTERNAL = _IMP_atom.USAGE_AND_INTERNAL

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

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

_ostream_swigregister = _IMP_atom._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_atom.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_atom.IMP_COMPILER_HAS_FINAL
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_atom.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_atom.IMP_CGAL_HAS_BOOST_SYSTEM
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_atom.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_atom.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_atom.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_atom.IMP_ALGEBRA_HAS_ANN
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_atom.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_atom.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_atom.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_atom.IMP_KERNEL_HAS_CGAL
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_atom.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_atom.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_atom.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_atom.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_atom.IMP_DISPLAY_HAS_CGAL
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_atom.IMP_SCORE_FUNCTOR_HAS_CGAL
import IMP.score_functor
IMP_CORE_HAS_IMP_BASE = _IMP_atom.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_atom.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_atom.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_atom.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_atom.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_atom.IMP_CORE_HAS_CGAL
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_atom.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_atom.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_atom.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_atom.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_atom.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_atom.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_atom.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_atom.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_atom.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_atom.IMP_CONTAINER_HAS_CGAL
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_atom.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_atom.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_atom.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_atom.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_atom.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_atom.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_atom.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_atom.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_atom.IMP_ATOM_HAS_CGAL
IMP_ATOM_TYPE_INDEX = _IMP_atom.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_atom.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_atom.IMP_HIERARCHY_TYPE_INDEX
class HierarchyTree(IMP.base.Object):
    """Proxy of C++ IMP::base::internal::BoostDigraph<(IMP::atom::HierarchyTree,IMP::atom::Hierarchy)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchyTree, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchyTree, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::base::internal::BoostDigraph<(IMP::atom::HierarchyTree,IMP::atom::Hierarchy)> self) -> HierarchyTree"""
        this = _IMP_atom.new_HierarchyTree()
        try: self.this.append(this)
        except: 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::base::internal::BoostDigraph< IMP::atom::HierarchyTree,IMP::atom::Hierarchy >::VertexDescriptors"""
        return _IMP_atom.HierarchyTree_get_vertices(self)

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

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

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

    def do_show(self, *args):
        """do_show(HierarchyTree self, _ostream out)"""
        return _IMP_atom.HierarchyTree_do_show(self, *args)

    def show_graphviz(self, *args):
        """
        show_graphviz(HierarchyTree self, _ostream out=std::cout)
        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 get_type_name(self):
        """get_type_name(HierarchyTree self) -> std::string"""
        return _IMP_atom.HierarchyTree_get_type_name(self)

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

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

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

    __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(*args):
  """_object_cast_to_PDBSelector(Object o) -> PDBSelector"""
  return _IMP_atom._object_cast_to_PDBSelector(*args)
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 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 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 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 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")

_object_types.append("Simulator")


def _object_cast_to_Simulator(*args):
  """_object_cast_to_Simulator(Object o) -> Simulator"""
  return _IMP_atom._object_cast_to_Simulator(*args)
_object_types.append("ATOMPDBSelector")


def _object_cast_to_ATOMPDBSelector(*args):
  """_object_cast_to_ATOMPDBSelector(Object o) -> ATOMPDBSelector"""
  return _IMP_atom._object_cast_to_ATOMPDBSelector(*args)
_object_types.append("AllMol2Selector")


def _object_cast_to_AllMol2Selector(*args):
  """_object_cast_to_AllMol2Selector(Object o) -> AllMol2Selector"""
  return _IMP_atom._object_cast_to_AllMol2Selector(*args)
_object_types.append("AllPDBSelector")


def _object_cast_to_AllPDBSelector(*args):
  """_object_cast_to_AllPDBSelector(Object o) -> AllPDBSelector"""
  return _IMP_atom._object_cast_to_AllPDBSelector(*args)
_object_types.append("AndPDBSelector")


def _object_cast_to_AndPDBSelector(*args):
  """_object_cast_to_AndPDBSelector(Object o) -> AndPDBSelector"""
  return _IMP_atom._object_cast_to_AndPDBSelector(*args)
_object_types.append("AngleSingletonScore")


def _object_cast_to_AngleSingletonScore(*args):
  """_object_cast_to_AngleSingletonScore(Object o) -> AngleSingletonScore"""
  return _IMP_atom._object_cast_to_AngleSingletonScore(*args)
_object_types.append("BondEndpointsRefiner")


def _object_cast_to_BondEndpointsRefiner(*args):
  """_object_cast_to_BondEndpointsRefiner(Object o) -> BondEndpointsRefiner"""
  return _IMP_atom._object_cast_to_BondEndpointsRefiner(*args)
_object_types.append("BondPairContainer")


def _object_cast_to_BondPairContainer(*args):
  """_object_cast_to_BondPairContainer(Object o) -> BondPairContainer"""
  return _IMP_atom._object_cast_to_BondPairContainer(*args)
_object_types.append("BondSingletonScore")


def _object_cast_to_BondSingletonScore(*args):
  """_object_cast_to_BondSingletonScore(Object o) -> BondSingletonScore"""
  return _IMP_atom._object_cast_to_BondSingletonScore(*args)
_object_types.append("BondedPairFilter")


def _object_cast_to_BondedPairFilter(*args):
  """_object_cast_to_BondedPairFilter(Object o) -> BondedPairFilter"""
  return _IMP_atom._object_cast_to_BondedPairFilter(*args)
_object_types.append("BrownianDynamics")


def _object_cast_to_BrownianDynamics(*args):
  """_object_cast_to_BrownianDynamics(Object o) -> BrownianDynamics"""
  return _IMP_atom._object_cast_to_BrownianDynamics(*args)
_object_types.append("CAlphaPDBSelector")


def _object_cast_to_CAlphaPDBSelector(*args):
  """_object_cast_to_CAlphaPDBSelector(Object o) -> CAlphaPDBSelector"""
  return _IMP_atom._object_cast_to_CAlphaPDBSelector(*args)
_object_types.append("CBetaPDBSelector")


def _object_cast_to_CBetaPDBSelector(*args):
  """_object_cast_to_CBetaPDBSelector(Object o) -> CBetaPDBSelector"""
  return _IMP_atom._object_cast_to_CBetaPDBSelector(*args)
_object_types.append("CHARMMParameters")


def _object_cast_to_CHARMMParameters(*args):
  """_object_cast_to_CHARMMParameters(Object o) -> CHARMMParameters"""
  return _IMP_atom._object_cast_to_CHARMMParameters(*args)
_object_types.append("CHARMMResidueTopology")


def _object_cast_to_CHARMMResidueTopology(*args):
  """_object_cast_to_CHARMMResidueTopology(Object o) -> CHARMMResidueTopology"""
  return _IMP_atom._object_cast_to_CHARMMResidueTopology(*args)
_object_types.append("CHARMMSegmentTopology")


def _object_cast_to_CHARMMSegmentTopology(*args):
  """_object_cast_to_CHARMMSegmentTopology(Object o) -> CHARMMSegmentTopology"""
  return _IMP_atom._object_cast_to_CHARMMSegmentTopology(*args)
_object_types.append("CHARMMStereochemistryRestraint")


def _object_cast_to_CHARMMStereochemistryRestraint(*args):
  """_object_cast_to_CHARMMStereochemistryRestraint(Object o) -> CHARMMStereochemistryRestraint"""
  return _IMP_atom._object_cast_to_CHARMMStereochemistryRestraint(*args)
_object_types.append("CHARMMTopology")


def _object_cast_to_CHARMMTopology(*args):
  """_object_cast_to_CHARMMTopology(Object o) -> CHARMMTopology"""
  return _IMP_atom._object_cast_to_CHARMMTopology(*args)
_object_types.append("CPDBSelector")


def _object_cast_to_CPDBSelector(*args):
  """_object_cast_to_CPDBSelector(Object o) -> CPDBSelector"""
  return _IMP_atom._object_cast_to_CPDBSelector(*args)
_object_types.append("ChainPDBSelector")


def _object_cast_to_ChainPDBSelector(*args):
  """_object_cast_to_ChainPDBSelector(Object o) -> ChainPDBSelector"""
  return _IMP_atom._object_cast_to_ChainPDBSelector(*args)
_object_types.append("CoulombPairScore")


def _object_cast_to_CoulombPairScore(*args):
  """_object_cast_to_CoulombPairScore(Object o) -> CoulombPairScore"""
  return _IMP_atom._object_cast_to_CoulombPairScore(*args)
_object_types.append("CoverBond")


def _object_cast_to_CoverBond(*args):
  """_object_cast_to_CoverBond(Object o) -> CoverBond"""
  return _IMP_atom._object_cast_to_CoverBond(*args)
_object_types.append("DihedralSingletonScore")


def _object_cast_to_DihedralSingletonScore(*args):
  """_object_cast_to_DihedralSingletonScore(Object o) -> DihedralSingletonScore"""
  return _IMP_atom._object_cast_to_DihedralSingletonScore(*args)
_object_types.append("DopePairScore")


def _object_cast_to_DopePairScore(*args):
  """_object_cast_to_DopePairScore(Object o) -> DopePairScore"""
  return _IMP_atom._object_cast_to_DopePairScore(*args)
_object_types.append("ForceFieldParameters")


def _object_cast_to_ForceFieldParameters(*args):
  """_object_cast_to_ForceFieldParameters(Object o) -> ForceFieldParameters"""
  return _IMP_atom._object_cast_to_ForceFieldParameters(*args)
_object_types.append("ForceSwitch")


def _object_cast_to_ForceSwitch(*args):
  """_object_cast_to_ForceSwitch(Object o) -> ForceSwitch"""
  return _IMP_atom._object_cast_to_ForceSwitch(*args)
_object_types.append("HydrogenPDBSelector")


def _object_cast_to_HydrogenPDBSelector(*args):
  """_object_cast_to_HydrogenPDBSelector(Object o) -> HydrogenPDBSelector"""
  return _IMP_atom._object_cast_to_HydrogenPDBSelector(*args)
_object_types.append("ImproperSingletonScore")


def _object_cast_to_ImproperSingletonScore(*args):
  """_object_cast_to_ImproperSingletonScore(Object o) -> ImproperSingletonScore"""
  return _IMP_atom._object_cast_to_ImproperSingletonScore(*args)
_object_types.append("LennardJonesPairScore")


def _object_cast_to_LennardJonesPairScore(*args):
  """_object_cast_to_LennardJonesPairScore(Object o) -> LennardJonesPairScore"""
  return _IMP_atom._object_cast_to_LennardJonesPairScore(*args)
_object_types.append("Mol2Selector")


def _object_cast_to_Mol2Selector(*args):
  """_object_cast_to_Mol2Selector(Object o) -> Mol2Selector"""
  return _IMP_atom._object_cast_to_Mol2Selector(*args)
_object_types.append("MolecularDynamics")


def _object_cast_to_MolecularDynamics(*args):
  """_object_cast_to_MolecularDynamics(Object o) -> MolecularDynamics"""
  return _IMP_atom._object_cast_to_MolecularDynamics(*args)
_object_types.append("NPDBSelector")


def _object_cast_to_NPDBSelector(*args):
  """_object_cast_to_NPDBSelector(Object o) -> NPDBSelector"""
  return _IMP_atom._object_cast_to_NPDBSelector(*args)
_object_types.append("NonAlternativePDBSelector")


def _object_cast_to_NonAlternativePDBSelector(*args):
  """_object_cast_to_NonAlternativePDBSelector(Object o) -> NonAlternativePDBSelector"""
  return _IMP_atom._object_cast_to_NonAlternativePDBSelector(*args)
_object_types.append("NonHydrogenMol2Selector")


def _object_cast_to_NonHydrogenMol2Selector(*args):
  """_object_cast_to_NonHydrogenMol2Selector(Object o) -> NonHydrogenMol2Selector"""
  return _IMP_atom._object_cast_to_NonHydrogenMol2Selector(*args)
_object_types.append("NonWaterNonHydrogenPDBSelector")


def _object_cast_to_NonWaterNonHydrogenPDBSelector(*args):
  """_object_cast_to_NonWaterNonHydrogenPDBSelector(Object o) -> NonWaterNonHydrogenPDBSelector"""
  return _IMP_atom._object_cast_to_NonWaterNonHydrogenPDBSelector(*args)
_object_types.append("NonWaterPDBSelector")


def _object_cast_to_NonWaterPDBSelector(*args):
  """_object_cast_to_NonWaterPDBSelector(Object o) -> NonWaterPDBSelector"""
  return _IMP_atom._object_cast_to_NonWaterPDBSelector(*args)
_object_types.append("NotPDBSelector")


def _object_cast_to_NotPDBSelector(*args):
  """_object_cast_to_NotPDBSelector(Object o) -> NotPDBSelector"""
  return _IMP_atom._object_cast_to_NotPDBSelector(*args)
_object_types.append("OrPDBSelector")


def _object_cast_to_OrPDBSelector(*args):
  """_object_cast_to_OrPDBSelector(Object o) -> OrPDBSelector"""
  return _IMP_atom._object_cast_to_OrPDBSelector(*args)
_object_types.append("PPDBSelector")


def _object_cast_to_PPDBSelector(*args):
  """_object_cast_to_PPDBSelector(Object o) -> PPDBSelector"""
  return _IMP_atom._object_cast_to_PPDBSelector(*args)
_object_types.append("ProteinLigandAtomPairScore")


def _object_cast_to_ProteinLigandAtomPairScore(*args):
  """_object_cast_to_ProteinLigandAtomPairScore(Object o) -> ProteinLigandAtomPairScore"""
  return _IMP_atom._object_cast_to_ProteinLigandAtomPairScore(*args)
_object_types.append("ProteinLigandRestraint")


def _object_cast_to_ProteinLigandRestraint(*args):
  """_object_cast_to_ProteinLigandRestraint(Object o) -> ProteinLigandRestraint"""
  return _IMP_atom._object_cast_to_ProteinLigandRestraint(*args)
_object_types.append("SameResiduePairFilter")


def _object_cast_to_SameResiduePairFilter(*args):
  """_object_cast_to_SameResiduePairFilter(Object o) -> SameResiduePairFilter"""
  return _IMP_atom._object_cast_to_SameResiduePairFilter(*args)
_object_types.append("SmoothingFunction")


def _object_cast_to_SmoothingFunction(*args):
  """_object_cast_to_SmoothingFunction(Object o) -> SmoothingFunction"""
  return _IMP_atom._object_cast_to_SmoothingFunction(*args)
_object_types.append("StereochemistryPairFilter")


def _object_cast_to_StereochemistryPairFilter(*args):
  """_object_cast_to_StereochemistryPairFilter(Object o) -> StereochemistryPairFilter"""
  return _IMP_atom._object_cast_to_StereochemistryPairFilter(*args)
_object_types.append("VelocityScalingOptimizerState")


def _object_cast_to_VelocityScalingOptimizerState(*args):
  """_object_cast_to_VelocityScalingOptimizerState(Object o) -> VelocityScalingOptimizerState"""
  return _IMP_atom._object_cast_to_VelocityScalingOptimizerState(*args)
_object_types.append("WaterPDBSelector")


def _object_cast_to_WaterPDBSelector(*args):
  """_object_cast_to_WaterPDBSelector(Object o) -> WaterPDBSelector"""
  return _IMP_atom._object_cast_to_WaterPDBSelector(*args)
_object_types.append("WritePDBOptimizerState")


def _object_cast_to_WritePDBOptimizerState(*args):
  """_object_cast_to_WritePDBOptimizerState(Object o) -> WritePDBOptimizerState"""
  return _IMP_atom._object_cast_to_WritePDBOptimizerState(*args)
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(*args):
  """_object_cast_to_CHARMMIdealResidueTopology(Object o) -> CHARMMIdealResidueTopology"""
  return _IMP_atom._object_cast_to_CHARMMIdealResidueTopology(*args)
CHARMMInternalCoordinates=list
_plural_types.append("CHARMMInternalCoordinates")
_value_types.append("CHARMMInternalCoordinate")

_object_types.append("CHARMMPatch")


def _object_cast_to_CHARMMPatch(*args):
  """_object_cast_to_CHARMMPatch(Object o) -> CHARMMPatch"""
  return _IMP_atom._object_cast_to_CHARMMPatch(*args)
_object_types.append("CHARMMResidueTopologyBase")


def _object_cast_to_CHARMMResidueTopologyBase(*args):
  """_object_cast_to_CHARMMResidueTopologyBase(Object o) -> CHARMMResidueTopologyBase"""
  return _IMP_atom._object_cast_to_CHARMMResidueTopologyBase(*args)
RMSDCalculators=list
_plural_types.append("RMSDCalculators")
_value_types.append("RMSDCalculator")

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(*args):
  """_object_cast_to_RemoveRigidMotionOptimizerState(Object o) -> RemoveRigidMotionOptimizerState"""
  return _IMP_atom._object_cast_to_RemoveRigidMotionOptimizerState(*args)
_object_types.append("BerendsenThermostatOptimizerState")


def _object_cast_to_BerendsenThermostatOptimizerState(*args):
  """_object_cast_to_BerendsenThermostatOptimizerState(Object o) -> BerendsenThermostatOptimizerState"""
  return _IMP_atom._object_cast_to_BerendsenThermostatOptimizerState(*args)
_object_types.append("LangevinThermostatOptimizerState")


def _object_cast_to_LangevinThermostatOptimizerState(*args):
  """_object_cast_to_LangevinThermostatOptimizerState(Object o) -> LangevinThermostatOptimizerState"""
  return _IMP_atom._object_cast_to_LangevinThermostatOptimizerState(*args)
_object_types.append("SelectionGeometry")


def _object_cast_to_SelectionGeometry(*args):
  """_object_cast_to_SelectionGeometry(Object o) -> SelectionGeometry"""
  return _IMP_atom._object_cast_to_SelectionGeometry(*args)
_object_types.append("HierarchyGeometry")


def _object_cast_to_HierarchyGeometry(*args):
  """_object_cast_to_HierarchyGeometry(Object o) -> HierarchyGeometry"""
  return _IMP_atom._object_cast_to_HierarchyGeometry(*args)
_object_types.append("HierarchiesGeometry")


def _object_cast_to_HierarchiesGeometry(*args):
  """_object_cast_to_HierarchiesGeometry(Object o) -> HierarchiesGeometry"""
  return _IMP_atom._object_cast_to_HierarchiesGeometry(*args)
_object_types.append("BondGeometry")


def _object_cast_to_BondGeometry(*args):
  """_object_cast_to_BondGeometry(Object o) -> BondGeometry"""
  return _IMP_atom._object_cast_to_BondGeometry(*args)
_object_types.append("BondsGeometry")


def _object_cast_to_BondsGeometry(*args):
  """_object_cast_to_BondsGeometry(Object o) -> BondsGeometry"""
  return _IMP_atom._object_cast_to_BondsGeometry(*args)
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.kernel.Decorator):
    """Proxy of C++ IMP::atom::Bond class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bond, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Bond, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Bond self) -> Bond
        __init__(IMP::atom::Bond self, Model m, IMP::kernel::ParticleIndex id) -> Bond
        __init__(IMP::atom::Bond self, Particle p) -> Bond
        """
        this = _IMP_atom.new_Bond(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Bond"""
        return _IMP_atom.Bond_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Bond self, _ostream out=std::cout)
        show(Bond self)
        """
        return _IMP_atom.Bond_show(self, *args)

    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Bond_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    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, *args):
        """get_bonded(Bond self, unsigned int i) -> Bonded"""
        return _IMP_atom.Bond_get_bonded(self, *args)

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

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

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

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

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

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

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

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

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

    if _newclass:get_length_key = staticmethod(get_length_key)
    __swig_getmethods__["get_length_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Bond self, FloatKey a0) -> double"""
        return _IMP_atom.Bond_get_derivative(self, *args)

    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, *args):
        """set_name(Bond self, std::string a0)"""
        return _IMP_atom.Bond_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Bond self) -> IMP::base::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 __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_decorate_particle(*args):
  """Bond_decorate_particle(Particle p) -> Bond"""
  return _IMP_atom.Bond_decorate_particle(*args)

def Bond_particle_is_instance(*args):
  """Bond_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Bond_particle_is_instance(*args)

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

class Bonded(IMP.kernel.Decorator):
    """Proxy of C++ IMP::atom::Bonded class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bonded, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Bonded, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Bonded self) -> Bonded
        __init__(IMP::atom::Bonded self, Model m, IMP::kernel::ParticleIndex id) -> Bonded
        __init__(IMP::atom::Bonded self, Particle p) -> Bonded
        """
        this = _IMP_atom.new_Bonded(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Bonded"""
        return _IMP_atom.Bonded_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Bonded self, _ostream out=std::cout)
        show(Bonded self)
        """
        return _IMP_atom.Bonded_show(self, *args)

    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Bonded_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def setup_particle(*args):
        """setup_particle(Particle p) -> Bonded"""
        return _IMP_atom.Bonded_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    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_bonds(self):
        """get_bonds(Bonded self) -> IMP::kernel::ParticleIndexes"""
        return _IMP_atom.Bonded_get_bonds(self)

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

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

    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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Bonded self, FloatKey a0) -> double"""
        return _IMP_atom.Bonded_get_derivative(self, *args)

    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, *args):
        """set_name(Bonded self, std::string a0)"""
        return _IMP_atom.Bonded_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Bonded self) -> IMP::base::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 __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_decorate_particle(*args):
  """Bonded_decorate_particle(Particle p) -> Bonded"""
  return _IMP_atom.Bonded_decorate_particle(*args)

def Bonded_particle_is_instance(*args):
  """Bonded_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Bonded_particle_is_instance(*args)

def Bonded_setup_particle(*args):
  """Bonded_setup_particle(Particle p) -> Bonded"""
  return _IMP_atom.Bonded_setup_particle(*args)


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

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(*args):
  """destroy_bond(Bond b)"""
  return _IMP_atom.destroy_bond(*args)

def get_bond(*args):
  """get_bond(Bonded a, Bonded b) -> Bond"""
  return _IMP_atom.get_bond(*args)
class BondGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::atom::BondGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondGeometry, name)
    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: self.this = this
    def get_version_info(self):
        """get_version_info(BondGeometry self) -> VersionInfo"""
        return _IMP_atom.BondGeometry_get_version_info(self)

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

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

BondGeometry_swigregister = _IMP_atom.BondGeometry_swigregister
BondGeometry_swigregister(BondGeometry)

class BondsGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::atom::BondsGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondsGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondsGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::BondsGeometry self, SingletonContainer sc) -> BondsGeometry"""
        this = _IMP_atom.new_BondsGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(BondsGeometry self) -> VersionInfo"""
        return _IMP_atom.BondsGeometry_get_version_info(self)

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

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

BondsGeometry_swigregister = _IMP_atom.BondsGeometry_swigregister
BondsGeometry_swigregister(BondsGeometry)

class Hierarchy(IMP.core.Hierarchy):
    """Proxy of C++ IMP::atom::Hierarchy class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.Hierarchy]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Hierarchy, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.Hierarchy]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Hierarchy, name)
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Hierarchy"""
        return _IMP_atom.Hierarchy_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Hierarchy self, Particle p) -> Hierarchy
        __init__(IMP::atom::Hierarchy self, Model m, IMP::kernel::ParticleIndex 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: self.this = this
    def setup_particle(*args):
        """
        setup_particle(Particle p, IMP::kernel::ParticlesTemp const & children) -> Hierarchy
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, IMP::kernel::ParticlesTemp const & children=IMP::kernel::ParticlesTemp()) -> Hierarchy
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Hierarchy
        setup_particle(Particle p) -> Hierarchy
        """
        return _IMP_atom.Hierarchy_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
        """
        return _IMP_atom.Hierarchy_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_is_valid(self, *args):
        """get_is_valid(Hierarchy self, bool print_info) -> bool"""
        return _IMP_atom.Hierarchy_get_is_valid(self, *args)

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

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

    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_traits():
        """get_traits() -> HierarchyTraits"""
        return _IMP_atom.Hierarchy_get_traits()

    if _newclass:get_traits = staticmethod(get_traits)
    __swig_getmethods__["get_traits"] = lambda x: get_traits
    def show(self, *args):
        """
        show(Hierarchy self, _ostream out=std::cout)
        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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Hierarchy self, FloatKey a0) -> double"""
        return _IMP_atom.Hierarchy_get_derivative(self, *args)

    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, *args):
        """set_name(Hierarchy self, std::string a0)"""
        return _IMP_atom.Hierarchy_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Hierarchy self) -> IMP::base::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 __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_decorate_particle(*args):
  """Hierarchy_decorate_particle(Particle p) -> Hierarchy"""
  return _IMP_atom.Hierarchy_decorate_particle(*args)

def Hierarchy_setup_particle(*args):
  """
    setup_particle(Particle p, IMP::kernel::ParticlesTemp const & children) -> Hierarchy
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, IMP::kernel::ParticlesTemp const & children=IMP::kernel::ParticlesTemp()) -> Hierarchy
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Hierarchy
    Hierarchy_setup_particle(Particle p) -> Hierarchy
    """
  return _IMP_atom.Hierarchy_setup_particle(*args)

def Hierarchy_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    Hierarchy_particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
    """
  return _IMP_atom.Hierarchy_particle_is_instance(*args)

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

ATOM_TYPE = _IMP_atom.ATOM_TYPE
RESIDUE_TYPE = _IMP_atom.RESIDUE_TYPE
CHAIN_TYPE = _IMP_atom.CHAIN_TYPE
MOLECULE_TYPE = _IMP_atom.MOLECULE_TYPE
DOMAIN_TYPE = _IMP_atom.DOMAIN_TYPE
FRAGMENT_TYPE = _IMP_atom.FRAGMENT_TYPE
XYZ_TYPE = _IMP_atom.XYZ_TYPE
XYZR_TYPE = _IMP_atom.XYZR_TYPE
MASS_TYPE = _IMP_atom.MASS_TYPE

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

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

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

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

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

def create_rigid_body(*args):
  """
    create_rigid_body(IMP::atom::Hierarchies const & h, std::string name=std::string("created rigid body")) -> 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(*args):
  """create_compatible_rigid_body(Hierarchy h, Hierarchy reference) -> RigidBody"""
  return _IMP_atom.create_compatible_rigid_body(*args)

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

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

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

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

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

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

def get_bounding_sphere(*args):
  """get_bounding_sphere(Hierarchy h) -> Sphere3D"""
  return _IMP_atom.get_bounding_sphere(*args)
class Angle(IMP.kernel.Decorator):
    """Proxy of C++ IMP::atom::Angle class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Angle, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Angle, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Angle self) -> Angle
        __init__(IMP::atom::Angle self, Model m, IMP::kernel::ParticleIndex id) -> Angle
        __init__(IMP::atom::Angle self, Particle p) -> Angle
        """
        this = _IMP_atom.new_Angle(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Angle"""
        return _IMP_atom.Angle_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Angle self, _ostream out=std::cout)
        show(Angle self)
        """
        return _IMP_atom.Angle_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p, XYZ a, XYZ b, XYZ c) -> Angle"""
        return _IMP_atom.Angle_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Angle_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    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, *args):
        """set_ideal(Angle self, IMP::Float t)"""
        return _IMP_atom.Angle_set_ideal(self, *args)

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

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

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

    if _newclass:get_particle_key = staticmethod(get_particle_key)
    __swig_getmethods__["get_particle_key"] = lambda x: get_particle_key
    def get_ideal_key():
        """get_ideal_key() -> FloatKey"""
        return _IMP_atom.Angle_get_ideal_key()

    if _newclass:get_ideal_key = staticmethod(get_ideal_key)
    __swig_getmethods__["get_ideal_key"] = lambda x: get_ideal_key
    def get_stiffness_key():
        """get_stiffness_key() -> FloatKey"""
        return _IMP_atom.Angle_get_stiffness_key()

    if _newclass:get_stiffness_key = staticmethod(get_stiffness_key)
    __swig_getmethods__["get_stiffness_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Angle self, FloatKey a0) -> double"""
        return _IMP_atom.Angle_get_derivative(self, *args)

    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, *args):
        """set_name(Angle self, std::string a0)"""
        return _IMP_atom.Angle_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Angle self) -> IMP::base::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 __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_decorate_particle(*args):
  """Angle_decorate_particle(Particle p) -> Angle"""
  return _IMP_atom.Angle_decorate_particle(*args)

def Angle_setup_particle(*args):
  """Angle_setup_particle(Particle p, XYZ a, XYZ b, XYZ c) -> Angle"""
  return _IMP_atom.Angle_setup_particle(*args)

def Angle_particle_is_instance(*args):
  """Angle_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Angle_particle_is_instance(*args)

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

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.kernel.Decorator):
    """Proxy of C++ IMP::atom::Dihedral class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dihedral, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Dihedral, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Dihedral self) -> Dihedral
        __init__(IMP::atom::Dihedral self, Model m, IMP::kernel::ParticleIndex id) -> Dihedral
        __init__(IMP::atom::Dihedral self, Particle p) -> Dihedral
        """
        this = _IMP_atom.new_Dihedral(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Dihedral"""
        return _IMP_atom.Dihedral_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Dihedral self, _ostream out=std::cout)
        show(Dihedral self)
        """
        return _IMP_atom.Dihedral_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p, XYZ a, XYZ b, XYZ c, XYZ d) -> Dihedral"""
        return _IMP_atom.Dihedral_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Dihedral_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    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, *args):
        """set_ideal(Dihedral self, IMP::Float t)"""
        return _IMP_atom.Dihedral_set_ideal(self, *args)

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

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

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

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

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

    if _newclass:get_particle_key = staticmethod(get_particle_key)
    __swig_getmethods__["get_particle_key"] = lambda x: get_particle_key
    def get_ideal_key():
        """get_ideal_key() -> FloatKey"""
        return _IMP_atom.Dihedral_get_ideal_key()

    if _newclass:get_ideal_key = staticmethod(get_ideal_key)
    __swig_getmethods__["get_ideal_key"] = lambda x: get_ideal_key
    def get_multiplicity_key():
        """get_multiplicity_key() -> IntKey"""
        return _IMP_atom.Dihedral_get_multiplicity_key()

    if _newclass:get_multiplicity_key = staticmethod(get_multiplicity_key)
    __swig_getmethods__["get_multiplicity_key"] = lambda x: get_multiplicity_key
    def get_stiffness_key():
        """get_stiffness_key() -> FloatKey"""
        return _IMP_atom.Dihedral_get_stiffness_key()

    if _newclass:get_stiffness_key = staticmethod(get_stiffness_key)
    __swig_getmethods__["get_stiffness_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Dihedral self, FloatKey a0) -> double"""
        return _IMP_atom.Dihedral_get_derivative(self, *args)

    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, *args):
        """set_name(Dihedral self, std::string a0)"""
        return _IMP_atom.Dihedral_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Dihedral self) -> IMP::base::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 __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_decorate_particle(*args):
  """Dihedral_decorate_particle(Particle p) -> Dihedral"""
  return _IMP_atom.Dihedral_decorate_particle(*args)

def Dihedral_setup_particle(*args):
  """Dihedral_setup_particle(Particle p, XYZ a, XYZ b, XYZ c, XYZ d) -> Dihedral"""
  return _IMP_atom.Dihedral_setup_particle(*args)

def Dihedral_particle_is_instance(*args):
  """Dihedral_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Dihedral_particle_is_instance(*args)

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

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.base.Object):
    """Proxy of C++ IMP::atom::SmoothingFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SmoothingFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SmoothingFunction, name)
    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)

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

SmoothingFunction_swigregister = _IMP_atom.SmoothingFunction_swigregister
SmoothingFunction_swigregister(SmoothingFunction)

class ForceSwitch(SmoothingFunction):
    """Proxy of C++ IMP::atom::ForceSwitch class"""
    __swig_setmethods__ = {}
    for _s in [SmoothingFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ForceSwitch, name, value)
    __swig_getmethods__ = {}
    for _s in [SmoothingFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ForceSwitch, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::ForceSwitch self, double min_distance, double max_distance) -> ForceSwitch"""
        this = _IMP_atom.new_ForceSwitch(*args)
        try: self.this.append(this)
        except: 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 do_show(self, *args):
        """do_show(ForceSwitch self, _ostream out)"""
        return _IMP_atom.ForceSwitch_do_show(self, *args)

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

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

ForceSwitch_swigregister = _IMP_atom.ForceSwitch_swigregister
ForceSwitch_swigregister(ForceSwitch)

class AngleSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::atom::AngleSingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AngleSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AngleSingletonScore, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::AngleSingletonScore self, UnaryFunction f) -> AngleSingletonScore"""
        this = _IMP_atom.new_AngleSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(AngleSingletonScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.AngleSingletonScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(AngleSingletonScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.AngleSingletonScore_get_input_containers(self, *args)

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

    def do_show(self, *args):
        """do_show(AngleSingletonScore self, _ostream out)"""
        return _IMP_atom.AngleSingletonScore_do_show(self, *args)

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

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

AngleSingletonScore_swigregister = _IMP_atom.AngleSingletonScore_swigregister
AngleSingletonScore_swigregister(AngleSingletonScore)

class BondEndpointsRefiner(IMP.kernel.Refiner):
    """Proxy of C++ IMP::atom::BondEndpointsRefiner class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondEndpointsRefiner, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Refiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondEndpointsRefiner, name)
    def __init__(self): 
        """__init__(IMP::atom::BondEndpointsRefiner self) -> BondEndpointsRefiner"""
        this = _IMP_atom.new_BondEndpointsRefiner()
        try: self.this.append(this)
        except: self.this = this
    def get_refined(self, *args):
        """
        get_refined(BondEndpointsRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp const
        get_refined(BondEndpointsRefiner self, Particle arg2, unsigned int arg3) -> Particle
        """
        return _IMP_atom.BondEndpointsRefiner_get_refined(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(BondEndpointsRefiner self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.BondEndpointsRefiner_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(BondEndpointsRefiner self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.BondEndpointsRefiner_get_input_containers(self, *args)

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

    def do_show(self, *args):
        """do_show(BondEndpointsRefiner self, _ostream out)"""
        return _IMP_atom.BondEndpointsRefiner_do_show(self, *args)

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

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

BondEndpointsRefiner_swigregister = _IMP_atom.BondEndpointsRefiner_swigregister
BondEndpointsRefiner_swigregister(BondEndpointsRefiner)

class BondPairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::atom::BondPairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondPairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondPairContainer, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::BondPairContainer self, SingletonContainer sc) -> BondPairContainer"""
        this = _IMP_atom.new_BondPairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_before_evaluate(self):
        """do_before_evaluate(BondPairContainer self)"""
        return _IMP_atom.BondPairContainer_do_before_evaluate(self)

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

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

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

    def do_show(self, *args):
        """do_show(BondPairContainer self, _ostream out)"""
        return _IMP_atom.BondPairContainer_do_show(self, *args)

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

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

BondPairContainer_swigregister = _IMP_atom.BondPairContainer_swigregister
BondPairContainer_swigregister(BondPairContainer)

class BondSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::atom::BondSingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondSingletonScore, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::BondSingletonScore self, UnaryFunction f) -> BondSingletonScore"""
        this = _IMP_atom.new_BondSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_unary_function(self):
        """get_unary_function(BondSingletonScore self) -> UnaryFunction"""
        return _IMP_atom.BondSingletonScore_get_unary_function(self)

    def get_input_particles(self, *args):
        """get_input_particles(BondSingletonScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.BondSingletonScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(BondSingletonScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.BondSingletonScore_get_input_containers(self, *args)

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

    def do_show(self, *args):
        """do_show(BondSingletonScore self, _ostream out)"""
        return _IMP_atom.BondSingletonScore_do_show(self, *args)

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

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

BondSingletonScore_swigregister = _IMP_atom.BondSingletonScore_swigregister
BondSingletonScore_swigregister(BondSingletonScore)

class DihedralSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::atom::DihedralSingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DihedralSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DihedralSingletonScore, name)
    def __init__(self): 
        """__init__(IMP::atom::DihedralSingletonScore self) -> DihedralSingletonScore"""
        this = _IMP_atom.new_DihedralSingletonScore()
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(DihedralSingletonScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.DihedralSingletonScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(DihedralSingletonScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.DihedralSingletonScore_get_input_containers(self, *args)

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

    def do_show(self, *args):
        """do_show(DihedralSingletonScore self, _ostream out)"""
        return _IMP_atom.DihedralSingletonScore_do_show(self, *args)

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

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

DihedralSingletonScore_swigregister = _IMP_atom.DihedralSingletonScore_swigregister
DihedralSingletonScore_swigregister(DihedralSingletonScore)

class ImproperSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::atom::ImproperSingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImproperSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ImproperSingletonScore, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::ImproperSingletonScore self, UnaryFunction f) -> ImproperSingletonScore"""
        this = _IMP_atom.new_ImproperSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(ImproperSingletonScore self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.ImproperSingletonScore_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(ImproperSingletonScore self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.ImproperSingletonScore_get_input_containers(self, *args)

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

    def do_show(self, *args):
        """do_show(ImproperSingletonScore self, _ostream out)"""
        return _IMP_atom.ImproperSingletonScore_do_show(self, *args)

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

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

ImproperSingletonScore_swigregister = _IMP_atom.ImproperSingletonScore_swigregister
ImproperSingletonScore_swigregister(ImproperSingletonScore)

class CoverBond(IMP.kernel.SingletonModifier):
    """Proxy of C++ IMP::atom::CoverBond class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoverBond, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonModifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoverBond, name)
    def __init__(self): 
        """__init__(IMP::atom::CoverBond self) -> CoverBond"""
        this = _IMP_atom.new_CoverBond()
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self, *args):
        """get_input_particles(CoverBond self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.CoverBond_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(CoverBond self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.CoverBond_get_input_containers(self, *args)

    def get_output_particles(self, *args):
        """get_output_particles(CoverBond self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.CoverBond_get_output_particles(self, *args)

    def get_output_containers(self, *args):
        """get_output_containers(CoverBond self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.CoverBond_get_output_containers(self, *args)

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

    def do_show(self, *args):
        """do_show(CoverBond self, _ostream out)"""
        return _IMP_atom.CoverBond_do_show(self, *args)

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

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

CoverBond_swigregister = _IMP_atom.CoverBond_swigregister
CoverBond_swigregister(CoverBond)

class Simulator(IMP.kernel.Optimizer):
    """Proxy of C++ IMP::atom::Simulator class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Simulator, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Optimizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Simulator, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Simulator self, Model m, std::string name="Simulator %1%") -> 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: self.this = this
        if self.__class__ != Simulator:
            import IMP.base
            IMP.base._director_objects.register(self)



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

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

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

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

    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, *args):
        """set_time_step(Simulator self, double ts)"""
        return _IMP_atom.Simulator_set_time_step(self, *args)

    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, *args):
        """set_current_time(Simulator self, double ct)"""
        return _IMP_atom.Simulator_set_current_time(self, *args)

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

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

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

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

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

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

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

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

    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, *args):
        """get_particle(Simulator self, unsigned int i) -> Particle"""
        return _IMP_atom.Simulator_get_particle(self, *args)

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

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

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

    def get_version_info(self):
        """get_version_info(Simulator self) -> VersionInfo"""
        return _IMP_atom.Simulator_get_version_info(self)

    def do_show(self, *args):
        """do_show(Simulator self, _ostream out)"""
        return _IMP_atom.Simulator_do_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete_Simulator
    __del__ = lambda self : None;
    def setup(self, *args):
        """setup(Simulator self, IMP::kernel::ParticleIndexes const & arg0)"""
        return _IMP_atom.Simulator_setup(self, *args)

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

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

    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)

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

    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("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Simulator(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_atom.disown_Simulator(self)
        return weakref_proxy(self)
Simulator_swigregister = _IMP_atom.Simulator_swigregister
Simulator_swigregister(Simulator)


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

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

def get_spring_constant_in_femto_newtons_per_angstrom(*args):
  """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(*args)
class BrownianDynamics(Simulator):
    """Proxy of C++ IMP::atom::BrownianDynamics class"""
    __swig_setmethods__ = {}
    for _s in [Simulator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BrownianDynamics, name, value)
    __swig_getmethods__ = {}
    for _s in [Simulator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BrownianDynamics, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::BrownianDynamics self, Model m, std::string name="BrownianDynamics%1%") -> BrownianDynamics
        __init__(IMP::atom::BrownianDynamics self, Model m) -> BrownianDynamics
        """
        this = _IMP_atom.new_BrownianDynamics(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_maximum_move(self, *args):
        """set_maximum_move(BrownianDynamics self, double ms)"""
        return _IMP_atom.BrownianDynamics_set_maximum_move(self, *args)

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

    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)

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

    __swig_destroy__ = _IMP_atom.delete_BrownianDynamics
    __del__ = lambda self : None;
BrownianDynamics_swigregister = _IMP_atom.BrownianDynamics_swigregister
BrownianDynamics_swigregister(BrownianDynamics)


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

def get_harmonic_sigma(*args):
  """get_harmonic_sigma(double D, double f) -> double"""
  return _IMP_atom.get_harmonic_sigma(*args)
class Diffusion(IMP.core.XYZ):
    """Proxy of C++ IMP::atom::Diffusion class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.XYZ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Diffusion, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.XYZ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Diffusion, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Diffusion self) -> Diffusion
        __init__(IMP::atom::Diffusion self, Model m, IMP::kernel::ParticleIndex id) -> Diffusion
        __init__(IMP::atom::Diffusion self, Particle p) -> Diffusion
        """
        this = _IMP_atom.new_Diffusion(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Diffusion"""
        return _IMP_atom.Diffusion_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Diffusion self, _ostream out=std::cout)
        show(Diffusion self)
        """
        return _IMP_atom.Diffusion_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p, Vector3D v, IMP::Float D) -> Diffusion
        setup_particle(Particle p, IMP::Float D) -> Diffusion
        setup_particle(Particle p) -> Diffusion
        """
        return _IMP_atom.Diffusion_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
        """
        return _IMP_atom.Diffusion_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def set_d(self, *args):
        """set_d(Diffusion self, double d)"""
        return _IMP_atom.Diffusion_set_d(self, *args)

    def get_d(self):
        """get_d(Diffusion self) -> double"""
        return _IMP_atom.Diffusion_get_d(self)

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

    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()

    if _newclass:get_diffusion_coefficient_key = staticmethod(get_diffusion_coefficient_key)
    __swig_getmethods__["get_diffusion_coefficient_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Diffusion self, FloatKey a0) -> double"""
        return _IMP_atom.Diffusion_get_derivative(self, *args)

    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, *args):
        """set_name(Diffusion self, std::string a0)"""
        return _IMP_atom.Diffusion_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Diffusion self) -> IMP::base::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 __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_decorate_particle(*args):
  """Diffusion_decorate_particle(Particle p) -> Diffusion"""
  return _IMP_atom.Diffusion_decorate_particle(*args)

def Diffusion_setup_particle(*args):
  """
    setup_particle(Particle p, Vector3D v, IMP::Float D) -> Diffusion
    setup_particle(Particle p, IMP::Float D) -> Diffusion
    Diffusion_setup_particle(Particle p) -> Diffusion
    """
  return _IMP_atom.Diffusion_setup_particle(*args)

def Diffusion_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    Diffusion_particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
    """
  return _IMP_atom.Diffusion_particle_is_instance(*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(*args):
  """get_diffusion_coefficient_from_cm2_per_second(double din) -> double"""
  return _IMP_atom.get_diffusion_coefficient_from_cm2_per_second(*args)
class RigidBodyDiffusion(Diffusion):
    """Proxy of C++ IMP::atom::RigidBodyDiffusion class"""
    __swig_setmethods__ = {}
    for _s in [Diffusion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodyDiffusion, name, value)
    __swig_getmethods__ = {}
    for _s in [Diffusion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodyDiffusion, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::RigidBodyDiffusion self) -> RigidBodyDiffusion
        __init__(IMP::atom::RigidBodyDiffusion self, Model m, IMP::kernel::ParticleIndex id) -> RigidBodyDiffusion
        __init__(IMP::atom::RigidBodyDiffusion self, Particle p) -> RigidBodyDiffusion
        """
        this = _IMP_atom.new_RigidBodyDiffusion(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> RigidBodyDiffusion"""
        return _IMP_atom.RigidBodyDiffusion_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(RigidBodyDiffusion self, _ostream out=std::cout)
        show(RigidBodyDiffusion self)
        """
        return _IMP_atom.RigidBodyDiffusion_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p) -> RigidBodyDiffusion"""
        return _IMP_atom.RigidBodyDiffusion_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: 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, *args):
        """set_rotational_diffusion_coefficient(RigidBodyDiffusion self, double d)"""
        return _IMP_atom.RigidBodyDiffusion_set_rotational_diffusion_coefficient(self, *args)

    def particle_is_instance(*args):
        """
        particle_is_instance(Particle p) -> bool
        particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
        """
        return _IMP_atom.RigidBodyDiffusion_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_rotational_diffusion_coefficient_key():
        """get_rotational_diffusion_coefficient_key() -> FloatKey"""
        return _IMP_atom.RigidBodyDiffusion_get_rotational_diffusion_coefficient_key()

    if _newclass:get_rotational_diffusion_coefficient_key = staticmethod(get_rotational_diffusion_coefficient_key)
    __swig_getmethods__["get_rotational_diffusion_coefficient_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(RigidBodyDiffusion self, FloatKey a0) -> double"""
        return _IMP_atom.RigidBodyDiffusion_get_derivative(self, *args)

    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, *args):
        """set_name(RigidBodyDiffusion self, std::string a0)"""
        return _IMP_atom.RigidBodyDiffusion_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(RigidBodyDiffusion self) -> IMP::base::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 __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_decorate_particle(*args):
  """RigidBodyDiffusion_decorate_particle(Particle p) -> RigidBodyDiffusion"""
  return _IMP_atom.RigidBodyDiffusion_decorate_particle(*args)

def RigidBodyDiffusion_setup_particle(*args):
  """RigidBodyDiffusion_setup_particle(Particle p) -> RigidBodyDiffusion"""
  return _IMP_atom.RigidBodyDiffusion_setup_particle(*args)

def RigidBodyDiffusion_particle_is_instance(*args):
  """
    particle_is_instance(Particle p) -> bool
    RigidBodyDiffusion_particle_is_instance(Model m, IMP::kernel::ParticleIndex p) -> bool
    """
  return _IMP_atom.RigidBodyDiffusion_particle_is_instance(*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 Chain(Hierarchy):
    """Proxy of C++ IMP::atom::Chain class"""
    __swig_setmethods__ = {}
    for _s in [Hierarchy]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chain, name, value)
    __swig_getmethods__ = {}
    for _s in [Hierarchy]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Chain, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Chain self) -> Chain
        __init__(IMP::atom::Chain self, Model m, IMP::kernel::ParticleIndex id) -> Chain
        __init__(IMP::atom::Chain self, Particle p) -> Chain
        """
        this = _IMP_atom.new_Chain(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Chain"""
        return _IMP_atom.Chain_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Chain self, _ostream out=std::cout)
        show(Chain self)
        """
        return _IMP_atom.Chain_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, char id) -> Chain
        setup_particle(Particle p, char id) -> Chain
        setup_particle(Particle p, Chain o) -> Chain
        """
        return _IMP_atom.Chain_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Chain_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_id(self):
        """get_id(Chain self) -> char"""
        return _IMP_atom.Chain_get_id(self)

    def set_id(self, *args):
        """set_id(Chain self, char c)"""
        return _IMP_atom.Chain_set_id(self, *args)

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

    if _newclass:get_id_key = staticmethod(get_id_key)
    __swig_getmethods__["get_id_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Chain self, FloatKey a0) -> double"""
        return _IMP_atom.Chain_get_derivative(self, *args)

    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, *args):
        """set_name(Chain self, std::string a0)"""
        return _IMP_atom.Chain_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Chain self) -> IMP::base::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 __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_decorate_particle(*args):
  """Chain_decorate_particle(Particle p) -> Chain"""
  return _IMP_atom.Chain_decorate_particle(*args)

def Chain_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, char id) -> Chain
    setup_particle(Particle p, char id) -> Chain
    Chain_setup_particle(Particle p, Chain o) -> Chain
    """
  return _IMP_atom.Chain_setup_particle(*args)

def Chain_particle_is_instance(*args):
  """Chain_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Chain_particle_is_instance(*args)

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


def get_chain(*args):
  """get_chain(Hierarchy h) -> Chain"""
  return _IMP_atom.get_chain(*args)
class Charged(IMP.core.XYZ):
    """Proxy of C++ IMP::atom::Charged class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.XYZ]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Charged, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.XYZ]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Charged, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Charged self) -> Charged
        __init__(IMP::atom::Charged self, Model m, IMP::kernel::ParticleIndex id) -> Charged
        __init__(IMP::atom::Charged self, Particle p) -> Charged
        """
        this = _IMP_atom.new_Charged(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Charged"""
        return _IMP_atom.Charged_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Charged self, _ostream out=std::cout)
        show(Charged self)
        """
        return _IMP_atom.Charged_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p, Vector3D v, IMP::Float charge) -> Charged
        setup_particle(Particle p, IMP::Float charge=0) -> Charged
        setup_particle(Particle p) -> Charged
        """
        return _IMP_atom.Charged_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def get_charge(self):
        """get_charge(Charged self) -> IMP::Float"""
        return _IMP_atom.Charged_get_charge(self)

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

    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Charged_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_charge_key():
        """get_charge_key() -> FloatKey"""
        return _IMP_atom.Charged_get_charge_key()

    if _newclass:get_charge_key = staticmethod(get_charge_key)
    __swig_getmethods__["get_charge_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Charged self, FloatKey a0) -> double"""
        return _IMP_atom.Charged_get_derivative(self, *args)

    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, *args):
        """set_name(Charged self, std::string a0)"""
        return _IMP_atom.Charged_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Charged self) -> IMP::base::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 __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_decorate_particle(*args):
  """Charged_decorate_particle(Particle p) -> Charged"""
  return _IMP_atom.Charged_decorate_particle(*args)

def Charged_setup_particle(*args):
  """
    setup_particle(Particle p, Vector3D v, IMP::Float charge) -> Charged
    setup_particle(Particle p, IMP::Float charge=0) -> Charged
    Charged_setup_particle(Particle p) -> Charged
    """
  return _IMP_atom.Charged_setup_particle(*args)

def Charged_particle_is_instance(*args):
  """Charged_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Charged_particle_is_instance(*args)

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

class CoulombPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::atom::CoulombPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoulombPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoulombPairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::CoulombPairScore self, SmoothingFunction f) -> CoulombPairScore"""
        this = _IMP_atom.new_CoulombPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_relative_dielectric(self, *args):
        """set_relative_dielectric(CoulombPairScore self, double relative_dielectric)"""
        return _IMP_atom.CoulombPairScore_set_relative_dielectric(self, *args)

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

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(CoulombPairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_atom.CoulombPairScore_do_create_current_decomposition(self, *args)

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

    def do_show(self, *args):
        """do_show(CoulombPairScore self, _ostream out)"""
        return _IMP_atom.CoulombPairScore_do_show(self, *args)

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

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

CoulombPairScore_swigregister = _IMP_atom.CoulombPairScore_swigregister
CoulombPairScore_swigregister(CoulombPairScore)

class Domain(Hierarchy):
    """Proxy of C++ IMP::atom::Domain class"""
    __swig_setmethods__ = {}
    for _s in [Hierarchy]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Domain, name, value)
    __swig_getmethods__ = {}
    for _s in [Hierarchy]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Domain, name)
    def setup_particle(*args):
        """
        setup_particle(Particle p, IMP::Int b, IMP::Int e) -> Domain
        setup_particle(Particle p, IMP::IntRange r) -> Domain
        setup_particle(Particle p, Domain o) -> Domain
        """
        return _IMP_atom.Domain_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    __swig_destroy__ = _IMP_atom.delete_Domain
    __del__ = lambda self : None;
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Domain_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def set_index_range(self, *args):
        """set_index_range(Domain self, IMP::IntRange ir)"""
        return _IMP_atom.Domain_set_index_range(self, *args)

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

    def get_begin_index(self):
        """get_begin_index(Domain self) -> IMP::Int"""
        return _IMP_atom.Domain_get_begin_index(self)

    def get_end_index(self):
        """get_end_index(Domain self) -> IMP::Int"""
        return _IMP_atom.Domain_get_end_index(self)

    def __init__(self, *args): 
        """
        __init__(IMP::atom::Domain self) -> Domain
        __init__(IMP::atom::Domain self, Model m, IMP::kernel::ParticleIndex id) -> Domain
        __init__(IMP::atom::Domain self, Particle p) -> Domain
        """
        this = _IMP_atom.new_Domain(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Domain"""
        return _IMP_atom.Domain_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Domain self, _ostream out=std::cout)
        show(Domain self)
        """
        return _IMP_atom.Domain_show(self, *args)

    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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Domain self, FloatKey a0) -> double"""
        return _IMP_atom.Domain_get_derivative(self, *args)

    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, *args):
        """set_name(Domain self, std::string a0)"""
        return _IMP_atom.Domain_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(Domain self) -> IMP::base::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 __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)

Domain_swigregister = _IMP_atom.Domain_swigregister
Domain_swigregister(Domain)

def Domain_setup_particle(*args):
  """
    setup_particle(Particle p, IMP::Int b, IMP::Int e) -> Domain
    setup_particle(Particle p, IMP::IntRange r) -> Domain
    Domain_setup_particle(Particle p, Domain o) -> Domain
    """
  return _IMP_atom.Domain_setup_particle(*args)

def Domain_particle_is_instance(*args):
  """Domain_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Domain_particle_is_instance(*args)

def Domain_decorate_particle(*args):
  """Domain_decorate_particle(Particle p) -> Domain"""
  return _IMP_atom.Domain_decorate_particle(*args)

class LennardJones(IMP.core.XYZR):
    """Proxy of C++ IMP::atom::LennardJones class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.XYZR]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LennardJones, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.XYZR]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LennardJones, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::LennardJones self) -> LennardJones
        __init__(IMP::atom::LennardJones self, Model m, IMP::kernel::ParticleIndex id) -> LennardJones
        __init__(IMP::atom::LennardJones self, Particle p) -> LennardJones
        """
        this = _IMP_atom.new_LennardJones(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> LennardJones"""
        return _IMP_atom.LennardJones_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(LennardJones self, _ostream out=std::cout)
        show(LennardJones self)
        """
        return _IMP_atom.LennardJones_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p, IMP::Float well_depth=0) -> LennardJones
        setup_particle(Particle p) -> LennardJones
        """
        return _IMP_atom.LennardJones_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: 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, *args):
        """set_well_depth(LennardJones self, IMP::Float well_depth)"""
        return _IMP_atom.LennardJones_set_well_depth(self, *args)

    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.LennardJones_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_well_depth_key():
        """get_well_depth_key() -> FloatKey"""
        return _IMP_atom.LennardJones_get_well_depth_key()

    if _newclass:get_well_depth_key = staticmethod(get_well_depth_key)
    __swig_getmethods__["get_well_depth_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(LennardJones self, FloatKey a0) -> double"""
        return _IMP_atom.LennardJones_get_derivative(self, *args)

    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, *args):
        """set_name(LennardJones self, std::string a0)"""
        return _IMP_atom.LennardJones_set_name(self, *args)

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

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

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

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

    def get_check_level(self):
        """get_check_level(LennardJones self) -> IMP::base::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 __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_decorate_particle(*args):
  """LennardJones_decorate_particle(Particle p) -> LennardJones"""
  return _IMP_atom.LennardJones_decorate_particle(*args)

def LennardJones_setup_particle(*args):
  """
    setup_particle(Particle p, IMP::Float well_depth=0) -> LennardJones
    LennardJones_setup_particle(Particle p) -> LennardJones
    """
  return _IMP_atom.LennardJones_setup_particle(*args)

def LennardJones_particle_is_instance(*args):
  """LennardJones_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.LennardJones_particle_is_instance(*args)

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

class LennardJonesPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::atom::LennardJonesPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LennardJonesPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LennardJonesPairScore, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::LennardJonesPairScore self, SmoothingFunction f) -> LennardJonesPairScore"""
        this = _IMP_atom.new_LennardJonesPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_repulsive_weight(self, *args):
        """set_repulsive_weight(LennardJonesPairScore self, double repulsive_weight)"""
        return _IMP_atom.LennardJonesPairScore_set_repulsive_weight(self, *args)

    def get_repulsive_weight(self):
        """get_repulsive_weight(LennardJonesPairScore self) -> double"""
        return _IMP_atom.LennardJonesPairScore_get_repulsive_weight(self)

    def set_attractive_weight(self, *args):
        """set_attractive_weight(LennardJonesPairScore self, double attractive_weight)"""
        return _IMP_atom.LennardJonesPairScore_set_attractive_weight(self, *args)

    def get_attractive_weight(self):
        """get_attractive_weight(LennardJonesPairScore self) -> double"""
        return _IMP_atom.LennardJonesPairScore_get_attractive_weight(self)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(LennardJonesPairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_atom.LennardJonesPairScore_do_create_current_decomposition(self, *args)

    def get_version_info(self):
        """get_version_info(LennardJonesPairScore self) -> VersionInfo"""
        return _IMP_atom.LennardJonesPairScore_get_version_info(self)

    def do_show(self, *args):
        """do_show(LennardJonesPairScore self, _ostream out)"""
        return _IMP_atom.LennardJonesPairScore_do_show(self, *args)

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

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

LennardJonesPairScore_swigregister = _IMP_atom.LennardJonesPairScore_swigregister
LennardJonesPairScore_swigregister(LennardJonesPairScore)

class MolecularDynamics(Simulator):
    """Proxy of C++ IMP::atom::MolecularDynamics class"""
    __swig_setmethods__ = {}
    for _s in [Simulator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MolecularDynamics, name, value)
    __swig_getmethods__ = {}
    for _s in [Simulator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MolecularDynamics, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::MolecularDynamics self, Model m=nullptr) -> MolecularDynamics
        __init__(IMP::atom::MolecularDynamics self) -> MolecularDynamics
        """
        this = _IMP_atom.new_MolecularDynamics(*args)
        try: self.this.append(this)
        except: 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, *args):
        """get_kinetic_temperature(MolecularDynamics self, IMP::Float ekinetic) -> IMP::Float"""
        return _IMP_atom.MolecularDynamics_get_kinetic_temperature(self, *args)

    def set_velocity_cap(self, *args):
        """set_velocity_cap(MolecularDynamics self, IMP::Float velocity_cap)"""
        return _IMP_atom.MolecularDynamics_set_velocity_cap(self, *args)

    def assign_velocities(self, *args):
        """assign_velocities(MolecularDynamics self, IMP::Float temperature)"""
        return _IMP_atom.MolecularDynamics_assign_velocities(self, *args)

    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)

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

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

class VelocityScalingOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::atom::VelocityScalingOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VelocityScalingOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VelocityScalingOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::VelocityScalingOptimizerState self, IMP::kernel::Particles const & pis, IMP::Float temperature, unsigned int skip_steps) -> VelocityScalingOptimizerState"""
        this = _IMP_atom.new_VelocityScalingOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_skip_steps(self, *args):
        """set_skip_steps(VelocityScalingOptimizerState self, unsigned int skip_steps)"""
        return _IMP_atom.VelocityScalingOptimizerState_set_skip_steps(self, *args)

    def set_particles(self, *args):
        """set_particles(VelocityScalingOptimizerState self, IMP::kernel::Particles const & pis)"""
        return _IMP_atom.VelocityScalingOptimizerState_set_particles(self, *args)

    def set_temperature(self, *args):
        """set_temperature(VelocityScalingOptimizerState self, IMP::Float temperature)"""
        return _IMP_atom.VelocityScalingOptimizerState_set_temperature(self, *args)

    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 do_show(self, *args):
        """do_show(VelocityScalingOptimizerState self, _ostream out)"""
        return _IMP_atom.VelocityScalingOptimizerState_do_show(self, *args)

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

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

VelocityScalingOptimizerState_swigregister = _IMP_atom.VelocityScalingOptimizerState_swigregister
VelocityScalingOptimizerState_swigregister(VelocityScalingOptimizerState)

class Fragment(Hierarchy):
    """Proxy of C++ IMP::atom::Fragment class"""
    __swig_setmethods__ = {}
    for _s in [Hierarchy]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Fragment, name, value)
    __swig_getmethods__ = {}
    for _s in [Hierarchy]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Fragment, name)
    def setup_particle(*args):
        """
        setup_particle(Particle p, IMP::Ints const & ris=IMP::Ints()) -> Fragment
        setup_particle(Particle p) -> Fragment
        setup_particle(Particle p, Fragment o) -> Fragment
        """
        return _IMP_atom.Fragment_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    __swig_destroy__ = _IMP_atom.delete_Fragment
    __del__ = lambda self : None;
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Fragment_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def set_residue_indexes(self, *args):
        """set_residue_indexes(Fragment self, IMP::Ints o)"""
        return _IMP_atom.Fragment_set_residue_indexes(self, *args)

    def get_residue_indexes(self):
        """get_residue_indexes(Fragment self) -> IMP::Ints"""
        return _IMP_atom.Fragment_get_residue_indexes(self)

    def get_residue_index_ranges(self):
        """get_residue_index_ranges(Fragment self) -> IMP::IntPairs"""
        return _IMP_atom.Fragment_get_residue_index_ranges(self)

    def get_contains_residue(self, *args):
        """get_contains_residue(Fragment self, int rindex) -> bool"""
        return _IMP_atom.Fragment_get_contains_residue(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::atom::Fragment self) -> Fragment
        __init__(IMP::atom::Fragment self, Model m, IMP::kernel::ParticleIndex id) -> Fragment
        __init__(IMP::atom::Fragment self, Particle p) -> Fragment
        """
        this = _IMP_atom.new_Fragment(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Fragment"""
        return _IMP_atom.Fragment_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Fragment self, _ostream out=std::cout)
        show(Fragment self)
        """
        return _IMP_atom.Fragment_show(self, *args)

    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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Fragment self, FloatKey a0) -> double"""
        return _IMP_atom.Fragment_get_derivative(self, *args)

    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, *args):
        """set_name(Fragment self, std::string a0)"""
        return _IMP_atom.Fragment_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Fragment self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.Fragment_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Fragment self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Fragment_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Fragment self, FloatKey a0, bool a1)"""
        return _IMP_atom.Fragment_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Fragment self, FloatKey a0) -> bool"""
        return _IMP_atom.Fragment_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Fragment self) -> IMP::base::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 __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)

Fragment_swigregister = _IMP_atom.Fragment_swigregister
Fragment_swigregister(Fragment)

def Fragment_setup_particle(*args):
  """
    setup_particle(Particle p, IMP::Ints const & ris=IMP::Ints()) -> Fragment
    setup_particle(Particle p) -> Fragment
    Fragment_setup_particle(Particle p, Fragment o) -> Fragment
    """
  return _IMP_atom.Fragment_setup_particle(*args)

def Fragment_particle_is_instance(*args):
  """Fragment_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Fragment_particle_is_instance(*args)

def Fragment_decorate_particle(*args):
  """Fragment_decorate_particle(Particle p) -> Fragment"""
  return _IMP_atom.Fragment_decorate_particle(*args)

class StereochemistryPairFilter(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::atom::StereochemistryPairFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StereochemistryPairFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StereochemistryPairFilter, name)
    def __init__(self): 
        """__init__(IMP::atom::StereochemistryPairFilter self) -> StereochemistryPairFilter"""
        this = _IMP_atom.new_StereochemistryPairFilter()
        try: self.this.append(this)
        except: self.this = this
    def set_bonds(self, *args):
        """set_bonds(StereochemistryPairFilter self, IMP::kernel::Particles const & bonds)"""
        return _IMP_atom.StereochemistryPairFilter_set_bonds(self, *args)

    def set_angles(self, *args):
        """set_angles(StereochemistryPairFilter self, IMP::kernel::Particles const & angles)"""
        return _IMP_atom.StereochemistryPairFilter_set_angles(self, *args)

    def set_dihedrals(self, *args):
        """set_dihedrals(StereochemistryPairFilter self, IMP::kernel::Particles const & dihedrals)"""
        return _IMP_atom.StereochemistryPairFilter_set_dihedrals(self, *args)

    def get_value(self, *args):
        """
        get_value(StereochemistryPairFilter self, IMP::kernel::ParticlePair const & a) -> int
        get_value(StereochemistryPairFilter self, IMP::kernel::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::kernel::ParticleIndexPair const & vt) -> int
        get_value_index(StereochemistryPairFilter self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_atom.StereochemistryPairFilter_get_value_index(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(StereochemistryPairFilter self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.StereochemistryPairFilter_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(StereochemistryPairFilter self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.StereochemistryPairFilter_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(StereochemistryPairFilter self) -> VersionInfo"""
        return _IMP_atom.StereochemistryPairFilter_get_version_info(self)

    def do_show(self, *args):
        """do_show(StereochemistryPairFilter self, _ostream out)"""
        return _IMP_atom.StereochemistryPairFilter_do_show(self, *args)

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

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

StereochemistryPairFilter_swigregister = _IMP_atom.StereochemistryPairFilter_swigregister
StereochemistryPairFilter_swigregister(StereochemistryPairFilter)

class Mass(IMP.kernel.Decorator):
    """Proxy of C++ IMP::atom::Mass class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mass, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Mass, name)
    def setup_particle(*args):
        """setup_particle(Particle p, double mass) -> Mass"""
        return _IMP_atom.Mass_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Mass_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_mass(self):
        """get_mass(Mass self) -> IMP::Float"""
        return _IMP_atom.Mass_get_mass(self)

    def set_mass(self, *args):
        """set_mass(Mass self, IMP::Float d)"""
        return _IMP_atom.Mass_set_mass(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::atom::Mass self) -> Mass
        __init__(IMP::atom::Mass self, Model m, IMP::kernel::ParticleIndex id) -> Mass
        __init__(IMP::atom::Mass self, Particle p) -> Mass
        """
        this = _IMP_atom.new_Mass(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Mass"""
        return _IMP_atom.Mass_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Mass self, _ostream out=std::cout)
        show(Mass self)
        """
        return _IMP_atom.Mass_show(self, *args)

    def get_mass_key():
        """get_mass_key() -> FloatKey"""
        return _IMP_atom.Mass_get_mass_key()

    if _newclass:get_mass_key = staticmethod(get_mass_key)
    __swig_getmethods__["get_mass_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Mass self, FloatKey a0) -> double"""
        return _IMP_atom.Mass_get_derivative(self, *args)

    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, *args):
        """set_name(Mass self, std::string a0)"""
        return _IMP_atom.Mass_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Mass self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.Mass_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Mass self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Mass_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Mass self, FloatKey a0, bool a1)"""
        return _IMP_atom.Mass_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Mass self, FloatKey a0) -> bool"""
        return _IMP_atom.Mass_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Mass self) -> IMP::base::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 __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_setup_particle(*args):
  """Mass_setup_particle(Particle p, double mass) -> Mass"""
  return _IMP_atom.Mass_setup_particle(*args)

def Mass_particle_is_instance(*args):
  """Mass_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Mass_particle_is_instance(*args)

def Mass_decorate_particle(*args):
  """Mass_decorate_particle(Particle p) -> Mass"""
  return _IMP_atom.Mass_decorate_particle(*args)

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

class BondedPairFilter(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::atom::BondedPairFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondedPairFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondedPairFilter, name)
    def __init__(self): 
        """__init__(IMP::atom::BondedPairFilter self) -> BondedPairFilter"""
        this = _IMP_atom.new_BondedPairFilter()
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(BondedPairFilter self, IMP::kernel::ParticlePair const & a) -> int
        get_value(BondedPairFilter self, IMP::kernel::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::kernel::ParticleIndexPair const & vt) -> int
        get_value_index(BondedPairFilter self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_atom.BondedPairFilter_get_value_index(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(BondedPairFilter self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.BondedPairFilter_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(BondedPairFilter self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.BondedPairFilter_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(BondedPairFilter self) -> VersionInfo"""
        return _IMP_atom.BondedPairFilter_get_version_info(self)

    def do_show(self, *args):
        """do_show(BondedPairFilter self, _ostream out)"""
        return _IMP_atom.BondedPairFilter_do_show(self, *args)

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

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

BondedPairFilter_swigregister = _IMP_atom.BondedPairFilter_swigregister
BondedPairFilter_swigregister(BondedPairFilter)

class Mol2Selector(IMP.base.Object):
    """Proxy of C++ IMP::atom::Mol2Selector class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mol2Selector, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Mol2Selector, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def get_is_selected(self, *args):
        """get_is_selected(Mol2Selector self, std::string const & atom_line) -> bool"""
        return _IMP_atom.Mol2Selector_get_is_selected(self, *args)

    __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)

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

Mol2Selector_swigregister = _IMP_atom.Mol2Selector_swigregister
Mol2Selector_swigregister(Mol2Selector)

class AllMol2Selector(Mol2Selector):
    """Proxy of C++ IMP::atom::AllMol2Selector class"""
    __swig_setmethods__ = {}
    for _s in [Mol2Selector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllMol2Selector, name, value)
    __swig_getmethods__ = {}
    for _s in [Mol2Selector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllMol2Selector, name)
    def get_version_info(self):
        """get_version_info(AllMol2Selector self) -> VersionInfo"""
        return _IMP_atom.AllMol2Selector_get_version_info(self)

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

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

    def __init__(self): 
        """__init__(IMP::atom::AllMol2Selector self) -> AllMol2Selector"""
        this = _IMP_atom.new_AllMol2Selector()
        try: self.this.append(this)
        except: self.this = this
AllMol2Selector_swigregister = _IMP_atom.AllMol2Selector_swigregister
AllMol2Selector_swigregister(AllMol2Selector)

class NonHydrogenMol2Selector(Mol2Selector):
    """Proxy of C++ IMP::atom::NonHydrogenMol2Selector class"""
    __swig_setmethods__ = {}
    for _s in [Mol2Selector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NonHydrogenMol2Selector, name, value)
    __swig_getmethods__ = {}
    for _s in [Mol2Selector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NonHydrogenMol2Selector, name)
    def get_version_info(self):
        """get_version_info(NonHydrogenMol2Selector self) -> VersionInfo"""
        return _IMP_atom.NonHydrogenMol2Selector_get_version_info(self)

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

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

    def __init__(self): 
        """__init__(IMP::atom::NonHydrogenMol2Selector self) -> NonHydrogenMol2Selector"""
        this = _IMP_atom.new_NonHydrogenMol2Selector()
        try: self.this.append(this)
        except: self.this = this
NonHydrogenMol2Selector_swigregister = _IMP_atom.NonHydrogenMol2Selector_swigregister
NonHydrogenMol2Selector_swigregister(NonHydrogenMol2Selector)


def read_mol2(*args):
  """
    read_mol2(TextInput mol2_file, Model model, Mol2Selector mol2sel=nullptr) -> Hierarchy
    read_mol2(TextInput mol2_file, Model model) -> Hierarchy
    """
  return _IMP_atom.read_mol2(*args)

def write_mol2(*args):
  """write_mol2(Hierarchy rhd, TextOutput file_name)"""
  return _IMP_atom.write_mol2(*args)
class SecondaryStructureResidue(IMP.kernel.Decorator):
    """Proxy of C++ IMP::atom::SecondaryStructureResidue class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SecondaryStructureResidue, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SecondaryStructureResidue, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::SecondaryStructureResidue self) -> SecondaryStructureResidue
        __init__(IMP::atom::SecondaryStructureResidue self, Model m, IMP::kernel::ParticleIndex id) -> SecondaryStructureResidue
        __init__(IMP::atom::SecondaryStructureResidue self, Particle p) -> SecondaryStructureResidue
        """
        this = _IMP_atom.new_SecondaryStructureResidue(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> SecondaryStructureResidue"""
        return _IMP_atom.SecondaryStructureResidue_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(SecondaryStructureResidue self, _ostream out=std::cout)
        show(SecondaryStructureResidue self)
        """
        return _IMP_atom.SecondaryStructureResidue_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle res_p, 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)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.SecondaryStructureResidue_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    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, *args):
        """set_prob_helix(SecondaryStructureResidue self, IMP::Float t)"""
        return _IMP_atom.SecondaryStructureResidue_set_prob_helix(self, *args)

    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, *args):
        """set_prob_strand(SecondaryStructureResidue self, IMP::Float t)"""
        return _IMP_atom.SecondaryStructureResidue_set_prob_strand(self, *args)

    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, *args):
        """set_prob_coil(SecondaryStructureResidue self, IMP::Float t)"""
        return _IMP_atom.SecondaryStructureResidue_set_prob_coil(self, *args)

    def get_prob_helix_key():
        """get_prob_helix_key() -> FloatKey"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_helix_key()

    if _newclass:get_prob_helix_key = staticmethod(get_prob_helix_key)
    __swig_getmethods__["get_prob_helix_key"] = lambda x: get_prob_helix_key
    def get_prob_strand_key():
        """get_prob_strand_key() -> FloatKey"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_strand_key()

    if _newclass:get_prob_strand_key = staticmethod(get_prob_strand_key)
    __swig_getmethods__["get_prob_strand_key"] = lambda x: get_prob_strand_key
    def get_prob_coil_key():
        """get_prob_coil_key() -> FloatKey"""
        return _IMP_atom.SecondaryStructureResidue_get_prob_coil_key()

    if _newclass:get_prob_coil_key = staticmethod(get_prob_coil_key)
    __swig_getmethods__["get_prob_coil_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(SecondaryStructureResidue self, FloatKey a0) -> double"""
        return _IMP_atom.SecondaryStructureResidue_get_derivative(self, *args)

    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, *args):
        """set_name(SecondaryStructureResidue self, std::string a0)"""
        return _IMP_atom.SecondaryStructureResidue_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(SecondaryStructureResidue self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.SecondaryStructureResidue_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(SecondaryStructureResidue self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.SecondaryStructureResidue_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(SecondaryStructureResidue self, FloatKey a0, bool a1)"""
        return _IMP_atom.SecondaryStructureResidue_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(SecondaryStructureResidue self, FloatKey a0) -> bool"""
        return _IMP_atom.SecondaryStructureResidue_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(SecondaryStructureResidue self) -> IMP::base::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 __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_decorate_particle(*args):
  """SecondaryStructureResidue_decorate_particle(Particle p) -> SecondaryStructureResidue"""
  return _IMP_atom.SecondaryStructureResidue_decorate_particle(*args)

def SecondaryStructureResidue_setup_particle(*args):
  """
    setup_particle(Particle res_p, 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_particle_is_instance(*args):
  """SecondaryStructureResidue_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.SecondaryStructureResidue_particle_is_instance(*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(*args):
  """
    setup_coarse_secondary_structure_residue(IMP::kernel::Particles const & ssr_ps, Model mdl, bool winner_takes_all_per_res=False) -> SecondaryStructureResidue
    setup_coarse_secondary_structure_residue(IMP::kernel::Particles const & ssr_ps, Model mdl) -> SecondaryStructureResidue
    """
  return _IMP_atom.setup_coarse_secondary_structure_residue(*args)

def setup_coarse_secondary_structure_residues(*args):
  """
    setup_coarse_secondary_structure_residues(IMP::kernel::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::kernel::Particles const & ssr_ps, Model mdl, int coarse_factor, int start_res_num) -> IMP::atom::SecondaryStructureResidues
    """
  return _IMP_atom.setup_coarse_secondary_structure_residues(*args)

def get_secondary_structure_match_score(*args):
  """get_secondary_structure_match_score(SecondaryStructureResidue ssr1, SecondaryStructureResidue ssr2) -> IMP::Float"""
  return _IMP_atom.get_secondary_structure_match_score(*args)

def read_psipred(*args):
  """
    read_psipred(TextInput inf, Model mdl) -> IMP::atom::SecondaryStructureResidues
    read_psipred(TextInput inf, IMP::kernel::Particles ps) -> IMP::atom::SecondaryStructureResidues
    """
  return _IMP_atom.read_psipred(*args)
class _ADopeBase(IMP.kernel.PairScore):
    """Proxy of C++ IMP::score_functor::DistancePairScore<(IMP::score_functor::Dope)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ADopeBase, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _ADopeBase, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::score_functor::DistancePairScore<(IMP::score_functor::Dope)> self, Dope t0, std::string name="FunctorDistancePairScore %1%") -> _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: self.this = this
    def get_version_info(self):
        """get_version_info(_ADopeBase self) -> VersionInfo"""
        return _IMP_atom._ADopeBase_get_version_info(self)

    def do_show(self, *args):
        """do_show(_ADopeBase self, _ostream out)"""
        return _IMP_atom._ADopeBase_do_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete__ADopeBase
    __del__ = lambda self : None;
_ADopeBase_swigregister = _IMP_atom._ADopeBase_swigregister
_ADopeBase_swigregister(_ADopeBase)

class _BDopeBase(IMP.kernel.PairScore):
    """Proxy of C++ IMP::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::DopeType,false,true,false)>)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _BDopeBase, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _BDopeBase, name)
    __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="FunctorDistancePairScore %1%") -> _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: self.this = this
    def get_version_info(self):
        """get_version_info(_BDopeBase self) -> VersionInfo"""
        return _IMP_atom._BDopeBase_get_version_info(self)

    def do_show(self, *args):
        """do_show(_BDopeBase self, _ostream out)"""
        return _IMP_atom._BDopeBase_do_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete__BDopeBase
    __del__ = lambda self : None;
_BDopeBase_swigregister = _IMP_atom._BDopeBase_swigregister
_BDopeBase_swigregister(_BDopeBase)

class _SPSFTB(IMP.kernel.PairScore):
    """Proxy of C++ IMP::score_functor::DistancePairScore<(IMP::score_functor::Statistical<(IMP::atom::ProteinLigandType,true,false)>)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _SPSFTB, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _SPSFTB, name)
    __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="FunctorDistancePairScore %1%") -> _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: self.this = this
    def get_version_info(self):
        """get_version_info(_SPSFTB self) -> VersionInfo"""
        return _IMP_atom._SPSFTB_get_version_info(self)

    def do_show(self, *args):
        """do_show(_SPSFTB self, _ostream out)"""
        return _IMP_atom._SPSFTB_do_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete__SPSFTB
    __del__ = lambda self : None;
_SPSFTB_swigregister = _IMP_atom._SPSFTB_swigregister
_SPSFTB_swigregister(_SPSFTB)

class _SPSTF(_SPSFTB):
    """Proxy of C++ IMP::core::StatisticalPairScore<(IMP::atom::ProteinLigandType,true,false)> class"""
    __swig_setmethods__ = {}
    for _s in [_SPSFTB]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _SPSTF, name, value)
    __swig_getmethods__ = {}
    for _s in [_SPSFTB]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _SPSTF, name)
    __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: 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"""
    __swig_setmethods__ = {}
    for _s in [_BDopeBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _SPSFT, name, value)
    __swig_getmethods__ = {}
    for _s in [_BDopeBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _SPSFT, name)
    __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: 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"""
    __swig_setmethods__ = {}
    for _s in [_SPSTF]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProteinLigandAtomPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [_SPSTF]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProteinLigandAtomPairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::ProteinLigandAtomPairScore self, double threshold=std::numeric_limits< double >::max()) -> 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: 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)

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

    __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"""
    __swig_setmethods__ = {}
    for _s in [IMP.container.PairsRestraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProteinLigandRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.container.PairsRestraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProteinLigandRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::ProteinLigandRestraint self, Hierarchy protein, Hierarchy ligand, double threshold=std::numeric_limits< double >::max()) -> 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: 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)

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

    __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(*args):
  """add_protein_ligand_score_data(Hierarchy h)"""
  return _IMP_atom.add_protein_ligand_score_data(*args)
class AtomType(IMP.base._Value):
    """Proxy of C++ IMP::Key<(8974343,false)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomType, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AtomType, name)
    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: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_atom.AtomType_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_atom.AtomType_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(AtomType self) -> std::string const"""
        return _IMP_atom.AtomType_get_string(self)

    def __eq__(self, *args):
        """__eq__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___ge__(self, *args)

    def __le__(self, *args):
        """__le__(AtomType self, AtomType o) -> bool"""
        return _IMP_atom.AtomType___le__(self, *args)

    def __hash__(self):
        """__hash__(AtomType self) -> std::size_t"""
        return _IMP_atom.AtomType___hash__(self)

    def show(self, *args):
        """
        show(AtomType self, _ostream out=std::cout)
        show(AtomType self)
        """
        return _IMP_atom.AtomType_show(self, *args)

    def add_alias(*args):
        """add_alias(AtomType old_key, std::string new_name) -> AtomType"""
        return _IMP_atom.AtomType_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(AtomType self) -> unsigned int"""
        return _IMP_atom.AtomType_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_atom.AtomType_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_atom.AtomType_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_atom.AtomType_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: 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(*args):
  """AtomType_add_key(std::string sc) -> unsigned int"""
  return _IMP_atom.AtomType_add_key(*args)

def AtomType_get_key_exists(*args):
  """AtomType_get_key_exists(std::string sc) -> bool"""
  return _IMP_atom.AtomType_get_key_exists(*args)

def AtomType_add_alias(*args):
  """AtomType_add_alias(AtomType old_key, std::string new_name) -> AtomType"""
  return _IMP_atom.AtomType_add_alias(*args)

def AtomType_show_all(*args):
  """AtomType_show_all(_ostream out)"""
  return _IMP_atom.AtomType_show_all(*args)

def AtomType_get_all_strings():
  """AtomType_get_all_strings() -> IMP::base::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.base._Value):
    """Proxy of C++ IMP::Key<(90784334,true)> class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResidueType, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ResidueType, name)
    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: self.this = this
    def add_key(*args):
        """add_key(std::string sc) -> unsigned int"""
        return _IMP_atom.ResidueType_add_key(*args)

    if _newclass:add_key = staticmethod(add_key)
    __swig_getmethods__["add_key"] = lambda x: add_key
    def get_key_exists(*args):
        """get_key_exists(std::string sc) -> bool"""
        return _IMP_atom.ResidueType_get_key_exists(*args)

    if _newclass:get_key_exists = staticmethod(get_key_exists)
    __swig_getmethods__["get_key_exists"] = lambda x: get_key_exists
    def get_string(self):
        """get_string(ResidueType self) -> std::string const"""
        return _IMP_atom.ResidueType_get_string(self)

    def __eq__(self, *args):
        """__eq__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___ge__(self, *args)

    def __le__(self, *args):
        """__le__(ResidueType self, ResidueType o) -> bool"""
        return _IMP_atom.ResidueType___le__(self, *args)

    def __hash__(self):
        """__hash__(ResidueType self) -> std::size_t"""
        return _IMP_atom.ResidueType___hash__(self)

    def show(self, *args):
        """
        show(ResidueType self, _ostream out=std::cout)
        show(ResidueType self)
        """
        return _IMP_atom.ResidueType_show(self, *args)

    def add_alias(*args):
        """add_alias(ResidueType old_key, std::string new_name) -> ResidueType"""
        return _IMP_atom.ResidueType_add_alias(*args)

    if _newclass:add_alias = staticmethod(add_alias)
    __swig_getmethods__["add_alias"] = lambda x: add_alias
    def get_index(self):
        """get_index(ResidueType self) -> unsigned int"""
        return _IMP_atom.ResidueType_get_index(self)

    def show_all(*args):
        """show_all(_ostream out)"""
        return _IMP_atom.ResidueType_show_all(*args)

    if _newclass:show_all = staticmethod(show_all)
    __swig_getmethods__["show_all"] = lambda x: show_all
    def get_all_strings():
        """get_all_strings() -> IMP::base::Vector< std::string >"""
        return _IMP_atom.ResidueType_get_all_strings()

    if _newclass:get_all_strings = staticmethod(get_all_strings)
    __swig_getmethods__["get_all_strings"] = lambda x: get_all_strings
    def get_number_unique():
        """get_number_unique() -> unsigned int"""
        return _IMP_atom.ResidueType_get_number_unique()

    if _newclass:get_number_unique = staticmethod(get_number_unique)
    __swig_getmethods__["get_number_unique"] = lambda x: 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(*args):
  """ResidueType_add_key(std::string sc) -> unsigned int"""
  return _IMP_atom.ResidueType_add_key(*args)

def ResidueType_get_key_exists(*args):
  """ResidueType_get_key_exists(std::string sc) -> bool"""
  return _IMP_atom.ResidueType_get_key_exists(*args)

def ResidueType_add_alias(*args):
  """ResidueType_add_alias(ResidueType old_key, std::string new_name) -> ResidueType"""
  return _IMP_atom.ResidueType_add_alias(*args)

def ResidueType_show_all(*args):
  """ResidueType_show_all(_ostream out)"""
  return _IMP_atom.ResidueType_show_all(*args)

def ResidueType_get_all_strings():
  """ResidueType_get_all_strings() -> IMP::base::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()

UNKNOWN_ELEMENT = _IMP_atom.UNKNOWN_ELEMENT
OH = _IMP_atom.OH
H2O = _IMP_atom.H2O
H = _IMP_atom.H
He = _IMP_atom.He
Li = _IMP_atom.Li
Be = _IMP_atom.Be
B = _IMP_atom.B
C = _IMP_atom.C
N = _IMP_atom.N
O = _IMP_atom.O
F = _IMP_atom.F
Ne = _IMP_atom.Ne
Na = _IMP_atom.Na
Mg = _IMP_atom.Mg
Al = _IMP_atom.Al
Si = _IMP_atom.Si
P = _IMP_atom.P
S = _IMP_atom.S
Cl = _IMP_atom.Cl
Ar = _IMP_atom.Ar
K = _IMP_atom.K
Ca = _IMP_atom.Ca
Sc = _IMP_atom.Sc
Ti = _IMP_atom.Ti
V = _IMP_atom.V
Cr = _IMP_atom.Cr
Mn = _IMP_atom.Mn
Fe = _IMP_atom.Fe
Co = _IMP_atom.Co
Ni = _IMP_atom.Ni
Cu = _IMP_atom.Cu
Zn = _IMP_atom.Zn
Ga = _IMP_atom.Ga
Ge = _IMP_atom.Ge
As = _IMP_atom.As
Se = _IMP_atom.Se
Br = _IMP_atom.Br
Kr = _IMP_atom.Kr
Rb = _IMP_atom.Rb
Sr = _IMP_atom.Sr
Y = _IMP_atom.Y
Zr = _IMP_atom.Zr
Nb = _IMP_atom.Nb
Mo = _IMP_atom.Mo
Tc = _IMP_atom.Tc
Ru = _IMP_atom.Ru
Rh = _IMP_atom.Rh
Pd = _IMP_atom.Pd
Ag = _IMP_atom.Ag
Cd = _IMP_atom.Cd
In = _IMP_atom.In
Sn = _IMP_atom.Sn
Sb = _IMP_atom.Sb
Te = _IMP_atom.Te
I = _IMP_atom.I
Xe = _IMP_atom.Xe
Cs = _IMP_atom.Cs
Ba = _IMP_atom.Ba
La = _IMP_atom.La
Ce = _IMP_atom.Ce
Pr = _IMP_atom.Pr
Nd = _IMP_atom.Nd
Pm = _IMP_atom.Pm
Sm = _IMP_atom.Sm
Eu = _IMP_atom.Eu
Gd = _IMP_atom.Gd
Tb = _IMP_atom.Tb
Dy = _IMP_atom.Dy
Ho = _IMP_atom.Ho
Er = _IMP_atom.Er
Tm = _IMP_atom.Tm
Yb = _IMP_atom.Yb
Lu = _IMP_atom.Lu
Hf = _IMP_atom.Hf
Ta = _IMP_atom.Ta
W = _IMP_atom.W
Re = _IMP_atom.Re
Os = _IMP_atom.Os
Ir = _IMP_atom.Ir
Pt = _IMP_atom.Pt
Au = _IMP_atom.Au
Hg = _IMP_atom.Hg
Tl = _IMP_atom.Tl
Pb = _IMP_atom.Pb
Bi = _IMP_atom.Bi
Po = _IMP_atom.Po
At = _IMP_atom.At
Rn = _IMP_atom.Rn
Fr = _IMP_atom.Fr
Ra = _IMP_atom.Ra
Ac = _IMP_atom.Ac
Th = _IMP_atom.Th
Pa = _IMP_atom.Pa
U = _IMP_atom.U
Np = _IMP_atom.Np
Pu = _IMP_atom.Pu
Am = _IMP_atom.Am
Cm = _IMP_atom.Cm
Bk = _IMP_atom.Bk
Cf = _IMP_atom.Cf
Es = _IMP_atom.Es
Fm = _IMP_atom.Fm
Md = _IMP_atom.Md
No = _IMP_atom.No
Lr = _IMP_atom.Lr
Db = _IMP_atom.Db
Jl = _IMP_atom.Jl
Rf = _IMP_atom.Rf
NUMBER_OF_ELEMENTS = _IMP_atom.NUMBER_OF_ELEMENTS

def hash_value(*args):
  """hash_value(IMP::atom::Element e) -> size_t"""
  return _IMP_atom.hash_value(*args)
class ElementTable(_object):
    """Proxy of C++ IMP::atom::ElementTable class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ElementTable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ElementTable, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::atom::ElementTable self) -> ElementTable"""
        this = _IMP_atom.new_ElementTable()
        try: self.this.append(this)
        except: self.this = this
    def get_element(self, *args):
        """get_element(ElementTable self, std::string const & s) -> IMP::atom::Element"""
        return _IMP_atom.ElementTable_get_element(self, *args)

    def get_name(self, *args):
        """get_name(ElementTable self, IMP::atom::Element e) -> std::string"""
        return _IMP_atom.ElementTable_get_name(self, *args)

    def get_mass(self, *args):
        """get_mass(ElementTable self, IMP::atom::Element e) -> IMP::Float"""
        return _IMP_atom.ElementTable_get_mass(self, *args)

    __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"""
    __swig_setmethods__ = {}
    for _s in [Hierarchy]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Atom, name, value)
    __swig_getmethods__ = {}
    for _s in [Hierarchy]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Atom, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Atom self) -> Atom
        __init__(IMP::atom::Atom self, Model m, IMP::kernel::ParticleIndex id) -> Atom
        __init__(IMP::atom::Atom self, Particle p) -> Atom
        """
        this = _IMP_atom.new_Atom(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Atom"""
        return _IMP_atom.Atom_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Atom self, _ostream out=std::cout)
        show(Atom self)
        """
        return _IMP_atom.Atom_show(self, *args)

    def get_particle(self):
        """get_particle(Atom self) -> Particle"""
        return _IMP_atom.Atom_get_particle(self)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, AtomType t) -> Atom
        setup_particle(Particle p, AtomType t) -> Atom
        setup_particle(Particle p, Atom o) -> Atom
        """
        return _IMP_atom.Atom_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Atom_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_atom_type(self):
        """get_atom_type(Atom self) -> AtomType"""
        return _IMP_atom.Atom_get_atom_type(self)

    def set_atom_type(self, *args):
        """set_atom_type(Atom self, AtomType t)"""
        return _IMP_atom.Atom_set_atom_type(self, *args)

    def get_element(self):
        """get_element(Atom self) -> IMP::atom::Element"""
        return _IMP_atom.Atom_get_element(self)

    def set_element(self, *args):
        """set_element(Atom self, IMP::atom::Element e)"""
        return _IMP_atom.Atom_set_element(self, *args)

    def get_occupancy(self):
        """get_occupancy(Atom self) -> double"""
        return _IMP_atom.Atom_get_occupancy(self)

    def set_occupancy(self, *args):
        """set_occupancy(Atom self, double occupancy)"""
        return _IMP_atom.Atom_set_occupancy(self, *args)

    def get_temperature_factor(self):
        """get_temperature_factor(Atom self) -> double"""
        return _IMP_atom.Atom_get_temperature_factor(self)

    def set_temperature_factor(self, *args):
        """set_temperature_factor(Atom self, double tempFactor)"""
        return _IMP_atom.Atom_set_temperature_factor(self, *args)

    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, *args):
        """set_input_index(Atom self, IMP::Int t)"""
        return _IMP_atom.Atom_set_input_index(self, *args)

    def get_atom_type_key():
        """get_atom_type_key() -> IntKey"""
        return _IMP_atom.Atom_get_atom_type_key()

    if _newclass:get_atom_type_key = staticmethod(get_atom_type_key)
    __swig_getmethods__["get_atom_type_key"] = lambda x: get_atom_type_key
    def get_element_key():
        """get_element_key() -> IntKey"""
        return _IMP_atom.Atom_get_element_key()

    if _newclass:get_element_key = staticmethod(get_element_key)
    __swig_getmethods__["get_element_key"] = lambda x: get_element_key
    def get_input_index_key():
        """get_input_index_key() -> IntKey"""
        return _IMP_atom.Atom_get_input_index_key()

    if _newclass:get_input_index_key = staticmethod(get_input_index_key)
    __swig_getmethods__["get_input_index_key"] = lambda x: get_input_index_key
    def get_occupancy_key():
        """get_occupancy_key() -> FloatKey"""
        return _IMP_atom.Atom_get_occupancy_key()

    if _newclass:get_occupancy_key = staticmethod(get_occupancy_key)
    __swig_getmethods__["get_occupancy_key"] = lambda x: get_occupancy_key
    def get_temperature_factor_key():
        """get_temperature_factor_key() -> FloatKey"""
        return _IMP_atom.Atom_get_temperature_factor_key()

    if _newclass:get_temperature_factor_key = staticmethod(get_temperature_factor_key)
    __swig_getmethods__["get_temperature_factor_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Atom self, FloatKey a0) -> double"""
        return _IMP_atom.Atom_get_derivative(self, *args)

    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, *args):
        """set_name(Atom self, std::string a0)"""
        return _IMP_atom.Atom_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Atom self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.Atom_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Atom self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Atom_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Atom self, FloatKey a0, bool a1)"""
        return _IMP_atom.Atom_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Atom self, FloatKey a0) -> bool"""
        return _IMP_atom.Atom_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Atom self) -> IMP::base::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 __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_decorate_particle(*args):
  """Atom_decorate_particle(Particle p) -> Atom"""
  return _IMP_atom.Atom_decorate_particle(*args)

def Atom_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, AtomType t) -> Atom
    setup_particle(Particle p, AtomType t) -> Atom
    Atom_setup_particle(Particle p, Atom o) -> Atom
    """
  return _IMP_atom.Atom_setup_particle(*args)

def Atom_particle_is_instance(*args):
  """Atom_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Atom_particle_is_instance(*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(*args):
  """get_atom(Residue rd, AtomType at) -> Atom"""
  return _IMP_atom.get_atom(*args)

def add_atom_type(*args):
  """add_atom_type(std::string name, IMP::atom::Element e) -> AtomType"""
  return _IMP_atom.add_atom_type(*args)

def get_element_for_atom_type(*args):
  """get_element_for_atom_type(AtomType at) -> IMP::atom::Element"""
  return _IMP_atom.get_element_for_atom_type(*args)

def get_atom_type_exists(*args):
  """get_atom_type_exists(std::string name) -> bool"""
  return _IMP_atom.get_atom_type_exists(*args)
class Residue(Hierarchy):
    """Proxy of C++ IMP::atom::Residue class"""
    __swig_setmethods__ = {}
    for _s in [Hierarchy]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Residue, name, value)
    __swig_getmethods__ = {}
    for _s in [Hierarchy]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Residue, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Residue self) -> Residue
        __init__(IMP::atom::Residue self, Model m, IMP::kernel::ParticleIndex id) -> Residue
        __init__(IMP::atom::Residue self, Particle p) -> Residue
        """
        this = _IMP_atom.new_Residue(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Residue"""
        return _IMP_atom.Residue_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Residue self, _ostream out=std::cout)
        show(Residue self)
        """
        return _IMP_atom.Residue_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, ResidueType t=UNK, int index=-1, int insertion_code=32) -> Residue
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, ResidueType t=UNK, int index=-1) -> Residue
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, ResidueType t=UNK) -> Residue
        setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Residue
        setup_particle(Particle p, ResidueType t=UNK, int index=-1, int insertion_code=32) -> Residue
        setup_particle(Particle p, ResidueType t=UNK, int index=-1) -> Residue
        setup_particle(Particle p, ResidueType t=UNK) -> Residue
        setup_particle(Particle p) -> Residue
        setup_particle(Particle p, Residue o) -> Residue
        """
        return _IMP_atom.Residue_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Residue_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_residue_type(self):
        """get_residue_type(Residue self) -> ResidueType"""
        return _IMP_atom.Residue_get_residue_type(self)

    def set_residue_type(self, *args):
        """set_residue_type(Residue self, ResidueType t)"""
        return _IMP_atom.Residue_set_residue_type(self, *args)

    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, *args):
        """set_index(Residue self, IMP::Int t)"""
        return _IMP_atom.Residue_set_index(self, *args)

    def get_insertion_code(self):
        """get_insertion_code(Residue self) -> char"""
        return _IMP_atom.Residue_get_insertion_code(self)

    def set_insertion_code(self, *args):
        """set_insertion_code(Residue self, char insertion_code)"""
        return _IMP_atom.Residue_set_insertion_code(self, *args)

    def get_index_key():
        """get_index_key() -> IntKey"""
        return _IMP_atom.Residue_get_index_key()

    if _newclass:get_index_key = staticmethod(get_index_key)
    __swig_getmethods__["get_index_key"] = lambda x: get_index_key
    def get_residue_type_key():
        """get_residue_type_key() -> IntKey"""
        return _IMP_atom.Residue_get_residue_type_key()

    if _newclass:get_residue_type_key = staticmethod(get_residue_type_key)
    __swig_getmethods__["get_residue_type_key"] = lambda x: get_residue_type_key
    def get_insertion_code_key():
        """get_insertion_code_key() -> IntKey"""
        return _IMP_atom.Residue_get_insertion_code_key()

    if _newclass:get_insertion_code_key = staticmethod(get_insertion_code_key)
    __swig_getmethods__["get_insertion_code_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Residue self, FloatKey a0) -> double"""
        return _IMP_atom.Residue_get_derivative(self, *args)

    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, *args):
        """set_name(Residue self, std::string a0)"""
        return _IMP_atom.Residue_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Residue self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.Residue_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Residue self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Residue_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Residue self, FloatKey a0, bool a1)"""
        return _IMP_atom.Residue_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Residue self, FloatKey a0) -> bool"""
        return _IMP_atom.Residue_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Residue self) -> IMP::base::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 __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_decorate_particle(*args):
  """Residue_decorate_particle(Particle p) -> Residue"""
  return _IMP_atom.Residue_decorate_particle(*args)

def Residue_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, ResidueType t=UNK, int index=-1, int insertion_code=32) -> Residue
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, ResidueType t=UNK, int index=-1) -> Residue
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, ResidueType t=UNK) -> Residue
    setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> Residue
    setup_particle(Particle p, ResidueType t=UNK, int index=-1, int insertion_code=32) -> Residue
    setup_particle(Particle p, ResidueType t=UNK, int index=-1) -> Residue
    setup_particle(Particle p, ResidueType t=UNK) -> Residue
    setup_particle(Particle p) -> Residue
    Residue_setup_particle(Particle p, Residue o) -> Residue
    """
  return _IMP_atom.Residue_setup_particle(*args)

def Residue_particle_is_instance(*args):
  """Residue_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Residue_particle_is_instance(*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(*args):
  """get_next_residue(Residue rd) -> Hierarchy"""
  return _IMP_atom.get_next_residue(*args)

def get_previous_residue(*args):
  """get_previous_residue(Residue rd) -> Hierarchy"""
  return _IMP_atom.get_previous_residue(*args)

def get_one_letter_code(*args):
  """get_one_letter_code(ResidueType c) -> char"""
  return _IMP_atom.get_one_letter_code(*args)

def get_phi_dihedral_atoms(*args):
  """get_phi_dihedral_atoms(Residue rd) -> IMP::atom::Atoms"""
  return _IMP_atom.get_phi_dihedral_atoms(*args)

def get_psi_dihedral_atoms(*args):
  """get_psi_dihedral_atoms(Residue rd) -> IMP::atom::Atoms"""
  return _IMP_atom.get_psi_dihedral_atoms(*args)
class Molecule(Hierarchy):
    """Proxy of C++ IMP::atom::Molecule class"""
    __swig_setmethods__ = {}
    for _s in [Hierarchy]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Molecule, name, value)
    __swig_getmethods__ = {}
    for _s in [Hierarchy]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Molecule, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Molecule self) -> Molecule
        __init__(IMP::atom::Molecule self, Model m, IMP::kernel::ParticleIndex id) -> Molecule
        __init__(IMP::atom::Molecule self, Particle p) -> Molecule
        """
        this = _IMP_atom.new_Molecule(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Molecule"""
        return _IMP_atom.Molecule_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Molecule self, _ostream out=std::cout)
        show(Molecule self)
        """
        return _IMP_atom.Molecule_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Particle p) -> Molecule
        setup_particle(Particle p, Molecule arg2) -> Molecule
        """
        return _IMP_atom.Molecule_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Molecule_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Molecule self, FloatKey a0) -> double"""
        return _IMP_atom.Molecule_get_derivative(self, *args)

    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, *args):
        """set_name(Molecule self, std::string a0)"""
        return _IMP_atom.Molecule_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Molecule self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.Molecule_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Molecule self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Molecule_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Molecule self, FloatKey a0, bool a1)"""
        return _IMP_atom.Molecule_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Molecule self, FloatKey a0) -> bool"""
        return _IMP_atom.Molecule_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Molecule self) -> IMP::base::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 __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_decorate_particle(*args):
  """Molecule_decorate_particle(Particle p) -> Molecule"""
  return _IMP_atom.Molecule_decorate_particle(*args)

def Molecule_setup_particle(*args):
  """
    setup_particle(Particle p) -> Molecule
    Molecule_setup_particle(Particle p, Molecule arg2) -> Molecule
    """
  return _IMP_atom.Molecule_setup_particle(*args)

def Molecule_particle_is_instance(*args):
  """Molecule_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Molecule_particle_is_instance(*args)

class Copy(Molecule):
    """Proxy of C++ IMP::atom::Copy class"""
    __swig_setmethods__ = {}
    for _s in [Molecule]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Copy, name, value)
    __swig_getmethods__ = {}
    for _s in [Molecule]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Copy, name)
    def get_copy_index_key():
        """get_copy_index_key() -> IntKey"""
        return _IMP_atom.Copy_get_copy_index_key()

    if _newclass:get_copy_index_key = staticmethod(get_copy_index_key)
    __swig_getmethods__["get_copy_index_key"] = lambda x: get_copy_index_key
    def __init__(self, *args): 
        """
        __init__(IMP::atom::Copy self) -> Copy
        __init__(IMP::atom::Copy self, Model m, IMP::kernel::ParticleIndex id) -> Copy
        __init__(IMP::atom::Copy self, Particle p) -> Copy
        """
        this = _IMP_atom.new_Copy(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Copy"""
        return _IMP_atom.Copy_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(Copy self, _ostream out=std::cout)
        show(Copy self)
        """
        return _IMP_atom.Copy_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p, int number) -> Copy"""
        return _IMP_atom.Copy_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.Copy_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(Copy self, FloatKey a0) -> double"""
        return _IMP_atom.Copy_get_derivative(self, *args)

    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, *args):
        """set_name(Copy self, std::string a0)"""
        return _IMP_atom.Copy_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Copy self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.Copy_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Copy self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.Copy_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Copy self, FloatKey a0, bool a1)"""
        return _IMP_atom.Copy_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Copy self, FloatKey a0) -> bool"""
        return _IMP_atom.Copy_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Copy self) -> IMP::base::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 __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_decorate_particle(*args):
  """Copy_decorate_particle(Particle p) -> Copy"""
  return _IMP_atom.Copy_decorate_particle(*args)

def Copy_setup_particle(*args):
  """Copy_setup_particle(Particle p, int number) -> Copy"""
  return _IMP_atom.Copy_setup_particle(*args)

def Copy_particle_is_instance(*args):
  """Copy_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.Copy_particle_is_instance(*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, Diffusion n) -> _ostream
    __lshift__(_ostream out, RigidBodyDiffusion 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, Molecule n) -> _ostream
    __lshift__(_ostream out, Copy n) -> _ostream
    """
  return _IMP_atom.__lshift__(*args)
class Selection(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::atom::Selection class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Selection, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Selection, name)
    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::kernel::ParticleIndexes const & pis) -> Selection
        __init__(IMP::atom::Selection self, IMP::kernel::ParticlesTemp const & h) -> Selection
        """
        this = _IMP_atom.new_Selection(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_hierarchies(self):
        """get_hierarchies(Selection self) -> IMP::atom::Hierarchies"""
        return _IMP_atom.Selection_get_hierarchies(self)

    def set_molecules(self, *args):
        """set_molecules(Selection self, IMP::Strings mols)"""
        return _IMP_atom.Selection_set_molecules(self, *args)

    def set_target_radius(self, *args):
        """set_target_radius(Selection self, double r)"""
        return _IMP_atom.Selection_set_target_radius(self, *args)

    def set_terminus(self, *args):
        """set_terminus(Selection self, IMP::atom::Selection::Terminus t)"""
        return _IMP_atom.Selection_set_terminus(self, *args)

    def set_chains(self, *args):
        """set_chains(Selection self, std::string chains)"""
        return _IMP_atom.Selection_set_chains(self, *args)

    def set_residue_indexes(self, *args):
        """set_residue_indexes(Selection self, IMP::Ints indexes)"""
        return _IMP_atom.Selection_set_residue_indexes(self, *args)

    def set_atom_types(self, *args):
        """set_atom_types(Selection self, IMP::atom::AtomTypes types)"""
        return _IMP_atom.Selection_set_atom_types(self, *args)

    def set_residue_types(self, *args):
        """set_residue_types(Selection self, IMP::atom::ResidueTypes types)"""
        return _IMP_atom.Selection_set_residue_types(self, *args)

    def set_domains(self, *args):
        """set_domains(Selection self, IMP::Strings names)"""
        return _IMP_atom.Selection_set_domains(self, *args)

    def set_molecule(self, *args):
        """set_molecule(Selection self, std::string mol)"""
        return _IMP_atom.Selection_set_molecule(self, *args)

    def set_chain(self, *args):
        """set_chain(Selection self, char c)"""
        return _IMP_atom.Selection_set_chain(self, *args)

    def set_residue_index(self, *args):
        """set_residue_index(Selection self, int i)"""
        return _IMP_atom.Selection_set_residue_index(self, *args)

    def set_atom_type(self, *args):
        """set_atom_type(Selection self, AtomType types)"""
        return _IMP_atom.Selection_set_atom_type(self, *args)

    def set_residue_type(self, *args):
        """set_residue_type(Selection self, ResidueType type)"""
        return _IMP_atom.Selection_set_residue_type(self, *args)

    def set_domain(self, *args):
        """set_domain(Selection self, std::string name)"""
        return _IMP_atom.Selection_set_domain(self, *args)

    def set_copy_index(self, *args):
        """set_copy_index(Selection self, unsigned int copy)"""
        return _IMP_atom.Selection_set_copy_index(self, *args)

    def set_copy_indexes(self, *args):
        """set_copy_indexes(Selection self, IMP::Ints const & copies)"""
        return _IMP_atom.Selection_set_copy_indexes(self, *args)

    def set_particle_type(self, *args):
        """set_particle_type(Selection self, ParticleType t)"""
        return _IMP_atom.Selection_set_particle_type(self, *args)

    def set_particle_types(self, *args):
        """set_particle_types(Selection self, IMP::core::ParticleTypes t)"""
        return _IMP_atom.Selection_set_particle_types(self, *args)

    def set_hierarchy_types(self, *args):
        """set_hierarchy_types(Selection self, IMP::Ints const & types)"""
        return _IMP_atom.Selection_set_hierarchy_types(self, *args)

    def get_selected_particles(self):
        """get_selected_particles(Selection self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.Selection_get_selected_particles(self)

    def show(self, *args):
        """
        show(Selection self, _ostream out=std::cout)
        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,
                 molecules=None,
                 residue_indexes=None,
                 chains=None,
                 atom_types=None,
                 residue_types=None,
                 domains=None,
                 target_radius=-1,
                 molecule=None,
                 residue_index=None,
                 chain=None,
                 atom_type=None,
                 residue_type=None,
                 terminus=None,
                 domain=None,
                 particle_type=None,
                 particle_types=None,
                 hierarchy_types=None,
                 copy_index=-1,
                 copy_indexes=None):
        if hierarchy:
          this = _IMP_atom.new_Selection(hierarchy)
          try: self.this.append(this)
          except: self.this = this
        else:
          this = _IMP_atom.new_Selection(hierarchies)
          try: self.this.append(this)
          except: self.this = this
        if not molecules:
            molecules=[]
        if not residue_indexes:
            residue_indexes=[]
        if not chains:
            chains=[]
        if not atom_types:
            atom_types=[]
        if not residue_types:
            residue_types=[]
        if not domains:
            domains=[]
        if molecule:
           molecules.append(molecule)
        if residue_index:
           residue_indexes.append(residue_index)
        if chain:
           chains.append(chain)
        if atom_type:
           atom_types.append(atom_type)
        if residue_type:
           residue_types.append(residue_type)
        if domain:
           domains.append(domain)
        if terminus:
           self.set_terminus(terminus)
        if not copy_indexes:
           copy_indexes=[]
        if copy_index !=-1:
           copy_indexes.append(copy_index)
        if not particle_types:
           particle_types=[]
        if particle_type:
           particle_types.append(particle_type)
        if not hierarchy_types:
           hierarchy_types=[]
        presidue_indexes=[]
        for ri in residue_indexes:
           if type(ri) == type(()):
               presidue_indexes= presidue_indexes+ range(ri[0], ri[1])
           else:
               presidue_indexes.append(ri)
        self.set_molecules(molecules);
        self.set_chains("".join(chains));
        self.set_residue_indexes(presidue_indexes);
        self.set_atom_types(atom_types);
        self.set_residue_types(residue_types);
        self.set_domains(domains);
        self.set_target_radius(target_radius);
        self.set_copy_indexes(copy_indexes)
        self.set_particle_types(particle_types)
        self.set_hierarchy_types(hierarchy_types)

    __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="Distance%1%") -> 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="Connectivity%1%") -> 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="Connectivity%1%") -> 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="Connectivity%1%") -> Restraint
    create_internal_connectivity_restraint(Selection s, double k) -> Restraint
    create_internal_connectivity_restraint(Selection s, double x0, double k, std::string name="Connectivity%1%") -> 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=std::string()) -> XYZR
    create_cover(Selection s) -> XYZR
    """
  return _IMP_atom.create_cover(*args)

def get_mass(*args):
  """get_mass(Selection s) -> double"""
  return _IMP_atom.get_mass(*args)

def get_volume(*args):
  """get_volume(Selection s) -> double"""
  return _IMP_atom.get_volume(*args)

def get_surface_area(*args):
  """get_surface_area(Selection s) -> double"""
  return _IMP_atom.get_surface_area(*args)

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"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SelectionGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SelectionGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::SelectionGeometry self, Selection d, std::string name="Selection") -> SelectionGeometry
        __init__(IMP::atom::SelectionGeometry self, Selection d) -> SelectionGeometry
        """
        this = _IMP_atom.new_SelectionGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(SelectionGeometry self) -> VersionInfo"""
        return _IMP_atom.SelectionGeometry_get_version_info(self)

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

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

SelectionGeometry_swigregister = _IMP_atom.SelectionGeometry_swigregister
SelectionGeometry_swigregister(SelectionGeometry)


def get_rmsd(*args):
  """
    get_rmsd(Selection s0, Selection s1, Transformation3D tr_for_second=IMP::algebra::get_identity_transformation_3d()) -> double
    get_rmsd(Selection s0, Selection s1) -> double
    """
  return _IMP_atom.get_rmsd(*args)

def get_placement_score(*args):
  """get_placement_score(IMP::core::XYZs const & source, IMP::core::XYZs const & target) -> IMP::FloatPair"""
  return _IMP_atom.get_placement_score(*args)

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

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

def get_radius_of_gyration(*args):
  """
    get_radius_of_gyration(Selection s) -> double
    get_radius_of_gyration(IMP::kernel::ParticlesTemp const & ps) -> double
    """
  return _IMP_atom.get_radius_of_gyration(*args)
class RMSDCalculator(_object):
    """Proxy of C++ IMP::atom::RMSDCalculator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RMSDCalculator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RMSDCalculator, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::RMSDCalculator self) -> RMSDCalculator
        __init__(IMP::atom::RMSDCalculator self, IMP::kernel::ParticlesTemp const & ps) -> RMSDCalculator
        """
        this = _IMP_atom.new_RMSDCalculator(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_rmsd(self, *args):
        """get_rmsd(RMSDCalculator self, Transformation3D t1, Transformation3D t2) -> double"""
        return _IMP_atom.RMSDCalculator_get_rmsd(self, *args)

    def get_squared_rmsd(self, *args):
        """get_squared_rmsd(RMSDCalculator self, Transformation3D t1, Transformation3D t2) -> double"""
        return _IMP_atom.RMSDCalculator_get_squared_rmsd(self, *args)

    def show(self, *args):
        """
        show(RMSDCalculator self, _ostream out=std::cout)
        show(RMSDCalculator self)
        """
        return _IMP_atom.RMSDCalculator_show(self, *args)

    def __str__(self):
        """__str__(RMSDCalculator self) -> std::string"""
        return _IMP_atom.RMSDCalculator___str__(self)

    def __repr__(self):
        """__repr__(RMSDCalculator self) -> std::string"""
        return _IMP_atom.RMSDCalculator___repr__(self)

    __swig_destroy__ = _IMP_atom.delete_RMSDCalculator
    __del__ = lambda self : None;
RMSDCalculator_swigregister = _IMP_atom.RMSDCalculator_swigregister
RMSDCalculator_swigregister(RMSDCalculator)

class ForceFieldParameters(IMP.base.Object):
    """Proxy of C++ IMP::atom::ForceFieldParameters class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ForceFieldParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ForceFieldParameters, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def get_radius(self, *args):
        """get_radius(ForceFieldParameters self, Atom atom) -> IMP::Float"""
        return _IMP_atom.ForceFieldParameters_get_radius(self, *args)

    def get_epsilon(self, *args):
        """get_epsilon(ForceFieldParameters self, Atom atom) -> IMP::Float"""
        return _IMP_atom.ForceFieldParameters_get_epsilon(self, *args)

    def add_radii(self, *args):
        """
        add_radii(ForceFieldParameters self, Hierarchy mhd, double scale=1.0, FloatKey radius_key=FloatKey("radius"))
        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, *args):
        """add_well_depths(ForceFieldParameters self, Hierarchy mhd)"""
        return _IMP_atom.ForceFieldParameters_add_well_depths(self, *args)

    def add_bonds(self, *args):
        """add_bonds(ForceFieldParameters self, Hierarchy mhd)"""
        return _IMP_atom.ForceFieldParameters_add_bonds(self, *args)

    __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)

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

ForceFieldParameters_swigregister = _IMP_atom.ForceFieldParameters_swigregister
ForceFieldParameters_swigregister(ForceFieldParameters)

class CHARMMAtomTopology(_object):
    """Proxy of C++ IMP::atom::CHARMMAtomTopology class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMAtomTopology, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMAtomTopology, name)
    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: 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, *args):
        """set_charmm_type(CHARMMAtomTopology self, std::string charmm_type)"""
        return _IMP_atom.CHARMMAtomTopology_set_charmm_type(self, *args)

    def set_charge(self, *args):
        """set_charge(CHARMMAtomTopology self, double charge)"""
        return _IMP_atom.CHARMMAtomTopology_set_charge(self, *args)

    def show(self, *args):
        """
        show(CHARMMAtomTopology self, _ostream out=std::cout)
        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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMBondEndpoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMBondEndpoint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::CHARMMBondEndpoint self, std::string atom_name, CHARMMResidueTopology residue=nullptr) -> CHARMMBondEndpoint
        __init__(IMP::atom::CHARMMBondEndpoint self, std::string atom_name) -> CHARMMBondEndpoint
        """
        this = _IMP_atom.new_CHARMMBondEndpoint(*args)
        try: self.this.append(this)
        except: 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, *args):
        """
        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, *args)

    def show(self, *args):
        """
        show(CHARMMBondEndpoint self, _ostream out=std::cout)
        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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMDihedral, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMDihedral, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::atom::CHARMMConnection<(4)> self, IMP::Strings const & atoms) -> CHARMMDihedral"""
        this = _IMP_atom.new_CHARMMDihedral(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_endpoint(self, *args):
        """get_endpoint(CHARMMDihedral self, unsigned int i) -> CHARMMBondEndpoint"""
        return _IMP_atom.CHARMMDihedral_get_endpoint(self, *args)

    def get_contains_atom(self, *args):
        """get_contains_atom(CHARMMDihedral self, std::string name) -> bool"""
        return _IMP_atom.CHARMMDihedral_get_contains_atom(self, *args)

    def show(self, *args):
        """
        show(CHARMMDihedral self, _ostream out=std::cout)
        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"""
    __swig_setmethods__ = {}
    for _s in [CHARMMDihedral]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMInternalCoordinate, name, value)
    __swig_getmethods__ = {}
    for _s in [CHARMMDihedral]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMInternalCoordinate, name)
    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::base::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: 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=std::cout)
        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.base.Object):
    """Proxy of C++ IMP::atom::CHARMMResidueTopologyBase class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMResidueTopologyBase, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMResidueTopologyBase, name)
    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, *args):
        """add_atom(CHARMMResidueTopologyBase self, CHARMMAtomTopology atom)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_atom(self, *args)

    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, *args):
        """add_bond(CHARMMResidueTopologyBase self, IMP::atom::CHARMMBond const & bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_bond(self, *args)

    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, *args):
        """add_angle(CHARMMResidueTopologyBase self, IMP::atom::CHARMMAngle const & bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_angle(self, *args)

    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, *args):
        """add_dihedral(CHARMMResidueTopologyBase self, CHARMMDihedral bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_dihedral(self, *args)

    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, *args):
        """add_improper(CHARMMResidueTopologyBase self, CHARMMDihedral bond)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_improper(self, *args)

    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, *args):
        """add_internal_coordinate(CHARMMResidueTopologyBase self, CHARMMInternalCoordinate ic)"""
        return _IMP_atom.CHARMMResidueTopologyBase_add_internal_coordinate(self, *args)

    def get_internal_coordinate(self, *args):
        """get_internal_coordinate(CHARMMResidueTopologyBase self, unsigned int index) -> CHARMMInternalCoordinate"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_internal_coordinate(self, *args)

    def get_bond(self, *args):
        """get_bond(CHARMMResidueTopologyBase self, unsigned int index) -> IMP::atom::CHARMMBond const &"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_bond(self, *args)

    def get_angle(self, *args):
        """get_angle(CHARMMResidueTopologyBase self, unsigned int index) -> IMP::atom::CHARMMAngle const &"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_angle(self, *args)

    def get_dihedral(self, *args):
        """get_dihedral(CHARMMResidueTopologyBase self, unsigned int index) -> CHARMMDihedral"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_dihedral(self, *args)

    def get_improper(self, *args):
        """get_improper(CHARMMResidueTopologyBase self, unsigned int index) -> CHARMMDihedral"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_improper(self, *args)

    def get_version_info(self):
        """get_version_info(CHARMMResidueTopologyBase self) -> VersionInfo"""
        return _IMP_atom.CHARMMResidueTopologyBase_get_version_info(self)

    def do_show(self, *args):
        """do_show(CHARMMResidueTopologyBase self, _ostream out)"""
        return _IMP_atom.CHARMMResidueTopologyBase_do_show(self, *args)

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

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

CHARMMResidueTopologyBase_swigregister = _IMP_atom.CHARMMResidueTopologyBase_swigregister
CHARMMResidueTopologyBase_swigregister(CHARMMResidueTopologyBase)

class CHARMMIdealResidueTopology(CHARMMResidueTopologyBase):
    """Proxy of C++ IMP::atom::CHARMMIdealResidueTopology class"""
    __swig_setmethods__ = {}
    for _s in [CHARMMResidueTopologyBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMIdealResidueTopology, name, value)
    __swig_getmethods__ = {}
    for _s in [CHARMMResidueTopologyBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMIdealResidueTopology, name)
    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: self.this = this
    def remove_atom(self, *args):
        """remove_atom(CHARMMIdealResidueTopology self, std::string name)"""
        return _IMP_atom.CHARMMIdealResidueTopology_remove_atom(self, *args)

    def set_default_first_patch(self, *args):
        """set_default_first_patch(CHARMMIdealResidueTopology self, std::string patch)"""
        return _IMP_atom.CHARMMIdealResidueTopology_set_default_first_patch(self, *args)

    def set_default_last_patch(self, *args):
        """set_default_last_patch(CHARMMIdealResidueTopology self, std::string patch)"""
        return _IMP_atom.CHARMMIdealResidueTopology_set_default_last_patch(self, *args)

    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)

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

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

CHARMMIdealResidueTopology_swigregister = _IMP_atom.CHARMMIdealResidueTopology_swigregister
CHARMMIdealResidueTopology_swigregister(CHARMMIdealResidueTopology)

class CHARMMPatch(CHARMMResidueTopologyBase):
    """Proxy of C++ IMP::atom::CHARMMPatch class"""
    __swig_setmethods__ = {}
    for _s in [CHARMMResidueTopologyBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMPatch, name, value)
    __swig_getmethods__ = {}
    for _s in [CHARMMResidueTopologyBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMPatch, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::CHARMMPatch self, std::string type) -> CHARMMPatch"""
        this = _IMP_atom.new_CHARMMPatch(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_removed_atom(self, *args):
        """add_removed_atom(CHARMMPatch self, std::string name)"""
        return _IMP_atom.CHARMMPatch_add_removed_atom(self, *args)

    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, *args):
        """get_removed_atom(CHARMMPatch self, unsigned int i) -> std::string"""
        return _IMP_atom.CHARMMPatch_get_removed_atom(self, *args)

    def apply(self, *args):
        """
        apply(CHARMMPatch self, CHARMMResidueTopology res)
        apply(CHARMMPatch self, CHARMMResidueTopology res1, CHARMMResidueTopology res2)
        """
        return _IMP_atom.CHARMMPatch_apply(self, *args)

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

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

CHARMMPatch_swigregister = _IMP_atom.CHARMMPatch_swigregister
CHARMMPatch_swigregister(CHARMMPatch)

class CHARMMResidueTopology(CHARMMIdealResidueTopology):
    """Proxy of C++ IMP::atom::CHARMMResidueTopology class"""
    __swig_setmethods__ = {}
    for _s in [CHARMMIdealResidueTopology]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMResidueTopology, name, value)
    __swig_getmethods__ = {}
    for _s in [CHARMMIdealResidueTopology]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMResidueTopology, name)
    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: self.this = this
    def get_patched(self):
        """get_patched(CHARMMResidueTopology self) -> bool"""
        return _IMP_atom.CHARMMResidueTopology_get_patched(self)

    def set_patched(self, *args):
        """set_patched(CHARMMResidueTopology self, bool patched)"""
        return _IMP_atom.CHARMMResidueTopology_set_patched(self, *args)

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

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

CHARMMResidueTopology_swigregister = _IMP_atom.CHARMMResidueTopology_swigregister
CHARMMResidueTopology_swigregister(CHARMMResidueTopology)

class CHARMMAtom(Atom):
    """Proxy of C++ IMP::atom::CHARMMAtom class"""
    __swig_setmethods__ = {}
    for _s in [Atom]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [Atom]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMAtom, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::CHARMMAtom self) -> CHARMMAtom
        __init__(IMP::atom::CHARMMAtom self, Model m, IMP::kernel::ParticleIndex id) -> CHARMMAtom
        __init__(IMP::atom::CHARMMAtom self, Particle p) -> CHARMMAtom
        """
        this = _IMP_atom.new_CHARMMAtom(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> CHARMMAtom"""
        return _IMP_atom.CHARMMAtom_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(CHARMMAtom self, _ostream out=std::cout)
        show(CHARMMAtom self)
        """
        return _IMP_atom.CHARMMAtom_show(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p, IMP::String charmm_type) -> CHARMMAtom"""
        return _IMP_atom.CHARMMAtom_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: 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, *args):
        """set_charmm_type(CHARMMAtom self, IMP::String t)"""
        return _IMP_atom.CHARMMAtom_set_charmm_type(self, *args)

    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_atom.CHARMMAtom_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_charmm_type_key():
        """get_charmm_type_key() -> StringKey"""
        return _IMP_atom.CHARMMAtom_get_charmm_type_key()

    if _newclass:get_charmm_type_key = staticmethod(get_charmm_type_key)
    __swig_getmethods__["get_charmm_type_key"] = lambda x: 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, IMP::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) -> IMP::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, IMP::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, *args):
        """get_derivative(CHARMMAtom self, FloatKey a0) -> double"""
        return _IMP_atom.CHARMMAtom_get_derivative(self, *args)

    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, *args):
        """set_name(CHARMMAtom self, std::string a0)"""
        return _IMP_atom.CHARMMAtom_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(CHARMMAtom self, IMP::base::CheckLevel a0)"""
        return _IMP_atom.CHARMMAtom_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(CHARMMAtom self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_atom.CHARMMAtom_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(CHARMMAtom self, FloatKey a0, bool a1)"""
        return _IMP_atom.CHARMMAtom_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(CHARMMAtom self, FloatKey a0) -> bool"""
        return _IMP_atom.CHARMMAtom_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(CHARMMAtom self) -> IMP::base::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 __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_decorate_particle(*args):
  """CHARMMAtom_decorate_particle(Particle p) -> CHARMMAtom"""
  return _IMP_atom.CHARMMAtom_decorate_particle(*args)

def CHARMMAtom_setup_particle(*args):
  """CHARMMAtom_setup_particle(Particle p, IMP::String charmm_type) -> CHARMMAtom"""
  return _IMP_atom.CHARMMAtom_setup_particle(*args)

def CHARMMAtom_particle_is_instance(*args):
  """CHARMMAtom_particle_is_instance(Particle p) -> bool"""
  return _IMP_atom.CHARMMAtom_particle_is_instance(*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(*args):
  """get_charmm_untyped_atoms(Hierarchy hierarchy) -> IMP::atom::Atoms"""
  return _IMP_atom.get_charmm_untyped_atoms(*args)

def remove_charmm_untyped_atoms(*args):
  """remove_charmm_untyped_atoms(Hierarchy hierarchy)"""
  return _IMP_atom.remove_charmm_untyped_atoms(*args)
class CHARMMBondParameters(_object):
    """Proxy of C++ IMP::atom::CHARMMBondParameters class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMBondParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMBondParameters, name)
    __swig_setmethods__["force_constant"] = _IMP_atom.CHARMMBondParameters_force_constant_set
    __swig_getmethods__["force_constant"] = _IMP_atom.CHARMMBondParameters_force_constant_get
    if _newclass:force_constant = _swig_property(_IMP_atom.CHARMMBondParameters_force_constant_get, _IMP_atom.CHARMMBondParameters_force_constant_set)
    __swig_setmethods__["ideal"] = _IMP_atom.CHARMMBondParameters_ideal_set
    __swig_getmethods__["ideal"] = _IMP_atom.CHARMMBondParameters_ideal_get
    if _newclass: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: self.this = this
    def show(self, *args):
        """
        show(CHARMMBondParameters self, _ostream out=std::cout)
        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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMDihedralParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMDihedralParameters, name)
    __swig_setmethods__["force_constant"] = _IMP_atom.CHARMMDihedralParameters_force_constant_set
    __swig_getmethods__["force_constant"] = _IMP_atom.CHARMMDihedralParameters_force_constant_get
    if _newclass:force_constant = _swig_property(_IMP_atom.CHARMMDihedralParameters_force_constant_get, _IMP_atom.CHARMMDihedralParameters_force_constant_set)
    __swig_setmethods__["multiplicity"] = _IMP_atom.CHARMMDihedralParameters_multiplicity_set
    __swig_getmethods__["multiplicity"] = _IMP_atom.CHARMMDihedralParameters_multiplicity_get
    if _newclass:multiplicity = _swig_property(_IMP_atom.CHARMMDihedralParameters_multiplicity_get, _IMP_atom.CHARMMDihedralParameters_multiplicity_set)
    __swig_setmethods__["ideal"] = _IMP_atom.CHARMMDihedralParameters_ideal_set
    __swig_getmethods__["ideal"] = _IMP_atom.CHARMMDihedralParameters_ideal_get
    if _newclass: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: self.this = this
    def show(self, *args):
        """
        show(CHARMMDihedralParameters self, _ostream out=std::cout)
        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"""
    __swig_setmethods__ = {}
    for _s in [ForceFieldParameters]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [ForceFieldParameters]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMParameters, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::CHARMMParameters self, TextInput topology_file_name, TextInput par_file_name=IMP::base::TextInput(), bool translate_names_to_pdb=False) -> CHARMMParameters
        __init__(IMP::atom::CHARMMParameters self, TextInput topology_file_name, TextInput par_file_name=IMP::base::TextInput()) -> CHARMMParameters
        __init__(IMP::atom::CHARMMParameters self, TextInput topology_file_name) -> CHARMMParameters
        """
        this = _IMP_atom.new_CHARMMParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_residue_topology(self, *args):
        """add_residue_topology(CHARMMParameters self, CHARMMIdealResidueTopology res)"""
        return _IMP_atom.CHARMMParameters_add_residue_topology(self, *args)

    def get_residue_topology(self, *args):
        """get_residue_topology(CHARMMParameters self, ResidueType type) -> CHARMMIdealResidueTopology"""
        return _IMP_atom.CHARMMParameters_get_residue_topology(self, *args)

    def add_patch(self, *args):
        """add_patch(CHARMMParameters self, CHARMMPatch patch)"""
        return _IMP_atom.CHARMMParameters_add_patch(self, *args)

    def get_patch(self, *args):
        """get_patch(CHARMMParameters self, std::string name) -> CHARMMPatch"""
        return _IMP_atom.CHARMMParameters_get_patch(self, *args)

    def create_topology(self, *args):
        """create_topology(CHARMMParameters self, Hierarchy hierarchy) -> CHARMMTopology"""
        return _IMP_atom.CHARMMParameters_create_topology(self, *args)

    def get_bond_parameters(self, *args):
        """get_bond_parameters(CHARMMParameters self, std::string type1, std::string type2) -> CHARMMBondParameters"""
        return _IMP_atom.CHARMMParameters_get_bond_parameters(self, *args)

    def get_angle_parameters(self, *args):
        """get_angle_parameters(CHARMMParameters self, std::string type1, std::string type2, std::string type3) -> CHARMMBondParameters"""
        return _IMP_atom.CHARMMParameters_get_angle_parameters(self, *args)

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

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

    def create_angles(self, *args):
        """create_angles(CHARMMParameters self, IMP::kernel::Particles bonds) -> IMP::kernel::Particles"""
        return _IMP_atom.CHARMMParameters_create_angles(self, *args)

    def create_dihedrals(self, *args):
        """create_dihedrals(CHARMMParameters self, IMP::kernel::Particles bonds) -> IMP::kernel::Particles"""
        return _IMP_atom.CHARMMParameters_create_dihedrals(self, *args)

    def get_version_info(self):
        """get_version_info(CHARMMParameters self) -> VersionInfo"""
        return _IMP_atom.CHARMMParameters_get_version_info(self)

    def do_show(self, *args):
        """do_show(CHARMMParameters self, _ostream out)"""
        return _IMP_atom.CHARMMParameters_do_show(self, *args)

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

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

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.base.Object):
    """Proxy of C++ IMP::atom::CHARMMSegmentTopology class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMSegmentTopology, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMSegmentTopology, name)
    def remove_residue(self, *args):
        """remove_residue(CHARMMSegmentTopology self, CHARMMResidueTopology d)"""
        return _IMP_atom.CHARMMSegmentTopology_remove_residue(self, *args)

    def remove_residues(self, *args):
        """remove_residues(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & d)"""
        return _IMP_atom.CHARMMSegmentTopology_remove_residues(self, *args)

    def set_residues(self, *args):
        """set_residues(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & ps)"""
        return _IMP_atom.CHARMMSegmentTopology_set_residues(self, *args)

    def set_residues_order(self, *args):
        """set_residues_order(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & objs)"""
        return _IMP_atom.CHARMMSegmentTopology_set_residues_order(self, *args)

    def add_residue(self, *args):
        """add_residue(CHARMMSegmentTopology self, CHARMMResidueTopology obj) -> unsigned int"""
        return _IMP_atom.CHARMMSegmentTopology_add_residue(self, *args)

    def add_residues(self, *args):
        """add_residues(CHARMMSegmentTopology self, IMP::atom::CHARMMResidueTopologies const & objs)"""
        return _IMP_atom.CHARMMSegmentTopology_add_residues(self, *args)

    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, *args):
        """get_residue(CHARMMSegmentTopology self, unsigned int i) -> CHARMMResidueTopology"""
        return _IMP_atom.CHARMMSegmentTopology_get_residue(self, *args)

    def get_residues(self):
        """get_residues(CHARMMSegmentTopology self) -> IMP::atom::CHARMMResidueTopologies"""
        return _IMP_atom.CHARMMSegmentTopology_get_residues(self)

    def reserve_residues(self, *args):
        """reserve_residues(CHARMMSegmentTopology self, unsigned int sz)"""
        return _IMP_atom.CHARMMSegmentTopology_reserve_residues(self, *args)

    def get_version_info(self):
        """get_version_info(CHARMMSegmentTopology self) -> VersionInfo"""
        return _IMP_atom.CHARMMSegmentTopology_get_version_info(self)

    def do_show(self, *args):
        """do_show(CHARMMSegmentTopology self, _ostream out)"""
        return _IMP_atom.CHARMMSegmentTopology_do_show(self, *args)

    __swig_destroy__ = _IMP_atom.delete_CHARMMSegmentTopology
    __del__ = lambda self : None;
    def __init__(self, name="CHARMM segment topology %1%"): 
        """
        __init__(IMP::atom::CHARMMSegmentTopology self, std::string name="CHARMM segment topology %1%") -> CHARMMSegmentTopology
        __init__(IMP::atom::CHARMMSegmentTopology self) -> CHARMMSegmentTopology
        """
        this = _IMP_atom.new_CHARMMSegmentTopology(name)
        try: self.this.append(this)
        except: self.this = this
    def apply_default_patches(self, *args):
        """apply_default_patches(CHARMMSegmentTopology self, CHARMMParameters ff)"""
        return _IMP_atom.CHARMMSegmentTopology_apply_default_patches(self, *args)

    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)

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

CHARMMSegmentTopology_swigregister = _IMP_atom.CHARMMSegmentTopology_swigregister
CHARMMSegmentTopology_swigregister(CHARMMSegmentTopology)

class CHARMMTopology(IMP.base.Object):
    """Proxy of C++ IMP::atom::CHARMMTopology class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMTopology, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMTopology, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::CHARMMTopology self, CHARMMParameters force_field, std::string name="CHARMM topology %1%") -> CHARMMTopology
        __init__(IMP::atom::CHARMMTopology self, CHARMMParameters force_field) -> CHARMMTopology
        """
        this = _IMP_atom.new_CHARMMTopology(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_parameters(self):
        """get_parameters(CHARMMTopology self) -> CHARMMParameters"""
        return _IMP_atom.CHARMMTopology_get_parameters(self)

    def add_sequence(self, *args):
        """add_sequence(CHARMMTopology self, std::string sequence)"""
        return _IMP_atom.CHARMMTopology_add_sequence(self, *args)

    def apply_default_patches(self):
        """apply_default_patches(CHARMMTopology self)"""
        return _IMP_atom.CHARMMTopology_apply_default_patches(self)

    def create_hierarchy(self, *args):
        """create_hierarchy(CHARMMTopology self, Model model) -> Hierarchy"""
        return _IMP_atom.CHARMMTopology_create_hierarchy(self, *args)

    def add_atom_types(self, *args):
        """add_atom_types(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_atom_types(self, *args)

    def add_coordinates(self, *args):
        """add_coordinates(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_coordinates(self, *args)

    def add_missing_atoms(self, *args):
        """add_missing_atoms(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_missing_atoms(self, *args)

    def setup_hierarchy(self, *args):
        """setup_hierarchy(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_setup_hierarchy(self, *args)

    def add_charges(self, *args):
        """add_charges(CHARMMTopology self, Hierarchy hierarchy)"""
        return _IMP_atom.CHARMMTopology_add_charges(self, *args)

    def add_bonds(self, *args):
        """add_bonds(CHARMMTopology self, Hierarchy hierarchy) -> IMP::kernel::Particles"""
        return _IMP_atom.CHARMMTopology_add_bonds(self, *args)

    def add_dihedrals(self, *args):
        """add_dihedrals(CHARMMTopology self, Hierarchy hierarchy) -> IMP::kernel::Particles"""
        return _IMP_atom.CHARMMTopology_add_dihedrals(self, *args)

    def add_impropers(self, *args):
        """add_impropers(CHARMMTopology self, Hierarchy hierarchy) -> IMP::kernel::Particles"""
        return _IMP_atom.CHARMMTopology_add_impropers(self, *args)

    def remove_segment(self, *args):
        """remove_segment(CHARMMTopology self, CHARMMSegmentTopology d)"""
        return _IMP_atom.CHARMMTopology_remove_segment(self, *args)

    def remove_segments(self, *args):
        """remove_segments(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & d)"""
        return _IMP_atom.CHARMMTopology_remove_segments(self, *args)

    def set_segments(self, *args):
        """set_segments(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & ps)"""
        return _IMP_atom.CHARMMTopology_set_segments(self, *args)

    def set_segments_order(self, *args):
        """set_segments_order(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & objs)"""
        return _IMP_atom.CHARMMTopology_set_segments_order(self, *args)

    def add_segment(self, *args):
        """add_segment(CHARMMTopology self, CHARMMSegmentTopology obj) -> unsigned int"""
        return _IMP_atom.CHARMMTopology_add_segment(self, *args)

    def add_segments(self, *args):
        """add_segments(CHARMMTopology self, IMP::atom::CHARMMSegmentTopologies const & objs)"""
        return _IMP_atom.CHARMMTopology_add_segments(self, *args)

    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, *args):
        """get_segment(CHARMMTopology self, unsigned int i) -> CHARMMSegmentTopology"""
        return _IMP_atom.CHARMMTopology_get_segment(self, *args)

    def get_segments(self):
        """get_segments(CHARMMTopology self) -> IMP::atom::CHARMMSegmentTopologies"""
        return _IMP_atom.CHARMMTopology_get_segments(self)

    def reserve_segments(self, *args):
        """reserve_segments(CHARMMTopology self, unsigned int sz)"""
        return _IMP_atom.CHARMMTopology_reserve_segments(self, *args)

    def get_version_info(self):
        """get_version_info(CHARMMTopology self) -> VersionInfo"""
        return _IMP_atom.CHARMMTopology_get_version_info(self)

    def do_show(self, *args):
        """do_show(CHARMMTopology self, _ostream out)"""
        return _IMP_atom.CHARMMTopology_do_show(self, *args)

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

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

CHARMMTopology_swigregister = _IMP_atom.CHARMMTopology_swigregister
CHARMMTopology_swigregister(CHARMMTopology)

class CHARMMStereochemistryRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::atom::CHARMMStereochemistryRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMStereochemistryRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMStereochemistryRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::CHARMMStereochemistryRestraint self, Hierarchy h, CHARMMTopology topology) -> CHARMMStereochemistryRestraint"""
        this = _IMP_atom.new_CHARMMStereochemistryRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_pair_filter(self):
        """get_pair_filter(CHARMMStereochemistryRestraint self) -> StereochemistryPairFilter"""
        return _IMP_atom.CHARMMStereochemistryRestraint_get_pair_filter(self)

    def get_input_particles(self):
        """get_input_particles(CHARMMStereochemistryRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.CHARMMStereochemistryRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(CHARMMStereochemistryRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.CHARMMStereochemistryRestraint_get_input_containers(self)

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

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

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

CHARMMStereochemistryRestraint_swigregister = _IMP_atom.CHARMMStereochemistryRestraint_swigregister
CHARMMStereochemistryRestraint_swigregister(CHARMMStereochemistryRestraint)


def add_bonds(*args):
  """
    add_bonds(Hierarchy d, ForceFieldParameters ffp=IMP::atom::get_all_atom_CHARMM_parameters())
    add_bonds(Hierarchy d)
    """
  return _IMP_atom.add_bonds(*args)

def add_radii(*args):
  """
    add_radii(Hierarchy d, ForceFieldParameters ffp=IMP::atom::get_all_atom_CHARMM_parameters(), 
        FloatKey radius_key=FloatKey("radius"))
    add_radii(Hierarchy d, ForceFieldParameters ffp=IMP::atom::get_all_atom_CHARMM_parameters())
    add_radii(Hierarchy d)
    """
  return _IMP_atom.add_radii(*args)
ALBER = _IMP_atom.ALBER
HARPAZ = _IMP_atom.HARPAZ
ANDERSSON = _IMP_atom.ANDERSSON
TSAI = _IMP_atom.TSAI
QUILLIN = _IMP_atom.QUILLIN
SQUIRE = _IMP_atom.SQUIRE

def get_protein_density_from_reference(*args):
  """get_protein_density_from_reference(IMP::atom::ProteinDensityReference densityReference) -> double"""
  return _IMP_atom.get_protein_density_from_reference(*args)

def get_volume_from_mass(*args):
  """
    get_volume_from_mass(double m, IMP::atom::ProteinDensityReference ref=ALBER) -> 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=ALBER) -> double
    get_mass_from_volume(double v) -> double
    """
  return _IMP_atom.get_mass_from_volume(*args)

def get_mass_from_number_of_residues(*args):
  """get_mass_from_number_of_residues(unsigned int num_aa) -> double"""
  return _IMP_atom.get_mass_from_number_of_residues(*args)

def get_volume_from_residue_type(*args):
  """get_volume_from_residue_type(ResidueType rt) -> double"""
  return _IMP_atom.get_volume_from_residue_type(*args)

def get_molarity(*args):
  """get_molarity(double n, double volume) -> double"""
  return _IMP_atom.get_molarity(*args)

def get_kd(*args):
  """get_kd(double na, double nb, double nab, double volume) -> double"""
  return _IMP_atom.get_kd(*args)

def get_einstein_diffusion_coefficient(*args):
  """get_einstein_diffusion_coefficient(double r) -> double"""
  return _IMP_atom.get_einstein_diffusion_coefficient(*args)

def get_einstein_rotational_diffusion_coefficient(*args):
  """get_einstein_rotational_diffusion_coefficient(double r) -> double"""
  return _IMP_atom.get_einstein_rotational_diffusion_coefficient(*args)

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(*args):
  """get_diffusion_angle(double D, double dtfs) -> double"""
  return _IMP_atom.get_diffusion_angle(*args)

def get_diffusion_coefficient(*args):
  """get_diffusion_coefficient(IMP::algebra::Vector3Ds const & displacements, double dt) -> double"""
  return _IMP_atom.get_diffusion_coefficient(*args)

def get_rotational_diffusion_coefficient(*args):
  """get_rotational_diffusion_coefficient(IMP::algebra::Rotation3Ds const & displacements, double dt) -> double"""
  return _IMP_atom.get_rotational_diffusion_coefficient(*args)

def create_protein(*args):
  """
    create_protein(Model m, std::string name, double resolution, int number_of_residues, int first_residue_index=0, 
        double volume=-1, bool ismol=True) -> Hierarchy
    create_protein(Model m, std::string name, double resolution, int number_of_residues, int first_residue_index=0, 
        double volume=-1) -> Hierarchy
    create_protein(Model m, std::string name, double resolution, int number_of_residues, int first_residue_index=0) -> Hierarchy
    create_protein(Model m, std::string name, double resolution, int number_of_residues) -> Hierarchy
    create_protein(Model m, std::string name, double resolution, 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 get_molecule_name(*args):
  """get_molecule_name(Hierarchy h) -> std::string"""
  return _IMP_atom.get_molecule_name(*args)

def get_residue_indexes(*args):
  """get_residue_indexes(Hierarchy h) -> IMP::Ints"""
  return _IMP_atom.get_residue_indexes(*args)

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_chain_id(*args):
  """get_chain_id(Hierarchy h) -> int"""
  return _IMP_atom.get_chain_id(*args)

def get_atom_type(*args):
  """get_atom_type(Hierarchy h) -> AtomType"""
  return _IMP_atom.get_atom_type(*args)

def get_domain_name(*args):
  """get_domain_name(Hierarchy h) -> std::string"""
  return _IMP_atom.get_domain_name(*args)

def get_copy_index(*args):
  """get_copy_index(Hierarchy h) -> int"""
  return _IMP_atom.get_copy_index(*args)

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::kernel::ParticlesTemp const & other, double resolution=-1)
    setup_as_approximation(Particle h, IMP::kernel::ParticlesTemp const & other)
    setup_as_approximation(Hierarchy h, double resolution=-1)
    setup_as_approximation(Hierarchy h)
    """
  return _IMP_atom.setup_as_approximation(*args)

def transform(*args):
  """transform(Hierarchy h, Transformation3D tr)"""
  return _IMP_atom.transform(*args)
class _HierarchyTreeVertexIndex(_object):
    """Proxy of C++ IMP::atom::HierarchyTreeVertexIndex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _HierarchyTreeVertexIndex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _HierarchyTreeVertexIndex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::atom::HierarchyTreeVertexIndex self) -> _HierarchyTreeVertexIndex"""
        this = _IMP_atom.new__HierarchyTreeVertexIndex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_atom.delete__HierarchyTreeVertexIndex
    __del__ = lambda self : None;
_HierarchyTreeVertexIndex_swigregister = _IMP_atom._HierarchyTreeVertexIndex_swigregister
_HierarchyTreeVertexIndex_swigregister(_HierarchyTreeVertexIndex)


def get_vertex_index(*args):
  """get_vertex_index(IMP::atom::HierarchyTree const & g) -> _HierarchyTreeVertexIndex"""
  return _IMP_atom.get_vertex_index(*args)

def get_hierarchy_tree(*args):
  """get_hierarchy_tree(Hierarchy h) -> IMP::atom::HierarchyTree"""
  return _IMP_atom.get_hierarchy_tree(*args)
class HierarchyGeometry(IMP.display.SingletonGeometry):
    """Proxy of C++ IMP::atom::HierarchyGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchyGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchyGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::HierarchyGeometry self, Hierarchy d, double resolution=-1) -> HierarchyGeometry
        __init__(IMP::atom::HierarchyGeometry self, Hierarchy d) -> HierarchyGeometry
        """
        this = _IMP_atom.new_HierarchyGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(HierarchyGeometry self) -> VersionInfo"""
        return _IMP_atom.HierarchyGeometry_get_version_info(self)

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

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

HierarchyGeometry_swigregister = _IMP_atom.HierarchyGeometry_swigregister
HierarchyGeometry_swigregister(HierarchyGeometry)

class HierarchiesGeometry(IMP.display.SingletonsGeometry):
    """Proxy of C++ IMP::atom::HierarchiesGeometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HierarchiesGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.display.SingletonsGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HierarchiesGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::HierarchiesGeometry self, SingletonContainer sc, double resolution=-1) -> HierarchiesGeometry
        __init__(IMP::atom::HierarchiesGeometry self, SingletonContainer sc) -> HierarchiesGeometry
        """
        this = _IMP_atom.new_HierarchiesGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(HierarchiesGeometry self) -> VersionInfo"""
        return _IMP_atom.HierarchiesGeometry_get_version_info(self)

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

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

HierarchiesGeometry_swigregister = _IMP_atom.HierarchiesGeometry_swigregister
HierarchiesGeometry_swigregister(HierarchiesGeometry)

class DopePairScore(_ADopeBase):
    """Proxy of C++ IMP::atom::DopePairScore class"""
    __swig_setmethods__ = {}
    for _s in [_ADopeBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DopePairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [_ADopeBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DopePairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::atom::DopePairScore self, double threshold=std::numeric_limits< double >::max()) -> 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: 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)

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

    __swig_destroy__ = _IMP_atom.delete_DopePairScore
    __del__ = lambda self : None;
DopePairScore_swigregister = _IMP_atom.DopePairScore_swigregister
DopePairScore_swigregister(DopePairScore)


def add_dope_score_data(*args):
  """add_dope_score_data(Hierarchy h)"""
  return _IMP_atom.add_dope_score_data(*args)
class SameResiduePairFilter(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::atom::SameResiduePairFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SameResiduePairFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SameResiduePairFilter, name)
    def __init__(self): 
        """__init__(IMP::atom::SameResiduePairFilter self) -> SameResiduePairFilter"""
        this = _IMP_atom.new_SameResiduePairFilter()
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """
        get_value(SameResiduePairFilter self, IMP::kernel::ParticlePair const & a) -> int
        get_value(SameResiduePairFilter self, IMP::kernel::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::kernel::ParticleIndexPair const & vt) -> int
        get_value_index(SameResiduePairFilter self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_atom.SameResiduePairFilter_get_value_index(self, *args)

    def get_input_particles(self, *args):
        """get_input_particles(SameResiduePairFilter self, Particle arg2) -> IMP::kernel::ParticlesTemp"""
        return _IMP_atom.SameResiduePairFilter_get_input_particles(self, *args)

    def get_input_containers(self, *args):
        """get_input_containers(SameResiduePairFilter self, Particle arg2) -> IMP::kernel::ContainersTemp"""
        return _IMP_atom.SameResiduePairFilter_get_input_containers(self, *args)

    def get_version_info(self):
        """get_version_info(SameResiduePairFilter self) -> VersionInfo"""
        return _IMP_atom.SameResiduePairFilter_get_version_info(self)

    def do_show(self, *args):
        """do_show(SameResiduePairFilter self, _ostream out)"""
        return _IMP_atom.SameResiduePairFilter_do_show(self, *args)

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

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

SameResiduePairFilter_swigregister = _IMP_atom.SameResiduePairFilter_swigregister
SameResiduePairFilter_swigregister(SameResiduePairFilter)

class RemoveRigidMotionOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::atom::RemoveRigidMotionOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RemoveRigidMotionOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RemoveRigidMotionOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::RemoveRigidMotionOptimizerState self, IMP::kernel::ParticlesTemp const & pis, unsigned int skip_steps) -> RemoveRigidMotionOptimizerState"""
        this = _IMP_atom.new_RemoveRigidMotionOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_skip_steps(self, *args):
        """set_skip_steps(RemoveRigidMotionOptimizerState self, unsigned int skip_steps)"""
        return _IMP_atom.RemoveRigidMotionOptimizerState_set_skip_steps(self, *args)

    def get_skip_steps(self):
        """get_skip_steps(RemoveRigidMotionOptimizerState self) -> unsigned int"""
        return _IMP_atom.RemoveRigidMotionOptimizerState_get_skip_steps(self)

    def set_particles(self, *args):
        """set_particles(RemoveRigidMotionOptimizerState self, IMP::kernel::Particles const & pis)"""
        return _IMP_atom.RemoveRigidMotionOptimizerState_set_particles(self, *args)

    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 do_show(self, *args):
        """do_show(RemoveRigidMotionOptimizerState self, _ostream out)"""
        return _IMP_atom.RemoveRigidMotionOptimizerState_do_show(self, *args)

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

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

RemoveRigidMotionOptimizerState_swigregister = _IMP_atom.RemoveRigidMotionOptimizerState_swigregister
RemoveRigidMotionOptimizerState_swigregister(RemoveRigidMotionOptimizerState)

class BerendsenThermostatOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::atom::BerendsenThermostatOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BerendsenThermostatOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BerendsenThermostatOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::BerendsenThermostatOptimizerState self, IMP::kernel::Particles const & pis, double temperature, double tau) -> BerendsenThermostatOptimizerState"""
        this = _IMP_atom.new_BerendsenThermostatOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_particles(self, *args):
        """set_particles(BerendsenThermostatOptimizerState self, IMP::kernel::Particles const & pis)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_set_particles(self, *args)

    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, *args):
        """set_temperature(BerendsenThermostatOptimizerState self, double temperature)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_set_temperature(self, *args)

    def set_tau(self, *args):
        """set_tau(BerendsenThermostatOptimizerState self, double tau)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_set_tau(self, *args)

    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 do_show(self, *args):
        """do_show(BerendsenThermostatOptimizerState self, _ostream out)"""
        return _IMP_atom.BerendsenThermostatOptimizerState_do_show(self, *args)

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

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

BerendsenThermostatOptimizerState_swigregister = _IMP_atom.BerendsenThermostatOptimizerState_swigregister
BerendsenThermostatOptimizerState_swigregister(BerendsenThermostatOptimizerState)

class LangevinThermostatOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::atom::LangevinThermostatOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LangevinThermostatOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LangevinThermostatOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::LangevinThermostatOptimizerState self, IMP::kernel::ParticlesTemp const & pis, double temperature, double gamma) -> LangevinThermostatOptimizerState"""
        this = _IMP_atom.new_LangevinThermostatOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_particles(self, *args):
        """set_particles(LangevinThermostatOptimizerState self, IMP::kernel::Particles const & pis)"""
        return _IMP_atom.LangevinThermostatOptimizerState_set_particles(self, *args)

    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, *args):
        """set_temperature(LangevinThermostatOptimizerState self, double temperature)"""
        return _IMP_atom.LangevinThermostatOptimizerState_set_temperature(self, *args)

    def set_gamma(self, *args):
        """set_gamma(LangevinThermostatOptimizerState self, double gamma)"""
        return _IMP_atom.LangevinThermostatOptimizerState_set_gamma(self, *args)

    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 do_show(self, *args):
        """do_show(LangevinThermostatOptimizerState self, _ostream out)"""
        return _IMP_atom.LangevinThermostatOptimizerState_do_show(self, *args)

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

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

LangevinThermostatOptimizerState_swigregister = _IMP_atom.LangevinThermostatOptimizerState_swigregister
LangevinThermostatOptimizerState_swigregister(LangevinThermostatOptimizerState)

class PDBSelector(IMP.base.Object):
    """Proxy of C++ IMP::atom::PDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PDBSelector, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::PDBSelector self, std::string name) -> PDBSelector"""
        if self.__class__ == PDBSelector:
            _self = None
        else:
            _self = self
        this = _IMP_atom.new_PDBSelector(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != PDBSelector:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_is_selected(self, *args):
        """get_is_selected(PDBSelector self, std::string const & pdb_line) -> bool"""
        return _IMP_atom.PDBSelector_get_is_selected(self, *args)

    __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)

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

    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("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_PDBSelector(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_atom.disown_PDBSelector(self)
        return weakref_proxy(self)
PDBSelector_swigregister = _IMP_atom.PDBSelector_swigregister
PDBSelector_swigregister(PDBSelector)

class NonAlternativePDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::NonAlternativePDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [PDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NonAlternativePDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [PDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NonAlternativePDBSelector, name)
    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: self.this = this
    def get_version_info(self):
        """get_version_info(NonAlternativePDBSelector self) -> VersionInfo"""
        return _IMP_atom.NonAlternativePDBSelector_get_version_info(self)

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

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

NonAlternativePDBSelector_swigregister = _IMP_atom.NonAlternativePDBSelector_swigregister
NonAlternativePDBSelector_swigregister(NonAlternativePDBSelector)

class ATOMPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::ATOMPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ATOMPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ATOMPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_ATOMPDBSelector
    __del__ = lambda self : None;
    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)

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

ATOMPDBSelector_swigregister = _IMP_atom.ATOMPDBSelector_swigregister
ATOMPDBSelector_swigregister(ATOMPDBSelector)

class CAlphaPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::CAlphaPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAlphaPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAlphaPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_CAlphaPDBSelector
    __del__ = lambda self : None;
    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)

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

CAlphaPDBSelector_swigregister = _IMP_atom.CAlphaPDBSelector_swigregister
CAlphaPDBSelector_swigregister(CAlphaPDBSelector)

class CBetaPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::CBetaPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CBetaPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CBetaPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_CBetaPDBSelector
    __del__ = lambda self : None;
    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)

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

CBetaPDBSelector_swigregister = _IMP_atom.CBetaPDBSelector_swigregister
CBetaPDBSelector_swigregister(CBetaPDBSelector)

class CPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::CPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_CPDBSelector
    __del__ = lambda self : None;
    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)

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

CPDBSelector_swigregister = _IMP_atom.CPDBSelector_swigregister
CPDBSelector_swigregister(CPDBSelector)

class NPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::NPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_NPDBSelector
    __del__ = lambda self : None;
    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)

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

NPDBSelector_swigregister = _IMP_atom.NPDBSelector_swigregister
NPDBSelector_swigregister(NPDBSelector)

class AllPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::AllPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [PDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [PDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllPDBSelector, name)
    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: self.this = this
    def get_version_info(self):
        """get_version_info(AllPDBSelector self) -> VersionInfo"""
        return _IMP_atom.AllPDBSelector_get_version_info(self)

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

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

AllPDBSelector_swigregister = _IMP_atom.AllPDBSelector_swigregister
AllPDBSelector_swigregister(AllPDBSelector)

class ChainPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::ChainPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChainPDBSelector, name)
    __swig_destroy__ = _IMP_atom.delete_ChainPDBSelector
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(IMP::atom::ChainPDBSelector self, std::string const & chains, std::string name="ChainPDBSelector%1%") -> ChainPDBSelector
        __init__(IMP::atom::ChainPDBSelector self, std::string const & chains) -> ChainPDBSelector
        """
        this = _IMP_atom.new_ChainPDBSelector(*args)
        try: self.this.append(this)
        except: 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)

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

ChainPDBSelector_swigregister = _IMP_atom.ChainPDBSelector_swigregister
ChainPDBSelector_swigregister(ChainPDBSelector)

class WaterPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::WaterPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WaterPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WaterPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_WaterPDBSelector
    __del__ = lambda self : None;
    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)

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

WaterPDBSelector_swigregister = _IMP_atom.WaterPDBSelector_swigregister
WaterPDBSelector_swigregister(WaterPDBSelector)

class HydrogenPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::HydrogenPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HydrogenPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HydrogenPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_HydrogenPDBSelector
    __del__ = lambda self : None;
    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)

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

HydrogenPDBSelector_swigregister = _IMP_atom.HydrogenPDBSelector_swigregister
HydrogenPDBSelector_swigregister(HydrogenPDBSelector)

class NonWaterNonHydrogenPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::NonWaterNonHydrogenPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NonWaterNonHydrogenPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NonWaterNonHydrogenPDBSelector, name)
    __swig_destroy__ = _IMP_atom.delete_NonWaterNonHydrogenPDBSelector
    __del__ = lambda self : None;
    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: 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)

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

NonWaterNonHydrogenPDBSelector_swigregister = _IMP_atom.NonWaterNonHydrogenPDBSelector_swigregister
NonWaterNonHydrogenPDBSelector_swigregister(NonWaterNonHydrogenPDBSelector)

class NonWaterPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::NonWaterPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NonWaterPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NonWaterPDBSelector, name)
    __swig_destroy__ = _IMP_atom.delete_NonWaterPDBSelector
    __del__ = lambda self : None;
    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: 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)

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

NonWaterPDBSelector_swigregister = _IMP_atom.NonWaterPDBSelector_swigregister
NonWaterPDBSelector_swigregister(NonWaterPDBSelector)

class PPDBSelector(NonAlternativePDBSelector):
    """Proxy of C++ IMP::atom::PPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [NonAlternativePDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PPDBSelector, name)
    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: self.this = this
    __swig_destroy__ = _IMP_atom.delete_PPDBSelector
    __del__ = lambda self : None;
    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)

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

PPDBSelector_swigregister = _IMP_atom.PPDBSelector_swigregister
PPDBSelector_swigregister(PPDBSelector)

class AndPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::AndPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [PDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AndPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [PDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AndPDBSelector, name)
    def get_version_info(self):
        """get_version_info(AndPDBSelector self) -> VersionInfo"""
        return _IMP_atom.AndPDBSelector_get_version_info(self)

    __swig_destroy__ = _IMP_atom.delete_AndPDBSelector
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """__init__(IMP::atom::AndPDBSelector self, PDBSelector a, PDBSelector b) -> AndPDBSelector"""
        this = _IMP_atom.new_AndPDBSelector(*args)
        try: self.this.append(this)
        except: 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)

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

AndPDBSelector_swigregister = _IMP_atom.AndPDBSelector_swigregister
AndPDBSelector_swigregister(AndPDBSelector)

class OrPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::OrPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [PDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OrPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [PDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OrPDBSelector, name)
    def get_version_info(self):
        """get_version_info(OrPDBSelector self) -> VersionInfo"""
        return _IMP_atom.OrPDBSelector_get_version_info(self)

    __swig_destroy__ = _IMP_atom.delete_OrPDBSelector
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """__init__(IMP::atom::OrPDBSelector self, PDBSelector a, PDBSelector b) -> OrPDBSelector"""
        this = _IMP_atom.new_OrPDBSelector(*args)
        try: self.this.append(this)
        except: 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)

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

OrPDBSelector_swigregister = _IMP_atom.OrPDBSelector_swigregister
OrPDBSelector_swigregister(OrPDBSelector)

class NotPDBSelector(PDBSelector):
    """Proxy of C++ IMP::atom::NotPDBSelector class"""
    __swig_setmethods__ = {}
    for _s in [PDBSelector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotPDBSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [PDBSelector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotPDBSelector, name)
    def get_version_info(self):
        """get_version_info(NotPDBSelector self) -> VersionInfo"""
        return _IMP_atom.NotPDBSelector_get_version_info(self)

    __swig_destroy__ = _IMP_atom.delete_NotPDBSelector
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """__init__(IMP::atom::NotPDBSelector self, PDBSelector a) -> NotPDBSelector"""
        this = _IMP_atom.new_NotPDBSelector(*args)
        try: self.this.append(this)
        except: 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)

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

NotPDBSelector_swigregister = _IMP_atom.NotPDBSelector_swigregister
NotPDBSelector_swigregister(NotPDBSelector)


def read_pdb(*args):
  """
    read_pdb(TextInput input, Model model) -> Hierarchy
    read_pdb(TextInput input, int model, Hierarchy h)
    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
    """
  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(*args):
  """
    write_pdb(Selection mhd, TextOutput out, unsigned int model=0)
    write_pdb(Selection mhd, TextOutput out)
    """
  return _IMP_atom.write_pdb(*args)

def write_pdb_of_c_alphas(*args):
  """
    write_pdb_of_c_alphas(Selection mhd, TextOutput out, unsigned int model=0)
    write_pdb_of_c_alphas(Selection mhd, TextOutput out)
    """
  return _IMP_atom.write_pdb_of_c_alphas(*args)

def write_multimodel_pdb(*args):
  """write_multimodel_pdb(IMP::atom::Hierarchies const & mhd, TextOutput out)"""
  return _IMP_atom.write_multimodel_pdb(*args)

def get_pdb_string(*args):
  """
    get_pdb_string(Vector3D v, int index=-1, AtomType at=AT_C, ResidueType rt=ALA, char chain=' ', int res_index=1, 
        char res_icode=' ', double occpancy=1.00, double tempFactor=0.00, 
        IMP::atom::Element e=C) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at=AT_C, ResidueType rt=ALA, 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=AT_C, ResidueType rt=ALA, 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=AT_C, ResidueType rt=ALA, char chain=' ', int res_index=1, 
        char res_icode=' ') -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at=AT_C, ResidueType rt=ALA, char chain=' ', int res_index=1) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at=AT_C, ResidueType rt=ALA, char chain=' ') -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at=AT_C, ResidueType rt=ALA) -> std::string
    get_pdb_string(Vector3D v, int index=-1, AtomType at=AT_C) -> 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(*args):
  """get_pdb_conect_record_string(int arg1, int arg2) -> std::string"""
  return _IMP_atom.get_pdb_conect_record_string(*args)
class WritePDBOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::atom::WritePDBOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WritePDBOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WritePDBOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::atom::WritePDBOptimizerState self, IMP::atom::Hierarchies const & mh, std::string file_name) -> WritePDBOptimizerState"""
        this = _IMP_atom.new_WritePDBOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_skip_steps(self, *args):
        """set_skip_steps(WritePDBOptimizerState self, unsigned int k)"""
        return _IMP_atom.WritePDBOptimizerState_set_skip_steps(self, *args)

    def set_period(self, *args):
        """set_period(WritePDBOptimizerState self, unsigned int p)"""
        return _IMP_atom.WritePDBOptimizerState_set_period(self, *args)

    def write(self, *args):
        """
        write(WritePDBOptimizerState self, std::string file_name, unsigned int call=0, bool append=False)
        write(WritePDBOptimizerState self, std::string file_name, unsigned int call=0)
        write(WritePDBOptimizerState self, std::string file_name)
        """
        return _IMP_atom.WritePDBOptimizerState_write(self, *args)

    def get_version_info(self):
        """get_version_info(WritePDBOptimizerState self) -> VersionInfo"""
        return _IMP_atom.WritePDBOptimizerState_get_version_info(self)

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

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

WritePDBOptimizerState_swigregister = _IMP_atom.WritePDBOptimizerState_swigregister
WritePDBOptimizerState_swigregister(WritePDBOptimizerState)


def get_kt(*args):
  """get_kt(double T) -> double"""
  return _IMP_atom.get_kt(*args)

def show_molecular_hierarchy(*args):
  """
    show_molecular_hierarchy(Hierarchy h, _ostream out=std::cout) -> _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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMBond, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMBond, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::atom::CHARMMConnection<(2)> self, IMP::Strings const & atoms) -> CHARMMBond"""
        this = _IMP_atom.new_CHARMMBond(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_endpoint(self, *args):
        """get_endpoint(CHARMMBond self, unsigned int i) -> CHARMMBondEndpoint"""
        return _IMP_atom.CHARMMBond_get_endpoint(self, *args)

    def get_contains_atom(self, *args):
        """get_contains_atom(CHARMMBond self, std::string name) -> bool"""
        return _IMP_atom.CHARMMBond_get_contains_atom(self, *args)

    def show(self, *args):
        """
        show(CHARMMBond self, _ostream out=std::cout)
        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"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHARMMAngle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CHARMMAngle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::atom::CHARMMConnection<(3)> self, IMP::Strings const & atoms) -> CHARMMAngle"""
        this = _IMP_atom.new_CHARMMAngle(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_endpoint(self, *args):
        """get_endpoint(CHARMMAngle self, unsigned int i) -> CHARMMBondEndpoint"""
        return _IMP_atom.CHARMMAngle_get_endpoint(self, *args)

    def get_contains_atom(self, *args):
        """get_contains_atom(CHARMMAngle self, std::string name) -> bool"""
        return _IMP_atom.CHARMMAngle_get_contains_atom(self, *args)

    def show(self, *args):
        """
        show(CHARMMAngle self, _ostream out=std::cout)
        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_rmsd_cpp(*args):
  """
    _get_rmsd_cpp(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m2, 
        Transformation3D tr_for_second=IMP::algebra::get_identity_transformation_3d()) -> double
    _get_rmsd_cpp(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m2) -> double
    """
  return _IMP_atom._get_rmsd_cpp(*args)

def _get_native_overlap_cpp(*args):
  """
    _get_native_overlap_cpp(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m2, 
        double threshold) -> double
    """
  return _IMP_atom._get_native_overlap_cpp(*args)

def _get_drmsd_cpp(*args):
  """_get_drmsd_cpp(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m0, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m1) -> double"""
  return _IMP_atom._get_drmsd_cpp(*args)

def _get_drms_cpp(*args):
  """_get_drms_cpp(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m2) -> double"""
  return _IMP_atom._get_drms_cpp(*args)

def _get_rigid_bodies_drms_cpp(*args):
  """
    _get_rigid_bodies_drms_cpp(IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m1, IMP::base::Vector< IMP::algebra::VectorD< 3 > > const & m2, 
        IMP::IntRanges const & ranges) -> double
    """
  return _IMP_atom._get_rigid_bodies_drms_cpp(*args)
def get_rmsd(a, b):
   va= [IMP.algebra.get_vector(x) for x in a]
   vb= [IMP.algebra.get_vector(x) for x in b]
   return _get_rmsd_cpp(va, vb)
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_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(*args):
  """get_example_path(std::string fname) -> std::string"""
  return _IMP_atom.get_example_path(*args)

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

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