kinematics/__init__.py

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

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

from __future__ import print_function, division, absolute_import




from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_kinematics', [dirname(__file__)])
        except ImportError:
            import _IMP_kinematics
            return _IMP_kinematics
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_kinematics', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_kinematics = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_kinematics
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


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

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


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

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



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


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


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

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

    def value(self):
        """value(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(IMP_KINEMATICS_SwigPyIterator self, size_t n=1) -> IMP_KINEMATICS_SwigPyIterator
        incr(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(IMP_KINEMATICS_SwigPyIterator self, size_t n=1) -> IMP_KINEMATICS_SwigPyIterator
        decr(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_copy(self)


    def next(self):
        """next(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_next(self)


    def __next__(self):
        """__next__(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___next__(self)


    def previous(self):
        """previous(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator
        __sub__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
IMP_KINEMATICS_SwigPyIterator_swigregister = _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_swigregister
IMP_KINEMATICS_SwigPyIterator_swigregister(IMP_KINEMATICS_SwigPyIterator)


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


_IMP_kinematics.IMP_DEBUG_swigconstant(_IMP_kinematics)
IMP_DEBUG = _IMP_kinematics.IMP_DEBUG

_IMP_kinematics.IMP_RELEASE_swigconstant(_IMP_kinematics)
IMP_RELEASE = _IMP_kinematics.IMP_RELEASE

_IMP_kinematics.IMP_SILENT_swigconstant(_IMP_kinematics)
IMP_SILENT = _IMP_kinematics.IMP_SILENT

_IMP_kinematics.IMP_PROGRESS_swigconstant(_IMP_kinematics)
IMP_PROGRESS = _IMP_kinematics.IMP_PROGRESS

_IMP_kinematics.IMP_TERSE_swigconstant(_IMP_kinematics)
IMP_TERSE = _IMP_kinematics.IMP_TERSE

_IMP_kinematics.IMP_VERBOSE_swigconstant(_IMP_kinematics)
IMP_VERBOSE = _IMP_kinematics.IMP_VERBOSE

_IMP_kinematics.IMP_MEMORY_swigconstant(_IMP_kinematics)
IMP_MEMORY = _IMP_kinematics.IMP_MEMORY

_IMP_kinematics.IMP_NONE_swigconstant(_IMP_kinematics)
IMP_NONE = _IMP_kinematics.IMP_NONE

_IMP_kinematics.IMP_USAGE_swigconstant(_IMP_kinematics)
IMP_USAGE = _IMP_kinematics.IMP_USAGE

_IMP_kinematics.IMP_INTERNAL_swigconstant(_IMP_kinematics)
IMP_INTERNAL = _IMP_kinematics.IMP_INTERNAL

_IMP_kinematics.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_kinematics)
IMP_KERNEL_HAS_LOG4CXX = _IMP_kinematics.IMP_KERNEL_HAS_LOG4CXX

_IMP_kinematics.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_kinematics)
IMP_COMPILER_HAS_AUTO = _IMP_kinematics.IMP_COMPILER_HAS_AUTO

_IMP_kinematics.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_kinematics)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kinematics.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_kinematics.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_kinematics)
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kinematics.IMP_COMPILER_HAS_UNIQUE_PTR

_IMP_kinematics.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_kinematics)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kinematics.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_kinematics)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_kinematics)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_kinematics.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_kinematics)
IMPKERNEL_SHOW_WARNINGS = _IMP_kinematics.IMPKERNEL_SHOW_WARNINGS

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

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

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

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

_ostream_swigregister = _IMP_kinematics._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_kinematics.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_kinematics)
IMP_COMPILER_HAS_OVERRIDE = _IMP_kinematics.IMP_COMPILER_HAS_OVERRIDE

_IMP_kinematics.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_kinematics)
IMP_COMPILER_HAS_FINAL = _IMP_kinematics.IMP_COMPILER_HAS_FINAL

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

_IMP_kinematics.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_SYSTEM

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

_IMP_kinematics.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_IMP_CGAL

_IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_ALGEBRA_HAS_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_CGAL

_IMP_kinematics.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_kinematics)
IMP_ALGEBRA_HAS_ANN = _IMP_kinematics.IMP_ALGEBRA_HAS_ANN

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

_IMP_kinematics.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_IMP_CGAL

_IMP_kinematics.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_DISPLAY_HAS_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_CGAL

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

_IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

_IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_CGAL

_IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_HDF5_swigconstant(_IMP_kinematics)
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_HDF5

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

_IMP_kinematics.IMP_CORE_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_IMP_CGAL = _IMP_kinematics.IMP_CORE_HAS_IMP_CGAL

_IMP_kinematics.IMP_CORE_HAS_IMP_KERNEL_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CORE_HAS_IMP_KERNEL

_IMP_kinematics.IMP_CORE_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_CORE_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CORE_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_CORE_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_CORE_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_CGAL = _IMP_kinematics.IMP_CORE_HAS_CGAL

