kinematics/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.3.0
#
# 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-2024 IMP Inventors. All rights reserved.




from sys import version_info as _swig_python_version_info
import _IMP_kinematics

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class IMP_KINEMATICS_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_KINEMATICS_SwigPyIterator class."""

    thisown = 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register IMP_KINEMATICS_SwigPyIterator in _IMP_kinematics:
_IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_swigregister(IMP_KINEMATICS_SwigPyIterator)

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

IMP_DEBUG = _IMP_kinematics.IMP_DEBUG

IMP_RELEASE = _IMP_kinematics.IMP_RELEASE

IMP_SILENT = _IMP_kinematics.IMP_SILENT

IMP_PROGRESS = _IMP_kinematics.IMP_PROGRESS

IMP_TERSE = _IMP_kinematics.IMP_TERSE

IMP_VERBOSE = _IMP_kinematics.IMP_VERBOSE

IMP_MEMORY = _IMP_kinematics.IMP_MEMORY

IMP_NONE = _IMP_kinematics.IMP_NONE

IMP_USAGE = _IMP_kinematics.IMP_USAGE

IMP_INTERNAL = _IMP_kinematics.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_kinematics.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_kinematics.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kinematics.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_kinematics.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_kinematics.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_kinematics.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kinematics.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_kinematics.IMPKERNEL_SHOW_WARNINGS


import sys
class _DirectorObjects:
    """@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):
    r"""Proxy of C++ std::ostream class."""

    thisown = 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):
        r"""write(_ostream self, char const * osa_buf)"""
        return _IMP_kinematics._ostream_write(self, osa_buf)

# Register _ostream in _IMP_kinematics:
_IMP_kinematics._ostream_swigregister(_ostream)
IMP_C_OPEN_BINARY = _IMP_kinematics.IMP_C_OPEN_BINARY

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_SYSTEM

IMP_CGAL_HAS_NUMPY = _IMP_kinematics.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_kinematics.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_SYSTEM

IMP_ALGEBRA_HAS_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_kinematics.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_kinematics.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_kinematics.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_SYSTEM

IMP_DISPLAY_HAS_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_kinematics.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_kinematics.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_kinematics.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_CORE_HAS_IMP_CGAL = _IMP_kinematics.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_SYSTEM

IMP_CORE_HAS_CGAL = _IMP_kinematics.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_kinematics.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_kinematics.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_kinematics.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_SYSTEM

IMP_CONTAINER_HAS_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_kinematics.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_kinematics.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_kinematics.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_kinematics.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_kinematics.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_kinematics.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
IMP_ATOM_HAS_IMP_CGAL = _IMP_kinematics.IMP_ATOM_HAS_IMP_CGAL

IMP_ATOM_HAS_IMP_KERNEL = _IMP_kinematics.IMP_ATOM_HAS_IMP_KERNEL

IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

IMP_ATOM_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_RANDOM

IMP_ATOM_HAS_BOOST_REGEX = _IMP_kinematics.IMP_ATOM_HAS_BOOST_REGEX

IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_SYSTEM

IMP_ATOM_HAS_CGAL = _IMP_kinematics.IMP_ATOM_HAS_CGAL

IMP_ATOM_HAS_HDF5 = _IMP_kinematics.IMP_ATOM_HAS_HDF5

IMP_ATOM_HAS_NUMPY = _IMP_kinematics.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_kinematics.IMP_ATOM_HAS_PYTHON_IHM

IMPATOM_SHOW_WARNINGS = _IMP_kinematics.IMPATOM_SHOW_WARNINGS

IMP_ATOM_TYPE_INDEX = _IMP_kinematics.IMP_ATOM_TYPE_INDEX

IMP_RESIDUE_TYPE_INDEX = _IMP_kinematics.IMP_RESIDUE_TYPE_INDEX

IMP_HIERARCHY_TYPE_INDEX = _IMP_kinematics.IMP_HIERARCHY_TYPE_INDEX

IMP_CHAIN_TYPE_INDEX = _IMP_kinematics.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_SAXS_HAS_IMP_CGAL = _IMP_kinematics.IMP_SAXS_HAS_IMP_CGAL

IMP_SAXS_HAS_IMP_CONTAINER = _IMP_kinematics.IMP_SAXS_HAS_IMP_CONTAINER

IMP_SAXS_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_SAXS_HAS_IMP_DISPLAY

IMP_SAXS_HAS_IMP_KERNEL = _IMP_kinematics.IMP_SAXS_HAS_IMP_KERNEL

IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_FILESYSTEM

IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

IMP_SAXS_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_RANDOM

IMP_SAXS_HAS_BOOST_REGEX = _IMP_kinematics.IMP_SAXS_HAS_BOOST_REGEX

IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_SYSTEM

IMP_SAXS_HAS_CGAL = _IMP_kinematics.IMP_SAXS_HAS_CGAL