_IMP_kinematics.IMP_CORE_HAS_HDF5_swigconstant(_IMP_kinematics)
IMP_CORE_HAS_HDF5 = _IMP_kinematics.IMP_CORE_HAS_HDF5

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

_IMP_kinematics.IMP_CONTAINER_HAS_IMP_ALGEBRA_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_ALGEBRA

_IMP_kinematics.IMP_CONTAINER_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_CGAL

_IMP_kinematics.IMP_CONTAINER_HAS_IMP_DISPLAY_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_DISPLAY

_IMP_kinematics.IMP_CONTAINER_HAS_IMP_KERNEL_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_KERNEL

_IMP_kinematics.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

_IMP_kinematics.IMP_CONTAINER_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_CONTAINER_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_CONTAINER_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_CONTAINER_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_CGAL

_IMP_kinematics.IMP_CONTAINER_HAS_HDF5_swigconstant(_IMP_kinematics)
IMP_CONTAINER_HAS_HDF5 = _IMP_kinematics.IMP_CONTAINER_HAS_HDF5

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

_IMP_kinematics.IMP_ATOM_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_IMP_CGAL = _IMP_kinematics.IMP_ATOM_HAS_IMP_CGAL

_IMP_kinematics.IMP_ATOM_HAS_IMP_KERNEL_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_IMP_KERNEL = _IMP_kinematics.IMP_ATOM_HAS_IMP_KERNEL

_IMP_kinematics.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

_IMP_kinematics.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_ATOM_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_ATOM_HAS_BOOST_REGEX_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_BOOST_REGEX = _IMP_kinematics.IMP_ATOM_HAS_BOOST_REGEX

_IMP_kinematics.IMP_ATOM_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_ATOM_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_CGAL = _IMP_kinematics.IMP_ATOM_HAS_CGAL

_IMP_kinematics.IMP_ATOM_HAS_HDF5_swigconstant(_IMP_kinematics)
IMP_ATOM_HAS_HDF5 = _IMP_kinematics.IMP_ATOM_HAS_HDF5

_IMP_kinematics.IMPATOM_SHOW_WARNINGS_swigconstant(_IMP_kinematics)
IMPATOM_SHOW_WARNINGS = _IMP_kinematics.IMPATOM_SHOW_WARNINGS

_IMP_kinematics.IMP_ATOM_TYPE_INDEX_swigconstant(_IMP_kinematics)
IMP_ATOM_TYPE_INDEX = _IMP_kinematics.IMP_ATOM_TYPE_INDEX

_IMP_kinematics.IMP_RESIDUE_TYPE_INDEX_swigconstant(_IMP_kinematics)
IMP_RESIDUE_TYPE_INDEX = _IMP_kinematics.IMP_RESIDUE_TYPE_INDEX

_IMP_kinematics.IMP_HIERARCHY_TYPE_INDEX_swigconstant(_IMP_kinematics)
IMP_HIERARCHY_TYPE_INDEX = _IMP_kinematics.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom

_IMP_kinematics.IMP_SAXS_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_IMP_CGAL = _IMP_kinematics.IMP_SAXS_HAS_IMP_CGAL

_IMP_kinematics.IMP_SAXS_HAS_IMP_CONTAINER_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_IMP_CONTAINER = _IMP_kinematics.IMP_SAXS_HAS_IMP_CONTAINER

_IMP_kinematics.IMP_SAXS_HAS_IMP_DISPLAY_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_SAXS_HAS_IMP_DISPLAY

_IMP_kinematics.IMP_SAXS_HAS_IMP_KERNEL_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_IMP_KERNEL = _IMP_kinematics.IMP_SAXS_HAS_IMP_KERNEL

_IMP_kinematics.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

_IMP_kinematics.IMP_SAXS_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_SAXS_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_SAXS_HAS_BOOST_REGEX_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_BOOST_REGEX = _IMP_kinematics.IMP_SAXS_HAS_BOOST_REGEX

_IMP_kinematics.IMP_SAXS_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_SAXS_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_CGAL = _IMP_kinematics.IMP_SAXS_HAS_CGAL

_IMP_kinematics.IMP_SAXS_HAS_HDF5_swigconstant(_IMP_kinematics)
IMP_SAXS_HAS_HDF5 = _IMP_kinematics.IMP_SAXS_HAS_HDF5

_IMP_kinematics.IMPSAXS_SHOW_WARNINGS_swigconstant(_IMP_kinematics)
IMPSAXS_SHOW_WARNINGS = _IMP_kinematics.IMPSAXS_SHOW_WARNINGS
import IMP.saxs

_IMP_kinematics.IMP_KINEMATICS_HAS_IMP_CGAL_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_IMP_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_CGAL

_IMP_kinematics.IMP_KINEMATICS_HAS_IMP_DISPLAY_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_DISPLAY

_IMP_kinematics.IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR

_IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_FILESYSTEM

_IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS

_IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_RANDOM_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_RANDOM

_IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_REGEX_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_BOOST_REGEX = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_REGEX

_IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_SYSTEM_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_SYSTEM

_IMP_kinematics.IMP_KINEMATICS_HAS_CGAL_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_CGAL

_IMP_kinematics.IMP_KINEMATICS_HAS_HDF5_swigconstant(_IMP_kinematics)
IMP_KINEMATICS_HAS_HDF5 = _IMP_kinematics.IMP_KINEMATICS_HAS_HDF5

_IMP_kinematics.IMPKINEMATICS_SHOW_WARNINGS_swigconstant(_IMP_kinematics)
IMPKINEMATICS_SHOW_WARNINGS = _IMP_kinematics.IMPKINEMATICS_SHOW_WARNINGS

_object_types.append("Joint")


def _object_cast_to_Joint(o):
    """_object_cast_to_Joint(Object o) -> Joint"""
    return _IMP_kinematics._object_cast_to_Joint(o)

_object_types.append("TransformationJoint")


def _object_cast_to_TransformationJoint(o):
    """_object_cast_to_TransformationJoint(Object o) -> TransformationJoint"""
    return _IMP_kinematics._object_cast_to_TransformationJoint(o)

_object_types.append("RevoluteJoint")


def _object_cast_to_RevoluteJoint(o):
    """_object_cast_to_RevoluteJoint(Object o) -> RevoluteJoint"""
    return _IMP_kinematics._object_cast_to_RevoluteJoint(o)

_object_types.append("DihedralAngleRevoluteJoint")


def _object_cast_to_DihedralAngleRevoluteJoint(o):
    """_object_cast_to_DihedralAngleRevoluteJoint(Object o) -> DihedralAngleRevoluteJoint"""
    return _IMP_kinematics._object_cast_to_DihedralAngleRevoluteJoint(o)

_object_types.append("BondAngleRevoluteJoint")


def _object_cast_to_BondAngleRevoluteJoint(o):
    """_object_cast_to_BondAngleRevoluteJoint(Object o) -> BondAngleRevoluteJoint"""
    return _IMP_kinematics._object_cast_to_BondAngleRevoluteJoint(o)

_object_types.append("PrismaticJoint")


def _object_cast_to_PrismaticJoint(o):
    """_object_cast_to_PrismaticJoint(Object o) -> PrismaticJoint"""
    return _IMP_kinematics._object_cast_to_PrismaticJoint(o)

_object_types.append("KinematicForest")


def _object_cast_to_KinematicForest(o):
    """_object_cast_to_KinematicForest(Object o) -> KinematicForest"""
    return _IMP_kinematics._object_cast_to_KinematicForest(o)

_object_types.append("KinematicForestScoreState")


def _object_cast_to_KinematicForestScoreState(o):
    """_object_cast_to_KinematicForestScoreState(Object o) -> KinematicForestScoreState"""
    return _IMP_kinematics._object_cast_to_KinematicForestScoreState(o)

_object_types.append("CompositeJoint")


def _object_cast_to_CompositeJoint(o):
    """_object_cast_to_CompositeJoint(Object o) -> CompositeJoint"""
    return _IMP_kinematics._object_cast_to_CompositeJoint(o)

_object_types.append("RevoluteJointMover")


def _object_cast_to_RevoluteJointMover(o):
    """_object_cast_to_RevoluteJointMover(Object o) -> RevoluteJointMover"""
    return _IMP_kinematics._object_cast_to_RevoluteJointMover(o)

_object_types.append("DOF")


def _object_cast_to_DOF(o):
    """_object_cast_to_DOF(Object o) -> DOF"""
    return _IMP_kinematics._object_cast_to_DOF(o)

DOFValuesList=list
_plural_types.append("DOFValuesList")
_value_types.append("DOFValues")


DirectionalDOFs=list
_plural_types.append("DirectionalDOFs")
_value_types.append("DirectionalDOF")


_object_types.append("DOFsSampler")


def _object_cast_to_DOFsSampler(o):
    """_object_cast_to_DOFsSampler(Object o) -> DOFsSampler"""
    return _IMP_kinematics._object_cast_to_DOFsSampler(o)

_object_types.append("UniformBackboneSampler")


def _object_cast_to_UniformBackboneSampler(o):
    """_object_cast_to_UniformBackboneSampler(Object o) -> UniformBackboneSampler"""
    return _IMP_kinematics._object_cast_to_UniformBackboneSampler(o)