IMP_SAXS_HAS_HDF5 = _IMP_kinematics.IMP_SAXS_HAS_HDF5

IMP_SAXS_HAS_NUMPY = _IMP_kinematics.IMP_SAXS_HAS_NUMPY

IMP_SAXS_HAS_PYTHON_IHM = _IMP_kinematics.IMP_SAXS_HAS_PYTHON_IHM

IMPSAXS_SHOW_WARNINGS = _IMP_kinematics.IMPSAXS_SHOW_WARNINGS

import IMP.saxs
IMP_KINEMATICS_HAS_IMP_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_CGAL

IMP_KINEMATICS_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_DISPLAY

IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR

IMP_KINEMATICS_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_FILESYSTEM

IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS

IMP_KINEMATICS_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_RANDOM

IMP_KINEMATICS_HAS_BOOST_REGEX = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_REGEX

IMP_KINEMATICS_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_SYSTEM

IMP_KINEMATICS_HAS_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_CGAL

IMP_KINEMATICS_HAS_HDF5 = _IMP_kinematics.IMP_KINEMATICS_HAS_HDF5

IMP_KINEMATICS_HAS_NUMPY = _IMP_kinematics.IMP_KINEMATICS_HAS_NUMPY

IMP_KINEMATICS_HAS_PYTHON_IHM = _IMP_kinematics.IMP_KINEMATICS_HAS_PYTHON_IHM

IMPKINEMATICS_SHOW_WARNINGS = _IMP_kinematics.IMPKINEMATICS_SHOW_WARNINGS


_object_types.append("Joint")


def _object_cast_to_Joint(o):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_object_cast_to_RevoluteJointMover(Object o) -> RevoluteJointMover"""
    return _IMP_kinematics._object_cast_to_RevoluteJointMover(o)

_object_types.append("DihedralMover")


def _object_cast_to_DihedralMover(o):
    r"""_object_cast_to_DihedralMover(Object o) -> DihedralMover"""
    return _IMP_kinematics._object_cast_to_DihedralMover(o)

_object_types.append("DOF")


def _object_cast_to_DOF(o):
    r"""_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")


_object_types.append("DirectionalDOF")


def _object_cast_to_DirectionalDOF(o):
    r"""_object_cast_to_DirectionalDOF(Object o) -> DirectionalDOF"""
    return _IMP_kinematics._object_cast_to_DirectionalDOF(o)

_object_types.append("DOFsSampler")


def _object_cast_to_DOFsSampler(o):
    r"""_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):
    r"""_object_cast_to_UniformBackboneSampler(Object o) -> UniformBackboneSampler"""
    return _IMP_kinematics._object_cast_to_UniformBackboneSampler(o)

_object_types.append("FibrilSampler")


def _object_cast_to_FibrilSampler(o):
    r"""_object_cast_to_FibrilSampler(Object o) -> FibrilSampler"""
    return _IMP_kinematics._object_cast_to_FibrilSampler(o)

_object_types.append("ProteinKinematics")


def _object_cast_to_ProteinKinematics(o):
    r"""_object_cast_to_ProteinKinematics(Object o) -> ProteinKinematics"""
    return _IMP_kinematics._object_cast_to_ProteinKinematics(o)

_object_types.append("LocalPlanner")


def _object_cast_to_LocalPlanner(o):
    r"""_object_cast_to_LocalPlanner(Object o) -> LocalPlanner"""
    return _IMP_kinematics._object_cast_to_LocalPlanner(o)

_object_types.append("PathLocalPlanner")


def _object_cast_to_PathLocalPlanner(o):
    r"""_object_cast_to_PathLocalPlanner(Object o) -> PathLocalPlanner"""
    return _IMP_kinematics._object_cast_to_PathLocalPlanner(o)

_object_types.append("RRT")


def _object_cast_to_RRT(o):
    r"""_object_cast_to_RRT(Object o) -> RRT"""
    return _IMP_kinematics._object_cast_to_RRT(o)
class Joint(IMP.Object):
    r"""Proxy of C++ IMP::kinematics::Joint class."""

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

    def get_version_info(self):
        r"""get_version_info(Joint self) -> VersionInfo"""
        return _IMP_kinematics.Joint_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_Joint

    def __init__(self, parent, child):
        r"""__init__(Joint self, RigidBody parent, RigidBody child) -> Joint"""
        _IMP_kinematics.Joint_swiginit(self, _IMP_kinematics.new_Joint(parent, child))

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

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

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

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

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

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

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


# Register Joint in _IMP_kinematics:
_IMP_kinematics.Joint_swigregister(Joint)
class TransformationJoint(Joint):
    r"""Proxy of C++ IMP::kinematics::TransformationJoint class."""

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

    def __init__(self, parent, child):
        r"""__init__(TransformationJoint self, RigidBody parent, RigidBody child) -> TransformationJoint"""
        _IMP_kinematics.TransformationJoint_swiginit(self, _IMP_kinematics.new_TransformationJoint(parent, child))

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

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

    def __repr__(self):
        r"""__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

# Register TransformationJoint in _IMP_kinematics:
_IMP_kinematics.TransformationJoint_swigregister(TransformationJoint)
class PrismaticJoint(Joint):
    r"""Proxy of C++ IMP::kinematics::PrismaticJoint class."""

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

    def __init__(self, *args):
        r"""
        __init__(PrismaticJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b) -> PrismaticJoint
        __init__(PrismaticJoint self, RigidBody parent, RigidBody child) -> PrismaticJoint
        """
        _IMP_kinematics.PrismaticJoint_swiginit(self, _IMP_kinematics.new_PrismaticJoint(*args))

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

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

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

    def __repr__(self):
        r"""__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

# Register PrismaticJoint in _IMP_kinematics:
_IMP_kinematics.PrismaticJoint_swigregister(PrismaticJoint)
class CompositeJoint(Joint):
    r"""Proxy of C++ IMP::kinematics::CompositeJoint class."""

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

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

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

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

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

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

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

    def __repr__(self):
        r"""__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

# Register CompositeJoint in _IMP_kinematics:
_IMP_kinematics.CompositeJoint_swigregister(CompositeJoint)
class RevoluteJoint(Joint):
    r"""Proxy of C++ IMP::kinematics::RevoluteJoint class."""

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

    def __init__(self, parent, child):
        r"""__init__(RevoluteJoint self, RigidBody parent, RigidBody child) -> RevoluteJoint"""
        if self.__class__ == RevoluteJoint:
            _self = None
        else:
            _self = self
        _IMP_kinematics.RevoluteJoint_swiginit(self, _IMP_kinematics.new_RevoluteJoint(_self, parent, child))

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



    __swig_destroy__ = _IMP_kinematics.delete_RevoluteJoint

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

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

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

    def get_rot_axis_unit_vector(self):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""get_rotation_about_joint_in_parent_coordinates(RevoluteJoint self) -> Transformation3D"""
        return _IMP_kinematics.RevoluteJoint_get_rotation_about_joint_in_parent_coordinates(self)
    angle_ = property(_IMP_kinematics.RevoluteJoint_angle__get, _IMP_kinematics.RevoluteJoint_angle__set, doc=r"""angle_ : double""")
    last_updated_angle_ = property(_IMP_kinematics.RevoluteJoint_last_updated_angle__get, _IMP_kinematics.RevoluteJoint_last_updated_angle__set, doc=r"""last_updated_angle_ : double""")
    rot_axis_unit_vector_ = property(_IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__get, _IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__set, doc=r"""rot_axis_unit_vector_ : IMP::algebra::Vector3D""")
    rot_axis_origin_ = property(_IMP_kinematics.RevoluteJoint_rot_axis_origin__get, _IMP_kinematics.RevoluteJoint_rot_axis_origin__set, doc=r"""rot_axis_origin_ : IMP::algebra::Vector3D""")

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

    def __repr__(self):
        r"""__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):
        r"""do_destroy(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_do_destroy(self)

# Register RevoluteJoint in _IMP_kinematics:
_IMP_kinematics.RevoluteJoint_swigregister(RevoluteJoint)
class DihedralAngleRevoluteJoint(RevoluteJoint):
    r"""Proxy of C++ IMP::kinematics::DihedralAngleRevoluteJoint class."""

    thisown = 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):
        r"""__init__(DihedralAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c, XYZ d) -> DihedralAngleRevoluteJoint"""
        _IMP_kinematics.DihedralAngleRevoluteJoint_swiginit(self, _IMP_kinematics.new_DihedralAngleRevoluteJoint(parent, child, a, b, c, d))

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

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

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

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

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

    def __repr__(self):
        r"""__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

# Register DihedralAngleRevoluteJoint in _IMP_kinematics:
_IMP_kinematics.DihedralAngleRevoluteJoint_swigregister(DihedralAngleRevoluteJoint)
class BondAngleRevoluteJoint(RevoluteJoint):
    r"""Proxy of C++ IMP::kinematics::BondAngleRevoluteJoint class."""

    thisown = 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):
        r"""__init__(BondAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c) -> BondAngleRevoluteJoint"""
        _IMP_kinematics.BondAngleRevoluteJoint_swiginit(self, _IMP_kinematics.new_BondAngleRevoluteJoint(parent, child, a, b, c))

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

    def __repr__(self):
        r"""__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

# Register BondAngleRevoluteJoint in _IMP_kinematics:
_IMP_kinematics.BondAngleRevoluteJoint_swigregister(BondAngleRevoluteJoint)
class RevoluteJointMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::kinematics::RevoluteJointMover class."""

    thisown = 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):
        r"""__init__(RevoluteJointMover self, Model m, IMP::kinematics::RevoluteJoints const & joints, double const stddev=0.01) -> RevoluteJointMover"""
        _IMP_kinematics.RevoluteJointMover_swiginit(self, _IMP_kinematics.new_RevoluteJointMover(m, joints, stddev))

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

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

    def get_version_info(self):
        r"""get_version_info(RevoluteJointMover self) -> VersionInfo"""
        return _IMP_kinematics.RevoluteJointMover_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_RevoluteJointMover

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

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

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