class Joint(IMP.Object):
    """Proxy of C++ IMP::kinematics::Joint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def get_version_info(self):
        """get_version_info(Joint self) -> VersionInfo"""
        return _IMP_kinematics.Joint_get_version_info(self)


    def __init__(self, parent, child):
        """__init__(IMP::kinematics::Joint self, RigidBody parent, RigidBody child) -> Joint"""
        this = _IMP_kinematics.new_Joint(parent, child)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_owner_kf(self):
        """get_owner_kf(Joint self) -> KinematicForest"""
        return _IMP_kinematics.Joint_get_owner_kf(self)


    def get_transformation_child_to_parent(self):
        """get_transformation_child_to_parent(Joint self) -> Transformation3D"""
        return _IMP_kinematics.Joint_get_transformation_child_to_parent(self)


    def get_parent_node(self):
        """get_parent_node(Joint self) -> RigidBody"""
        return _IMP_kinematics.Joint_get_parent_node(self)


    def get_child_node(self):
        """get_child_node(Joint self) -> RigidBody"""
        return _IMP_kinematics.Joint_get_child_node(self)


    def __str__(self):
        """__str__(Joint self) -> std::string"""
        return _IMP_kinematics.Joint___str__(self)


    def __repr__(self):
        """__repr__(Joint self) -> std::string"""
        return _IMP_kinematics.Joint___repr__(self)


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

Joint_swigregister = _IMP_kinematics.Joint_swigregister
Joint_swigregister(Joint)

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

    def __init__(self, parent, child):
        """__init__(IMP::kinematics::TransformationJoint self, RigidBody parent, RigidBody child) -> TransformationJoint"""
        this = _IMP_kinematics.new_TransformationJoint(parent, child)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_transformation_child_to_parent(self, transformation):
        """set_transformation_child_to_parent(TransformationJoint self, Transformation3D transformation)"""
        return _IMP_kinematics.TransformationJoint_set_transformation_child_to_parent(self, transformation)


    def __str__(self):
        """__str__(TransformationJoint self) -> std::string"""
        return _IMP_kinematics.TransformationJoint___str__(self)


    def __repr__(self):
        """__repr__(TransformationJoint self) -> std::string"""
        return _IMP_kinematics.TransformationJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_TransformationJoint
    __del__ = lambda self: None
TransformationJoint_swigregister = _IMP_kinematics.TransformationJoint_swigregister
TransformationJoint_swigregister(TransformationJoint)

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

    def __init__(self, *args):
        """
        __init__(IMP::kinematics::PrismaticJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b) -> PrismaticJoint
        __init__(IMP::kinematics::PrismaticJoint self, RigidBody parent, RigidBody child) -> PrismaticJoint
        """
        this = _IMP_kinematics.new_PrismaticJoint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_length(self):
        """get_length(PrismaticJoint self) -> double"""
        return _IMP_kinematics.PrismaticJoint_get_length(self)


    def set_length(self, l):
        """set_length(PrismaticJoint self, double l)"""
        return _IMP_kinematics.PrismaticJoint_set_length(self, l)


    def __str__(self):
        """__str__(PrismaticJoint self) -> std::string"""
        return _IMP_kinematics.PrismaticJoint___str__(self)


    def __repr__(self):
        """__repr__(PrismaticJoint self) -> std::string"""
        return _IMP_kinematics.PrismaticJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_PrismaticJoint
    __del__ = lambda self: None
PrismaticJoint_swigregister = _IMP_kinematics.PrismaticJoint_swigregister
PrismaticJoint_swigregister(PrismaticJoint)

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

    def __init__(self, *args):
        """
        __init__(IMP::kinematics::CompositeJoint self, RigidBody parent, RigidBody child, IMP::kinematics::Joints joints) -> CompositeJoint
        __init__(IMP::kinematics::CompositeJoint self, RigidBody parent, RigidBody child) -> CompositeJoint
        """
        this = _IMP_kinematics.new_CompositeJoint(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_downstream_joint(self, j):
        """add_downstream_joint(CompositeJoint self, Joint j)"""
        return _IMP_kinematics.CompositeJoint_add_downstream_joint(self, j)


    def add_upstream_joint(self, j):
        """add_upstream_joint(CompositeJoint self, Joint j)"""
        return _IMP_kinematics.CompositeJoint_add_upstream_joint(self, j)


    def set_joints(self, joints):
        """set_joints(CompositeJoint self, IMP::kinematics::Joints joints)"""
        return _IMP_kinematics.CompositeJoint_set_joints(self, joints)


    def get_inner_joints(self):
        """get_inner_joints(CompositeJoint self) -> IMP::kinematics::Joints const &"""
        return _IMP_kinematics.CompositeJoint_get_inner_joints(self)


    def __str__(self):
        """__str__(CompositeJoint self) -> std::string"""
        return _IMP_kinematics.CompositeJoint___str__(self)


    def __repr__(self):
        """__repr__(CompositeJoint self) -> std::string"""
        return _IMP_kinematics.CompositeJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_CompositeJoint
    __del__ = lambda self: None
CompositeJoint_swigregister = _IMP_kinematics.CompositeJoint_swigregister
CompositeJoint_swigregister(CompositeJoint)

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

    def __init__(self, parent, child):
        """__init__(IMP::kinematics::RevoluteJoint self, RigidBody parent, RigidBody child) -> RevoluteJoint"""
        if self.__class__ == RevoluteJoint:
            _self = None
        else:
            _self = self
        this = _IMP_kinematics.new_RevoluteJoint(_self, parent, child)
        try:
            self.this.append(this)
        except:
            self.this = this

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



    __swig_destroy__ = _IMP_kinematics.delete_RevoluteJoint
    __del__ = lambda self: None

    def set_angle(self, angle):
        """set_angle(RevoluteJoint self, double angle)"""
        return _IMP_kinematics.RevoluteJoint_set_angle(self, angle)


    def get_angle(self):
        """get_angle(RevoluteJoint self) -> double"""
        return _IMP_kinematics.RevoluteJoint_get_angle(self)


    def get_rot_axis_origin(self):
        """get_rot_axis_origin(RevoluteJoint self) -> Vector3D"""
        return _IMP_kinematics.RevoluteJoint_get_rot_axis_origin(self)


    def get_rot_axis_unit_vector(self):
        """get_rot_axis_unit_vector(RevoluteJoint self) -> Vector3D"""
        return _IMP_kinematics.RevoluteJoint_get_rot_axis_unit_vector(self)


    def update_child_node_reference_frame(self):
        """update_child_node_reference_frame(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_child_node_reference_frame(self)


    def update_axis_of_rotation_from_cartesian_witnesses(self):
        """update_axis_of_rotation_from_cartesian_witnesses(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_axis_of_rotation_from_cartesian_witnesses(self)


    def get_current_angle_from_cartesian_witnesses(self):
        """get_current_angle_from_cartesian_witnesses(RevoluteJoint self) -> double"""
        return _IMP_kinematics.RevoluteJoint_get_current_angle_from_cartesian_witnesses(self)


    def update_joint_from_cartesian_witnesses(self):
        """update_joint_from_cartesian_witnesses(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_joint_from_cartesian_witnesses(self)


    def get_rotation_about_joint_in_parent_coordinates(self):
        """get_rotation_about_joint_in_parent_coordinates(RevoluteJoint self) -> Transformation3D"""
        return _IMP_kinematics.RevoluteJoint_get_rotation_about_joint_in_parent_coordinates(self)

    angle_ = _swig_property(_IMP_kinematics.RevoluteJoint_angle__get, _IMP_kinematics.RevoluteJoint_angle__set)
    last_updated_angle_ = _swig_property(_IMP_kinematics.RevoluteJoint_last_updated_angle__get, _IMP_kinematics.RevoluteJoint_last_updated_angle__set)
    rot_axis_unit_vector_ = _swig_property(_IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__get, _IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__set)
    rot_axis_origin_ = _swig_property(_IMP_kinematics.RevoluteJoint_rot_axis_origin__get, _IMP_kinematics.RevoluteJoint_rot_axis_origin__set)

    def __str__(self):
        """__str__(RevoluteJoint self) -> std::string"""
        return _IMP_kinematics.RevoluteJoint___str__(self)


    def __repr__(self):
        """__repr__(RevoluteJoint self) -> std::string"""
        return _IMP_kinematics.RevoluteJoint___repr__(self)


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


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

    def __disown__(self):
        self.this.disown()
        _IMP_kinematics.disown_RevoluteJoint(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_do_destroy(self)

RevoluteJoint_swigregister = _IMP_kinematics.RevoluteJoint_swigregister
RevoluteJoint_swigregister(RevoluteJoint)

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

    def __init__(self, parent, child, a, b, c, d):
        """__init__(IMP::kinematics::DihedralAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c, XYZ d) -> DihedralAngleRevoluteJoint"""
        this = _IMP_kinematics.new_DihedralAngleRevoluteJoint(parent, child, a, b, c, d)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_a(self):
        """get_a(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_a(self)


    def get_b(self):
        """get_b(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_b(self)


    def get_c(self):
        """get_c(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_c(self)


    def get_d(self):
        """get_d(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_d(self)


    def __str__(self):
        """__str__(DihedralAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint___str__(self)


    def __repr__(self):
        """__repr__(DihedralAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_DihedralAngleRevoluteJoint
    __del__ = lambda self: None
DihedralAngleRevoluteJoint_swigregister = _IMP_kinematics.DihedralAngleRevoluteJoint_swigregister
DihedralAngleRevoluteJoint_swigregister(DihedralAngleRevoluteJoint)

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

    def __init__(self, parent, child, a, b, c):
        """__init__(IMP::kinematics::BondAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c) -> BondAngleRevoluteJoint"""
        this = _IMP_kinematics.new_BondAngleRevoluteJoint(parent, child, a, b, c)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __str__(self):
        """__str__(BondAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.BondAngleRevoluteJoint___str__(self)


    def __repr__(self):
        """__repr__(BondAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.BondAngleRevoluteJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_BondAngleRevoluteJoint
    __del__ = lambda self: None
BondAngleRevoluteJoint_swigregister = _IMP_kinematics.BondAngleRevoluteJoint_swigregister
BondAngleRevoluteJoint_swigregister(BondAngleRevoluteJoint)

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

    def __init__(self, m, joints, stddev=0.01):
        """
        __init__(IMP::kinematics::RevoluteJointMover self, Model m, IMP::kinematics::RevoluteJoints const & joints, double const stddev=0.01) -> RevoluteJointMover
        __init__(IMP::kinematics::RevoluteJointMover self, Model m, IMP::kinematics::RevoluteJoints const & joints) -> RevoluteJointMover
        """
        this = _IMP_kinematics.new_RevoluteJointMover(m, joints, stddev)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_sigma(self, sigma):
        """set_sigma(RevoluteJointMover self, IMP::Float sigma)"""
        return _IMP_kinematics.RevoluteJointMover_set_sigma(self, sigma)


    def get_sigma(self):
        """get_sigma(RevoluteJointMover self) -> IMP::Float"""
        return _IMP_kinematics.RevoluteJointMover_get_sigma(self)


    def get_version_info(self):
        """get_version_info(RevoluteJointMover self) -> VersionInfo"""
        return _IMP_kinematics.RevoluteJointMover_get_version_info(self)


    def __str__(self):
        """__str__(RevoluteJointMover self) -> std::string"""
        return _IMP_kinematics.RevoluteJointMover___str__(self)


    def __repr__(self):
        """__repr__(RevoluteJointMover self) -> std::string"""
        return _IMP_kinematics.RevoluteJointMover___repr__(self)


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

RevoluteJointMover_swigregister = _IMP_kinematics.RevoluteJointMover_swigregister
RevoluteJointMover_swigregister(RevoluteJointMover)

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

    def get_version_info(self):
        """get_version_info(KinematicForest self) -> VersionInfo"""
        return _IMP_kinematics.KinematicForest_get_version_info(self)


    def __init__(self, *args):
        """
        __init__(IMP::kinematics::KinematicForest self, Model m) -> KinematicForest
        __init__(IMP::kinematics::KinematicForest self, Model m, Hierarchy hierarchy) -> KinematicForest
        """
        this = _IMP_kinematics.new_KinematicForest(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def add_edge(self, *args):
        """
        add_edge(KinematicForest self, RigidBody parent, RigidBody child) -> Joint
        add_edge(KinematicForest self, Joint joint)
        """
        return _IMP_kinematics.KinematicForest_add_edge(self, *args)


    def add_rigid_bodies_in_chain(self, rbs):
        """add_rigid_bodies_in_chain(KinematicForest self, IMP::core::RigidBodies rbs)"""
        return _IMP_kinematics.KinematicForest_add_rigid_bodies_in_chain(self, rbs)


    def reset_root(self, new_root):
        """reset_root(KinematicForest self, Particle new_root)"""
        return _IMP_kinematics.KinematicForest_reset_root(self, new_root)


    def update_all_internal_coordinates(self):
        """update_all_internal_coordinates(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_update_all_internal_coordinates(self)


    def update_all_external_coordinates(self):
        """update_all_external_coordinates(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_update_all_external_coordinates(self)


    def get_ordered_joints(self):
        """get_ordered_joints(KinematicForest self) -> IMP::kinematics::Joints"""
        return _IMP_kinematics.KinematicForest_get_ordered_joints(self)


    def mark_internal_coordinates_changed(self):
        """mark_internal_coordinates_changed(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_mark_internal_coordinates_changed(self)


    def mark_external_coordinates_changed(self):
        """mark_external_coordinates_changed(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_mark_external_coordinates_changed(self)


    def set_coordinates_safe(self, rb, c):
        """set_coordinates_safe(KinematicForest self, RigidBody rb, Vector3D c)"""
        return _IMP_kinematics.KinematicForest_set_coordinates_safe(self, rb, c)


    def get_coordinates_safe(self, rb):
        """get_coordinates_safe(KinematicForest self, RigidBody rb) -> Vector3D"""
        return _IMP_kinematics.KinematicForest_get_coordinates_safe(self, rb)


    def get_is_member(self, rb):
        """get_is_member(KinematicForest self, RigidBody rb) -> bool"""
        return _IMP_kinematics.KinematicForest_get_is_member(self, rb)


    def get_reference_frame_safe(self, rb):
        """get_reference_frame_safe(KinematicForest self, RigidBody rb) -> ReferenceFrame3D"""
        return _IMP_kinematics.KinematicForest_get_reference_frame_safe(self, rb)


    def set_reference_frame_safe(self, rb, r):
        """set_reference_frame_safe(KinematicForest self, RigidBody rb, ReferenceFrame3D r)"""
        return _IMP_kinematics.KinematicForest_set_reference_frame_safe(self, rb, r)


    def __str__(self):
        """__str__(KinematicForest self) -> std::string"""
        return _IMP_kinematics.KinematicForest___str__(self)


    def __repr__(self):
        """__repr__(KinematicForest self) -> std::string"""
        return _IMP_kinematics.KinematicForest___repr__(self)


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

KinematicForest_swigregister = _IMP_kinematics.KinematicForest_swigregister
KinematicForest_swigregister(KinematicForest)

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

    def get_version_info(self):
        """get_version_info(KinematicForestScoreState self) -> VersionInfo"""
        return _IMP_kinematics.KinematicForestScoreState_get_version_info(self)


    def __init__(self, kf, rbs, atoms):
        """__init__(IMP::kinematics::KinematicForestScoreState self, KinematicForest kf, IMP::core::RigidBodies rbs, IMP::ParticlesTemp atoms) -> KinematicForestScoreState"""
        this = _IMP_kinematics.new_KinematicForestScoreState(kf, rbs, atoms)
        try:
            self.this.append(this)
        except:
            self.this = this

    def do_before_evaluate(self):
        """do_before_evaluate(KinematicForestScoreState self)"""
        return _IMP_kinematics.KinematicForestScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(KinematicForestScoreState self, DerivativeAccumulator da)"""
        return _IMP_kinematics.KinematicForestScoreState_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(KinematicForestScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kinematics.KinematicForestScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(KinematicForestScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kinematics.KinematicForestScoreState_do_get_outputs(self)


    def __str__(self):
        """__str__(KinematicForestScoreState self) -> std::string"""
        return _IMP_kinematics.KinematicForestScoreState___str__(self)


    def __repr__(self):
        """__repr__(KinematicForestScoreState self) -> std::string"""
        return _IMP_kinematics.KinematicForestScoreState___repr__(self)


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

KinematicForestScoreState_swigregister = _IMP_kinematics.KinematicForestScoreState_swigregister
KinematicForestScoreState_swigregister(KinematicForestScoreState)

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

    def get_version_info(self):
        """get_version_info(DOF self) -> VersionInfo"""
        return _IMP_kinematics.DOF_get_version_info(self)


    def __init__(self, *args):
        """
        __init__(IMP::kinematics::DOF self, double v) -> DOF
        __init__(IMP::kinematics::DOF self, double v, double min, double max, double step_size) -> DOF
        """
        this = _IMP_kinematics.new_DOF(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_value(self):
        """get_value(DOF self) -> double"""
        return _IMP_kinematics.DOF_get_value(self)


    def set_value(self, v):
        """set_value(DOF self, double v)"""
        return _IMP_kinematics.DOF_set_value(self, v)


    def get_range(self):
        """get_range(DOF self) -> std::pair< double,double >"""
        return _IMP_kinematics.DOF_get_range(self)


    def set_range(self, range):
        """set_range(DOF self, std::pair< double,double > range)"""
        return _IMP_kinematics.DOF_set_range(self, range)


    def get_step_size(self):
        """get_step_size(DOF self) -> double"""
        return _IMP_kinematics.DOF_get_step_size(self)


    def set_step_size(self, step_size):
        """set_step_size(DOF self, double step_size)"""
        return _IMP_kinematics.DOF_set_step_size(self, step_size)


    def get_number_of_steps(self, *args):
        """
        get_number_of_steps(DOF self, double value) -> int
        get_number_of_steps(DOF self, double value1, double value2) -> int
        """
        return _IMP_kinematics.DOF_get_number_of_steps(self, *args)


    def __str__(self):
        """__str__(DOF self) -> std::string"""
        return _IMP_kinematics.DOF___str__(self)


    def __repr__(self):
        """__repr__(DOF self) -> std::string"""
        return _IMP_kinematics.DOF___repr__(self)


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

DOF_swigregister = _IMP_kinematics.DOF_swigregister
DOF_swigregister(DOF)

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

    def __init__(self, *args):
        """
        __init__(IMP::kinematics::DOFValues self, IMP::kinematics::DOFs const & dofs) -> DOFValues
        __init__(IMP::kinematics::DOFValues self) -> DOFValues
        """
        this = _IMP_kinematics.new_DOFValues(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_distance2(self, *args):
        """
        get_distance2(DOFValues self, DOFValues other_dof_values) -> double
        get_distance2(DOFValues self, DOFValues other_dof_values, std::vector< bool,std::allocator< bool > > const & active_dofs) -> double
        """
        return _IMP_kinematics.DOFValues_get_distance2(self, *args)


    def get_distance(self, *args):
        """
        get_distance(DOFValues self, DOFValues other_dof_values) -> double
        get_distance(DOFValues self, DOFValues other_dof_values, std::vector< bool,std::allocator< bool > > const & active_dofs) -> double
        """
        return _IMP_kinematics.DOFValues_get_distance(self, *args)


    def show(self, *args):
        """
        show(DOFValues self, _ostream out)
        show(DOFValues self)
        """
        return _IMP_kinematics.DOFValues_show(self, *args)


    def __str__(self):
        """__str__(DOFValues self) -> std::string"""
        return _IMP_kinematics.DOFValues___str__(self)


    def __repr__(self):
        """__repr__(DOFValues self) -> std::string"""
        return _IMP_kinematics.DOFValues___repr__(self)

    __swig_destroy__ = _IMP_kinematics.delete_DOFValues
    __del__ = lambda self: None
DOFValues_swigregister = _IMP_kinematics.DOFValues_swigregister
DOFValues_swigregister(DOFValues)

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

    def __init__(self, dofs):
        """__init__(IMP::kinematics::DirectionalDOF self, IMP::kinematics::DOFs const & dofs) -> DirectionalDOF"""
        this = _IMP_kinematics.new_DirectionalDOF(dofs)
        try:
            self.this.append(this)
        except:
            self.this = this

    def set_end_points(self, q1, q2):
        """set_end_points(DirectionalDOF self, DOFValues q1, DOFValues q2)"""
        return _IMP_kinematics.DirectionalDOF_set_end_points(self, q1, q2)


    def get_dofs_values(self):
        """get_dofs_values(DirectionalDOF self) -> DOFValues"""
        return _IMP_kinematics.DirectionalDOF_get_dofs_values(self)


    def get_value(self):
        """get_value(DirectionalDOF self) -> double"""
        return _IMP_kinematics.DirectionalDOF_get_value(self)


    def show(self, *args):
        """
        show(DirectionalDOF self, _ostream out)
        show(DirectionalDOF self)
        """
        return _IMP_kinematics.DirectionalDOF_show(self, *args)


    def __str__(self):
        """__str__(DirectionalDOF self) -> std::string"""
        return _IMP_kinematics.DirectionalDOF___str__(self)


    def __repr__(self):
        """__repr__(DirectionalDOF self) -> std::string"""
        return _IMP_kinematics.DirectionalDOF___repr__(self)

    __swig_destroy__ = _IMP_kinematics.delete_DirectionalDOF
    __del__ = lambda self: None
DirectionalDOF_swigregister = _IMP_kinematics.DirectionalDOF_swigregister
DirectionalDOF_swigregister(DirectionalDOF)

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

    def get_type_name(self):
        """get_type_name(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler_get_type_name(self)


    def get_version_info(self):
        """get_version_info(DOFsSampler self) -> VersionInfo"""
        return _IMP_kinematics.DOFsSampler_get_version_info(self)


    def __init__(self, dofs):
        """__init__(IMP::kinematics::DOFsSampler self, IMP::kinematics::DOFs dofs) -> DOFsSampler"""
        if self.__class__ == DOFsSampler:
            _self = None
        else:
            _self = self
        this = _IMP_kinematics.new_DOFsSampler(_self, dofs)
        try:
            self.this.append(this)
        except:
            self.this = this

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




    def get_sample(self):
        """get_sample(DOFsSampler self) -> DOFValues"""
        return _IMP_kinematics.DOFsSampler_get_sample(self)


    def apply(self, values):
        """apply(DOFsSampler self, DOFValues values)"""
        return _IMP_kinematics.DOFsSampler_apply(self, values)


    def apply_last_sample(self):
        """apply_last_sample(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_apply_last_sample(self)


    def sample_and_apply(self):
        """sample_and_apply(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_sample_and_apply(self)


    def get_dofs(self):
        """get_dofs(DOFsSampler self) -> IMP::kinematics::DOFs const &"""
        return _IMP_kinematics.DOFsSampler_get_dofs(self)


    def get_dof(self, i):
        """get_dof(DOFsSampler self, unsigned int i) -> DOF"""
        return _IMP_kinematics.DOFsSampler_get_dof(self, i)


    def get_number_of_dofs(self):
        """get_number_of_dofs(DOFsSampler self) -> unsigned int"""
        return _IMP_kinematics.DOFsSampler_get_number_of_dofs(self)


    def do_get_sample(self):
        """do_get_sample(DOFsSampler self) -> DOFValues"""
        return _IMP_kinematics.DOFsSampler_do_get_sample(self)


    def __str__(self):
        """__str__(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler___str__(self)


    def __repr__(self):
        """__repr__(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler___repr__(self)


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


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

    def __disown__(self):
        self.this.disown()
        _IMP_kinematics.disown_DOFsSampler(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_do_destroy(self)

DOFsSampler_swigregister = _IMP_kinematics.DOFsSampler_swigregister
DOFsSampler_swigregister(DOFsSampler)

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

    def __init__(self, joints, dofs):
        """__init__(IMP::kinematics::UniformBackboneSampler self, IMP::kinematics::DihedralAngleRevoluteJoints joints, IMP::kinematics::DOFs dofs) -> UniformBackboneSampler"""
        this = _IMP_kinematics.new_UniformBackboneSampler(joints, dofs)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __str__(self):
        """__str__(UniformBackboneSampler self) -> std::string"""
        return _IMP_kinematics.UniformBackboneSampler___str__(self)


    def __repr__(self):
        """__repr__(UniformBackboneSampler self) -> std::string"""
        return _IMP_kinematics.UniformBackboneSampler___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_UniformBackboneSampler
    __del__ = lambda self: None
UniformBackboneSampler_swigregister = _IMP_kinematics.UniformBackboneSampler_swigregister
UniformBackboneSampler_swigregister(UniformBackboneSampler)


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

def get_example_path(fname):
    """get_example_path(std::string fname) -> std::string"""
    return _IMP_kinematics.get_example_path(fname)

def get_data_path(fname):
    """get_data_path(std::string fname) -> std::string"""
    return _IMP_kinematics.get_data_path(fname)

from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()