# Register RevoluteJointMover in _IMP_kinematics:
_IMP_kinematics.RevoluteJointMover_swigregister(RevoluteJointMover)
class DihedralMover(IMP.core.MonteCarloMover):
    r"""Proxy of C++ IMP::kinematics::DihedralMover class."""

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

    def __init__(self, m, joints, max_rot=0.1):
        r"""__init__(DihedralMover self, Model m, IMP::kinematics::RevoluteJoints const & joints, double const max_rot=0.1) -> DihedralMover"""
        _IMP_kinematics.DihedralMover_swiginit(self, _IMP_kinematics.new_DihedralMover(m, joints, max_rot))

    def get_version_info(self):
        r"""get_version_info(DihedralMover self) -> VersionInfo"""
        return _IMP_kinematics.DihedralMover_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_DihedralMover

    def __str__(self):
        r"""__str__(DihedralMover self) -> std::string"""
        return _IMP_kinematics.DihedralMover___str__(self)

    def __repr__(self):
        r"""__repr__(DihedralMover self) -> std::string"""
        return _IMP_kinematics.DihedralMover___repr__(self)

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


# Register DihedralMover in _IMP_kinematics:
_IMP_kinematics.DihedralMover_swigregister(DihedralMover)
class KinematicForest(IMP.Object):
    r"""Proxy of C++ IMP::kinematics::KinematicForest class."""

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

    def get_version_info(self):
        r"""get_version_info(KinematicForest self) -> VersionInfo"""
        return _IMP_kinematics.KinematicForest_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_KinematicForest

    def __init__(self, *args):
        r"""
        __init__(KinematicForest self, Model m) -> KinematicForest
        __init__(KinematicForest self, Model m, Hierarchy hierarchy) -> KinematicForest
        """
        _IMP_kinematics.KinematicForest_swiginit(self, _IMP_kinematics.new_KinematicForest(*args))

    def add_edge(self, *args):
        r"""
        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):
        r"""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):
        r"""reset_root(KinematicForest self, Particle new_root)"""
        return _IMP_kinematics.KinematicForest_reset_root(self, new_root)

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

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

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

    def transform_safe(self, tr):
        r"""transform_safe(KinematicForest self, Transformation3D tr)"""
        return _IMP_kinematics.KinematicForest_transform_safe(self, tr)

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

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

    def set_coordinates_safe(self, rb, c):
        r"""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):
        r"""get_coordinates_safe(KinematicForest self, RigidBody rb) -> Vector3D"""
        return _IMP_kinematics.KinematicForest_get_coordinates_safe(self, rb)

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

    def get_reference_frame_safe(self, rb):
        r"""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):
        r"""set_reference_frame_safe(KinematicForest self, RigidBody rb, ReferenceFrame3D r)"""
        return _IMP_kinematics.KinematicForest_set_reference_frame_safe(self, rb, r)

    def apply_transform_safely(self, tr):
        r"""apply_transform_safely(KinematicForest self, Transformation3D tr)"""
        return _IMP_kinematics.KinematicForest_apply_transform_safely(self, tr)

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

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

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


# Register KinematicForest in _IMP_kinematics:
_IMP_kinematics.KinematicForest_swigregister(KinematicForest)
class KinematicForestScoreState(IMP.ScoreState):
    r"""Proxy of C++ IMP::kinematics::KinematicForestScoreState class."""

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

    def get_version_info(self):
        r"""get_version_info(KinematicForestScoreState self) -> VersionInfo"""
        return _IMP_kinematics.KinematicForestScoreState_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_KinematicForestScoreState

    def __init__(self, kf, rbs, atoms):
        r"""__init__(KinematicForestScoreState self, KinematicForest kf, IMP::core::RigidBodies rbs, IMP::ParticlesTemp atoms) -> KinematicForestScoreState"""
        _IMP_kinematics.KinematicForestScoreState_swiginit(self, _IMP_kinematics.new_KinematicForestScoreState(kf, rbs, atoms))

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

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

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

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

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

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

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


# Register KinematicForestScoreState in _IMP_kinematics:
_IMP_kinematics.KinematicForestScoreState_swigregister(KinematicForestScoreState)
class DOF(IMP.Object):
    r"""Proxy of C++ IMP::kinematics::DOF class."""

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

    def get_version_info(self):
        r"""get_version_info(DOF self) -> VersionInfo"""
        return _IMP_kinematics.DOF_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_DOF

    def __init__(self, *args):
        r"""
        __init__(DOF self, double v) -> DOF
        __init__(DOF self, double v, double min, double max, double step_size) -> DOF
        """
        _IMP_kinematics.DOF_swiginit(self, _IMP_kinematics.new_DOF(*args))

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

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

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

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

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

    def set_step_size(self, step_size):
        r"""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):
        r"""
        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):
        r"""__str__(DOF self) -> std::string"""
        return _IMP_kinematics.DOF___str__(self)

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

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


# Register DOF in _IMP_kinematics:
_IMP_kinematics.DOF_swigregister(DOF)
class DOFValues(IMP.saxs.DistBase):
    r"""Proxy of C++ IMP::kinematics::DOFValues class."""

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

    def __init__(self, *args):
        r"""
        __init__(DOFValues self, IMP::kinematics::DOFs const & dofs) -> DOFValues
        __init__(DOFValues self) -> DOFValues
        """
        _IMP_kinematics.DOFValues_swiginit(self, _IMP_kinematics.new_DOFValues(*args))

    def get_distance2(self, *args):
        r"""
        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):
        r"""
        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):
        r"""show(DOFValues self, _ostream out=std::cout)"""
        return _IMP_kinematics.DOFValues_show(self, *args)

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(DOFValues self) -> PyObject *"""
        return _IMP_kinematics.DOFValues__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(DOFValues self, PyObject * p)"""
        return _IMP_kinematics.DOFValues__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_kinematics.delete_DOFValues

# Register DOFValues in _IMP_kinematics:
_IMP_kinematics.DOFValues_swigregister(DOFValues)
class DirectionalDOF(IMP.Object):
    r"""Proxy of C++ IMP::kinematics::DirectionalDOF class."""

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

    def __init__(self, dofs):
        r"""__init__(DirectionalDOF self, IMP::kinematics::DOFs const & dofs) -> DirectionalDOF"""
        _IMP_kinematics.DirectionalDOF_swiginit(self, _IMP_kinematics.new_DirectionalDOF(dofs))

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

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

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

    def get_version_info(self):
        r"""get_version_info(DirectionalDOF self) -> VersionInfo"""
        return _IMP_kinematics.DirectionalDOF_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_DirectionalDOF

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

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

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


# Register DirectionalDOF in _IMP_kinematics:
_IMP_kinematics.DirectionalDOF_swigregister(DirectionalDOF)
class DOFsSampler(IMP.Object):
    r"""Proxy of C++ IMP::kinematics::DOFsSampler class."""

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

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

    def get_version_info(self):
        r"""get_version_info(DOFsSampler self) -> VersionInfo"""
        return _IMP_kinematics.DOFsSampler_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_DOFsSampler

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

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




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

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

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

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

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

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

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

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

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

    def __repr__(self):
        r"""__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):
        r"""do_destroy(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_do_destroy(self)

# Register DOFsSampler in _IMP_kinematics:
_IMP_kinematics.DOFsSampler_swigregister(DOFsSampler)
class FibrilSampler(DOFsSampler):
    r"""Proxy of C++ IMP::kinematics::FibrilSampler class."""

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

    def __init__(self, trans_joint, dihedral_joints, dofs):
        r"""__init__(FibrilSampler self, IMP::kinematics::TransformationJoints trans_joint, IMP::kinematics::DihedralAngleRevoluteJoints dihedral_joints, IMP::kinematics::DOFs dofs) -> FibrilSampler"""
        _IMP_kinematics.FibrilSampler_swiginit(self, _IMP_kinematics.new_FibrilSampler(trans_joint, dihedral_joints, dofs))

    def apply_floats(self, values):
        r"""apply_floats(FibrilSampler self, IMP::Floats const & values)"""
        return _IMP_kinematics.FibrilSampler_apply_floats(self, values)

    def get_dihedral_joints(self):
        r"""get_dihedral_joints(FibrilSampler self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.FibrilSampler_get_dihedral_joints(self)

    def get_transformation_joint(self):
        r"""get_transformation_joint(FibrilSampler self) -> IMP::kinematics::TransformationJoints"""
        return _IMP_kinematics.FibrilSampler_get_transformation_joint(self)

    def __str__(self):
        r"""__str__(FibrilSampler self) -> std::string"""
        return _IMP_kinematics.FibrilSampler___str__(self)

    def __repr__(self):
        r"""__repr__(FibrilSampler self) -> std::string"""
        return _IMP_kinematics.FibrilSampler___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_FibrilSampler

# Register FibrilSampler in _IMP_kinematics:
_IMP_kinematics.FibrilSampler_swigregister(FibrilSampler)
class UniformBackboneSampler(DOFsSampler):
    r"""Proxy of C++ IMP::kinematics::UniformBackboneSampler class."""

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

    def __init__(self, joints, dofs):
        r"""__init__(UniformBackboneSampler self, IMP::kinematics::DihedralAngleRevoluteJoints joints, IMP::kinematics::DOFs dofs) -> UniformBackboneSampler"""
        _IMP_kinematics.UniformBackboneSampler_swiginit(self, _IMP_kinematics.new_UniformBackboneSampler(joints, dofs))

    def apply_floats(self, values):
        r"""apply_floats(UniformBackboneSampler self, IMP::Floats const & values)"""
        return _IMP_kinematics.UniformBackboneSampler_apply_floats(self, values)

    def get_joints(self):
        r"""get_joints(UniformBackboneSampler self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.UniformBackboneSampler_get_joints(self)

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

    def __repr__(self):
        r"""__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

# Register UniformBackboneSampler in _IMP_kinematics:
_IMP_kinematics.UniformBackboneSampler_swigregister(UniformBackboneSampler)
PHI = _IMP_kinematics.PHI

PSI = _IMP_kinematics.PSI

CHI = _IMP_kinematics.CHI

CHI1 = _IMP_kinematics.CHI1

CHI2 = _IMP_kinematics.CHI2

CHI3 = _IMP_kinematics.CHI3

CHI4 = _IMP_kinematics.CHI4

CHI5 = _IMP_kinematics.CHI5

OTHER = _IMP_kinematics.OTHER

OTHER2 = _IMP_kinematics.OTHER2

OTHER3 = _IMP_kinematics.OTHER3

OTHER4 = _IMP_kinematics.OTHER4

OTHER5 = _IMP_kinematics.OTHER5

TOTAL = _IMP_kinematics.TOTAL

class ProteinKinematics(IMP.Object):
    r"""Proxy of C++ IMP::kinematics::ProteinKinematics class."""

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

    def __init__(self, *args):
        r"""
        __init__(ProteinKinematics self, Hierarchy mhd, bool flexible_backbone=True, bool flexible_side_chains=False) -> ProteinKinematics
        __init__(ProteinKinematics self, Hierarchy mhd, IMP::atom::Residues const & flexible_residues, IMP::ParticleIndexQuads const custom_dihedral_angles, IMP::atom::Atoms open_loop_bond_atoms=IMP::atom::Atoms(), bool flexible_backbone=True, bool flexible_side_chains=False) -> ProteinKinematics
        __init__(ProteinKinematics self, Hierarchy mhd, IMP::atom::Residues const & flexible_residues, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & custom_dihedral_atoms, IMP::atom::Atoms open_loop_bond_atoms=IMP::atom::Atoms(), bool flexible_backbone=True, bool flexible_side_chains=False) -> ProteinKinematics
        __init__(ProteinKinematics self, Hierarchy mhd, IMP::atom::Residues const & flexible_residues, IMP::ParticleIndexQuads const custom_dihedral_angles, std::vector< IMP::kinematics::ProteinAngleType,std::allocator< IMP::kinematics::ProteinAngleType > > const & custom_dihedral_angle_types, IMP::atom::Atoms open_loop_bond_atoms=IMP::atom::Atoms(), bool flexible_backbone=True, bool flexible_side_chains=False) -> ProteinKinematics
        """
        _IMP_kinematics.ProteinKinematics_swiginit(self, _IMP_kinematics.new_ProteinKinematics(*args))

    def get_phi(self, r):
        r"""get_phi(ProteinKinematics self, Residue r) -> double"""
        return _IMP_kinematics.ProteinKinematics_get_phi(self, r)

    def get_psi(self, r):
        r"""get_psi(ProteinKinematics self, Residue r) -> double"""
        return _IMP_kinematics.ProteinKinematics_get_psi(self, r)

    def get_joints(self):
        r"""get_joints(ProteinKinematics self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.ProteinKinematics_get_joints(self)

    def get_loop_joints(self):
        r"""get_loop_joints(ProteinKinematics self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.ProteinKinematics_get_loop_joints(self)

    def get_ordered_joints(self):
        r"""get_ordered_joints(ProteinKinematics self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.ProteinKinematics_get_ordered_joints(self)

    def get_kinematic_forest(self):
        r"""get_kinematic_forest(ProteinKinematics self) -> KinematicForest"""
        return _IMP_kinematics.ProteinKinematics_get_kinematic_forest(self)

    def get_rigid_bodies(self):
        r"""get_rigid_bodies(ProteinKinematics self) -> IMP::core::RigidBodies"""
        return _IMP_kinematics.ProteinKinematics_get_rigid_bodies(self)

    def set_phi(self, r, angle):
        r"""set_phi(ProteinKinematics self, Residue r, double angle)"""
        return _IMP_kinematics.ProteinKinematics_set_phi(self, r, angle)

    def set_psi(self, r, angle):
        r"""set_psi(ProteinKinematics self, Residue r, double angle)"""
        return _IMP_kinematics.ProteinKinematics_set_psi(self, r, angle)

    def get_version_info(self):
        r"""get_version_info(ProteinKinematics self) -> VersionInfo"""
        return _IMP_kinematics.ProteinKinematics_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_ProteinKinematics

    def build_topology_graph(self):
        r"""build_topology_graph(ProteinKinematics self)"""
        return _IMP_kinematics.ProteinKinematics_build_topology_graph(self)

    def order_rigid_bodies(self, dihedral_angles, phi_angles, psi_angles, chi1_angles, chi2_angles, chi3_angles, chi4_angles, chi5_angles, open_loop_bond_atoms):
        r"""order_rigid_bodies(ProteinKinematics self, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & dihedral_angles, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & phi_angles, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & psi_angles, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & chi1_angles, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & chi2_angles, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & chi3_angles, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & chi4_angles, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & chi5_angles, IMP::atom::Atoms open_loop_bond_atoms)"""
        return _IMP_kinematics.ProteinKinematics_order_rigid_bodies(self, dihedral_angles, phi_angles, psi_angles, chi1_angles, chi2_angles, chi3_angles, chi4_angles, chi5_angles, open_loop_bond_atoms)

    def mark_rotatable_angles(self, dihedral_angles):
        r"""mark_rotatable_angles(ProteinKinematics self, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & dihedral_angles)"""
        return _IMP_kinematics.ProteinKinematics_mark_rotatable_angles(self, dihedral_angles)

    def mark_rotatable_angle(self, dihedral_angle):
        r"""mark_rotatable_angle(ProteinKinematics self, std::vector< IMP::atom::Atom,std::allocator< IMP::atom::Atom > > const & dihedral_angle)"""
        return _IMP_kinematics.ProteinKinematics_mark_rotatable_angle(self, dihedral_angle)

    def build_rigid_bodies(self):
        r"""build_rigid_bodies(ProteinKinematics self)"""
        return _IMP_kinematics.ProteinKinematics_build_rigid_bodies(self)

    def add_dihedral_joints(self, residues, angle_type, dihedral_angles):
        r"""add_dihedral_joints(ProteinKinematics self, std::vector< IMP::atom::Residue,std::allocator< IMP::atom::Residue > > const & residues, IMP::kinematics::ProteinAngleType angle_type, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & dihedral_angles)"""
        return _IMP_kinematics.ProteinKinematics_add_dihedral_joints(self, residues, angle_type, dihedral_angles)

    def add_dihedral_joint(self, r, angle_type, atoms):
        r"""add_dihedral_joint(ProteinKinematics self, Residue r, IMP::kinematics::ProteinAngleType angle_type, IMP::atom::Atoms const & atoms)"""
        return _IMP_kinematics.ProteinKinematics_add_dihedral_joint(self, r, angle_type, atoms)

    def open_loop(self, open_loop_bond_atoms):
        r"""open_loop(ProteinKinematics self, IMP::atom::Atoms open_loop_bond_atoms)"""
        return _IMP_kinematics.ProteinKinematics_open_loop(self, open_loop_bond_atoms)

    def get_phi_joint(self, r):
        r"""get_phi_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_phi_joint(self, r)

    def get_psi_joint(self, r):
        r"""get_psi_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_psi_joint(self, r)

    def get_other_joint(self, r):
        r"""get_other_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_other_joint(self, r)

    def get_chi1_joint(self, r):
        r"""get_chi1_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_chi1_joint(self, r)

    def get_chi2_joint(self, r):
        r"""get_chi2_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_chi2_joint(self, r)

    def get_chi3_joint(self, r):
        r"""get_chi3_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_chi3_joint(self, r)

    def get_chi4_joint(self, r):
        r"""get_chi4_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_chi4_joint(self, r)

    def get_chi5_joint(self, r):
        r"""get_chi5_joint(ProteinKinematics self, Residue r) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_chi5_joint(self, r)

    def get_joint(self, r, angle):
        r"""get_joint(ProteinKinematics self, Residue r, IMP::kinematics::ProteinAngleType angle) -> DihedralAngleRevoluteJoint"""
        return _IMP_kinematics.ProteinKinematics_get_joint(self, r, angle)

    def __str__(self):
        r"""__str__(ProteinKinematics self) -> std::string"""
        return _IMP_kinematics.ProteinKinematics___str__(self)

    def __repr__(self):
        r"""__repr__(ProteinKinematics self) -> std::string"""
        return _IMP_kinematics.ProteinKinematics___repr__(self)

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


# Register ProteinKinematics in _IMP_kinematics:
_IMP_kinematics.ProteinKinematics_swigregister(ProteinKinematics)
class LocalPlanner(IMP.Object):
    r"""Proxy of C++ IMP::kinematics::LocalPlanner class."""

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

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

    def get_version_info(self):
        r"""get_version_info(LocalPlanner self) -> VersionInfo"""
        return _IMP_kinematics.LocalPlanner_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_LocalPlanner

    def plan(self, q_near, q_rand, sf):
        r"""plan(LocalPlanner self, DOFValues q_near, DOFValues q_rand, ScoringFunction sf) -> std::vector< IMP::kinematics::DOFValues,std::allocator< IMP::kinematics::DOFValues > >"""
        return _IMP_kinematics.LocalPlanner_plan(self, q_near, q_rand, sf)

    def is_valid(self, values, sf):
        r"""is_valid(LocalPlanner self, DOFValues values, ScoringFunction sf) -> bool"""
        return _IMP_kinematics.LocalPlanner_is_valid(self, values, sf)

    def __str__(self):
        r"""__str__(LocalPlanner self) -> std::string"""
        return _IMP_kinematics.LocalPlanner___str__(self)

    def __repr__(self):
        r"""__repr__(LocalPlanner self) -> std::string"""
        return _IMP_kinematics.LocalPlanner___repr__(self)

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


# Register LocalPlanner in _IMP_kinematics:
_IMP_kinematics.LocalPlanner_swigregister(LocalPlanner)
class PathLocalPlanner(LocalPlanner):
    r"""Proxy of C++ IMP::kinematics::PathLocalPlanner class."""

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

    def __init__(self, model, dofs_sampler, directional_dof, save_step_interval=1):
        r"""__init__(PathLocalPlanner self, Model model, DOFsSampler dofs_sampler, DirectionalDOF directional_dof, int save_step_interval=1) -> PathLocalPlanner"""
        _IMP_kinematics.PathLocalPlanner_swiginit(self, _IMP_kinematics.new_PathLocalPlanner(model, dofs_sampler, directional_dof, save_step_interval))

    def __str__(self):
        r"""__str__(PathLocalPlanner self) -> std::string"""
        return _IMP_kinematics.PathLocalPlanner___str__(self)

    def __repr__(self):
        r"""__repr__(PathLocalPlanner self) -> std::string"""
        return _IMP_kinematics.PathLocalPlanner___repr__(self)

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

    __swig_destroy__ = _IMP_kinematics.delete_PathLocalPlanner

# Register PathLocalPlanner in _IMP_kinematics:
_IMP_kinematics.PathLocalPlanner_swigregister(PathLocalPlanner)
class RRT(IMP.Sampler):
    r"""Proxy of C++ IMP::kinematics::RRT class."""

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

    def get_version_info(self):
        r"""get_version_info(RRT self) -> VersionInfo"""
        return _IMP_kinematics.RRT_get_version_info(self)
    __swig_destroy__ = _IMP_kinematics.delete_RRT

    def __init__(self, m, sampler, planner, cspace_dofs, iteration_number=1000, tree_size=100, number_of_sampled_dofs=0):
        r"""__init__(RRT self, Model m, DOFsSampler sampler, LocalPlanner planner, IMP::kinematics::DOFs const & cspace_dofs, unsigned int iteration_number=1000, unsigned int tree_size=100, unsigned int number_of_sampled_dofs=0) -> RRT"""
        _IMP_kinematics.RRT_swiginit(self, _IMP_kinematics.new_RRT(m, sampler, planner, cspace_dofs, iteration_number, tree_size, number_of_sampled_dofs))

    def do_sample(self):
        r"""do_sample(RRT self) -> ConfigurationSet"""
        return _IMP_kinematics.RRT_do_sample(self)

    def run(self, number_of_iterations=0):
        r"""run(RRT self, unsigned int number_of_iterations=0) -> bool"""
        return _IMP_kinematics.RRT_run(self, number_of_iterations)

    def get_DOFValuesList(self):
        r"""get_DOFValuesList(RRT self) -> IMP::kinematics::DOFValuesList"""
        return _IMP_kinematics.RRT_get_DOFValuesList(self)

    def set_number_of_iterations(self, num):
        r"""set_number_of_iterations(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_number_of_iterations(self, num)

    def set_tree_size(self, num):
        r"""set_tree_size(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_tree_size(self, num)

    def set_actual_tree_size(self, num):
        r"""set_actual_tree_size(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_actual_tree_size(self, num)

    def set_number_of_collisions(self, num):
        r"""set_number_of_collisions(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_number_of_collisions(self, num)

    def check_initial_configuration(self, sf):
        r"""check_initial_configuration(RRT self, ScoringFunction sf)"""
        return _IMP_kinematics.RRT_check_initial_configuration(self, sf)

    def __str__(self):
        r"""__str__(RRT self) -> std::string"""
        return _IMP_kinematics.RRT___str__(self)

    def __repr__(self):
        r"""__repr__(RRT self) -> std::string"""
        return _IMP_kinematics.RRT___repr__(self)

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


# Register RRT in _IMP_kinematics:
_IMP_kinematics.RRT_swigregister(RRT)

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

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

def get_data_path(fname):
    r"""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()