npc/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# 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 __future__ import print_function, division, absolute_import



from sys import version_info as _swig_python_version_info
import _IMP_npc

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_NPC_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_NPC_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_npc.delete_IMP_NPC_SwigPyIterator

    def value(self):
        r"""value(IMP_NPC_SwigPyIterator self) -> PyObject *"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(IMP_NPC_SwigPyIterator self, size_t n=1) -> IMP_NPC_SwigPyIterator"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(IMP_NPC_SwigPyIterator self, size_t n=1) -> IMP_NPC_SwigPyIterator"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(IMP_NPC_SwigPyIterator self, IMP_NPC_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(IMP_NPC_SwigPyIterator self, IMP_NPC_SwigPyIterator x) -> bool"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(IMP_NPC_SwigPyIterator self) -> IMP_NPC_SwigPyIterator"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_copy(self)

    def next(self):
        r"""next(IMP_NPC_SwigPyIterator self) -> PyObject *"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(IMP_NPC_SwigPyIterator self) -> PyObject *"""
        return _IMP_npc.IMP_NPC_SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(IMP_NPC_SwigPyIterator self) -> PyObject *"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(IMP_NPC_SwigPyIterator self, ptrdiff_t n) -> IMP_NPC_SwigPyIterator"""
        return _IMP_npc.IMP_NPC_SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(IMP_NPC_SwigPyIterator self, IMP_NPC_SwigPyIterator x) -> bool"""
        return _IMP_npc.IMP_NPC_SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(IMP_NPC_SwigPyIterator self, IMP_NPC_SwigPyIterator x) -> bool"""
        return _IMP_npc.IMP_NPC_SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(IMP_NPC_SwigPyIterator self, ptrdiff_t n) -> IMP_NPC_SwigPyIterator"""
        return _IMP_npc.IMP_NPC_SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(IMP_NPC_SwigPyIterator self, ptrdiff_t n) -> IMP_NPC_SwigPyIterator"""
        return _IMP_npc.IMP_NPC_SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(IMP_NPC_SwigPyIterator self, ptrdiff_t n) -> IMP_NPC_SwigPyIterator"""
        return _IMP_npc.IMP_NPC_SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(IMP_NPC_SwigPyIterator self, ptrdiff_t n) -> IMP_NPC_SwigPyIterator
        __sub__(IMP_NPC_SwigPyIterator self, IMP_NPC_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_npc.IMP_NPC_SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register IMP_NPC_SwigPyIterator in _IMP_npc:
_IMP_npc.IMP_NPC_SwigPyIterator_swigregister(IMP_NPC_SwigPyIterator)

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

IMP_DEBUG = _IMP_npc.IMP_DEBUG

IMP_RELEASE = _IMP_npc.IMP_RELEASE

IMP_SILENT = _IMP_npc.IMP_SILENT

IMP_PROGRESS = _IMP_npc.IMP_PROGRESS

IMP_TERSE = _IMP_npc.IMP_TERSE

IMP_VERBOSE = _IMP_npc.IMP_VERBOSE

IMP_MEMORY = _IMP_npc.IMP_MEMORY

IMP_NONE = _IMP_npc.IMP_NONE

IMP_USAGE = _IMP_npc.IMP_USAGE

IMP_INTERNAL = _IMP_npc.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_npc.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_npc.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_npc.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_npc.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_npc.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_npc.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_npc.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_npc.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_npc.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_npc.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_npc.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):
    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_npc._ostream_write(self, osa_buf)

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

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_npc.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_npc.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_npc.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_npc.IMP_CGAL_HAS_BOOST_SYSTEM

IMP_CGAL_HAS_NUMPY = _IMP_npc.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_npc.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_npc.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_npc.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_npc.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_npc.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_npc.IMP_ALGEBRA_HAS_BOOST_SYSTEM

IMP_ALGEBRA_HAS_CGAL = _IMP_npc.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_npc.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_npc.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_npc.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_npc.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_npc.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_npc.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_npc.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_npc.IMP_DISPLAY_HAS_BOOST_SYSTEM

IMP_DISPLAY_HAS_CGAL = _IMP_npc.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_npc.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_npc.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_npc.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_npc.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_CORE_HAS_IMP_CGAL = _IMP_npc.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_npc.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_npc.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_npc.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_npc.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_BOOST_SYSTEM = _IMP_npc.IMP_CORE_HAS_BOOST_SYSTEM

IMP_CORE_HAS_CGAL = _IMP_npc.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_npc.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_npc.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_npc.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_NPC_HAS_IMP_ALGEBRA = _IMP_npc.IMP_NPC_HAS_IMP_ALGEBRA

IMP_NPC_HAS_IMP_CGAL = _IMP_npc.IMP_NPC_HAS_IMP_CGAL

IMP_NPC_HAS_IMP_DISPLAY = _IMP_npc.IMP_NPC_HAS_IMP_DISPLAY

IMP_NPC_HAS_IMP_KERNEL = _IMP_npc.IMP_NPC_HAS_IMP_KERNEL

IMP_NPC_HAS_IMP_SCORE_FUNCTOR = _IMP_npc.IMP_NPC_HAS_IMP_SCORE_FUNCTOR

IMP_NPC_HAS_BOOST_FILESYSTEM = _IMP_npc.IMP_NPC_HAS_BOOST_FILESYSTEM

IMP_NPC_HAS_BOOST_PROGRAMOPTIONS = _IMP_npc.IMP_NPC_HAS_BOOST_PROGRAMOPTIONS

IMP_NPC_HAS_BOOST_RANDOM = _IMP_npc.IMP_NPC_HAS_BOOST_RANDOM

IMP_NPC_HAS_BOOST_SYSTEM = _IMP_npc.IMP_NPC_HAS_BOOST_SYSTEM

IMP_NPC_HAS_CGAL = _IMP_npc.IMP_NPC_HAS_CGAL

IMP_NPC_HAS_HDF5 = _IMP_npc.IMP_NPC_HAS_HDF5

IMP_NPC_HAS_NUMPY = _IMP_npc.IMP_NPC_HAS_NUMPY

IMP_NPC_HAS_PYTHON_IHM = _IMP_npc.IMP_NPC_HAS_PYTHON_IHM

IMPNPC_SHOW_WARNINGS = _IMP_npc.IMPNPC_SHOW_WARNINGS


_object_types.append("ZAxialPositionLowerRestraint")


def _object_cast_to_ZAxialPositionLowerRestraint(o):
    r"""_object_cast_to_ZAxialPositionLowerRestraint(Object o) -> ZAxialPositionLowerRestraint"""
    return _IMP_npc._object_cast_to_ZAxialPositionLowerRestraint(o)

_object_types.append("ZAxialPositionUpperRestraint")


def _object_cast_to_ZAxialPositionUpperRestraint(o):
    r"""_object_cast_to_ZAxialPositionUpperRestraint(Object o) -> ZAxialPositionUpperRestraint"""
    return _IMP_npc._object_cast_to_ZAxialPositionUpperRestraint(o)

_object_types.append("XYRadialPositionLowerRestraint")


def _object_cast_to_XYRadialPositionLowerRestraint(o):
    r"""_object_cast_to_XYRadialPositionLowerRestraint(Object o) -> XYRadialPositionLowerRestraint"""
    return _IMP_npc._object_cast_to_XYRadialPositionLowerRestraint(o)

_object_types.append("XYRadialPositionUpperRestraint")


def _object_cast_to_XYRadialPositionUpperRestraint(o):
    r"""_object_cast_to_XYRadialPositionUpperRestraint(Object o) -> XYRadialPositionUpperRestraint"""
    return _IMP_npc._object_cast_to_XYRadialPositionUpperRestraint(o)

_object_types.append("ProteinContactRestraint")


def _object_cast_to_ProteinContactRestraint(o):
    r"""_object_cast_to_ProteinContactRestraint(Object o) -> ProteinContactRestraint"""
    return _IMP_npc._object_cast_to_ProteinContactRestraint(o)

_object_types.append("ProteinChainRestraint")


def _object_cast_to_ProteinChainRestraint(o):
    r"""_object_cast_to_ProteinChainRestraint(Object o) -> ProteinChainRestraint"""
    return _IMP_npc._object_cast_to_ProteinChainRestraint(o)

_object_types.append("MembraneSurfaceLocationRestraint")


def _object_cast_to_MembraneSurfaceLocationRestraint(o):
    r"""_object_cast_to_MembraneSurfaceLocationRestraint(Object o) -> MembraneSurfaceLocationRestraint"""
    return _IMP_npc._object_cast_to_MembraneSurfaceLocationRestraint(o)

_object_types.append("PoreSideVolumeLocationRestraint")


def _object_cast_to_PoreSideVolumeLocationRestraint(o):
    r"""_object_cast_to_PoreSideVolumeLocationRestraint(Object o) -> PoreSideVolumeLocationRestraint"""
    return _IMP_npc._object_cast_to_PoreSideVolumeLocationRestraint(o)

_object_types.append("PerinuclearVolumeLocationRestraint")


def _object_cast_to_PerinuclearVolumeLocationRestraint(o):
    r"""_object_cast_to_PerinuclearVolumeLocationRestraint(Object o) -> PerinuclearVolumeLocationRestraint"""
    return _IMP_npc._object_cast_to_PerinuclearVolumeLocationRestraint(o)

_object_types.append("AssemblySymmetryByDistanceRestraint")


def _object_cast_to_AssemblySymmetryByDistanceRestraint(o):
    r"""_object_cast_to_AssemblySymmetryByDistanceRestraint(Object o) -> AssemblySymmetryByDistanceRestraint"""
    return _IMP_npc._object_cast_to_AssemblySymmetryByDistanceRestraint(o)

_object_types.append("AssemblySymmetryByDihedralRestraint")


def _object_cast_to_AssemblySymmetryByDihedralRestraint(o):
    r"""_object_cast_to_AssemblySymmetryByDihedralRestraint(Object o) -> AssemblySymmetryByDihedralRestraint"""
    return _IMP_npc._object_cast_to_AssemblySymmetryByDihedralRestraint(o)

_object_types.append("ProteinProximityRestraint")


def _object_cast_to_ProteinProximityRestraint(o):
    r"""_object_cast_to_ProteinProximityRestraint(Object o) -> ProteinProximityRestraint"""
    return _IMP_npc._object_cast_to_ProteinProximityRestraint(o)

_object_types.append("CompositeRestraint")


def _object_cast_to_CompositeRestraint(o):
    r"""_object_cast_to_CompositeRestraint(Object o) -> CompositeRestraint"""
    return _IMP_npc._object_cast_to_CompositeRestraint(o)

_object_types.append("MinimumSphereDistancePairScore")


def _object_cast_to_MinimumSphereDistancePairScore(o):
    r"""_object_cast_to_MinimumSphereDistancePairScore(Object o) -> MinimumSphereDistancePairScore"""
    return _IMP_npc._object_cast_to_MinimumSphereDistancePairScore(o)

_object_types.append("MembraneExclusionRestraint")


def _object_cast_to_MembraneExclusionRestraint(o):
    r"""_object_cast_to_MembraneExclusionRestraint(Object o) -> MembraneExclusionRestraint"""
    return _IMP_npc._object_cast_to_MembraneExclusionRestraint(o)

_object_types.append("MembraneSurfaceLocationConditionalRestraint")


def _object_cast_to_MembraneSurfaceLocationConditionalRestraint(o):
    r"""_object_cast_to_MembraneSurfaceLocationConditionalRestraint(Object o) -> MembraneSurfaceLocationConditionalRestraint"""
    return _IMP_npc._object_cast_to_MembraneSurfaceLocationConditionalRestraint(o)

_object_types.append("XYRadialPositionRestraint")


def _object_cast_to_XYRadialPositionRestraint(o):
    r"""_object_cast_to_XYRadialPositionRestraint(Object o) -> XYRadialPositionRestraint"""
    return _IMP_npc._object_cast_to_XYRadialPositionRestraint(o)

_object_types.append("YAxialPositionLowerRestraint")


def _object_cast_to_YAxialPositionLowerRestraint(o):
    r"""_object_cast_to_YAxialPositionLowerRestraint(Object o) -> YAxialPositionLowerRestraint"""
    return _IMP_npc._object_cast_to_YAxialPositionLowerRestraint(o)

_object_types.append("YAxialPositionRestraint")


def _object_cast_to_YAxialPositionRestraint(o):
    r"""_object_cast_to_YAxialPositionRestraint(Object o) -> YAxialPositionRestraint"""
    return _IMP_npc._object_cast_to_YAxialPositionRestraint(o)

_object_types.append("YAxialPositionUpperRestraint")


def _object_cast_to_YAxialPositionUpperRestraint(o):
    r"""_object_cast_to_YAxialPositionUpperRestraint(Object o) -> YAxialPositionUpperRestraint"""
    return _IMP_npc._object_cast_to_YAxialPositionUpperRestraint(o)

_object_types.append("ZAxialPositionRestraint")


def _object_cast_to_ZAxialPositionRestraint(o):
    r"""_object_cast_to_ZAxialPositionRestraint(Object o) -> ZAxialPositionRestraint"""
    return _IMP_npc._object_cast_to_ZAxialPositionRestraint(o)
class ZAxialPositionRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::ZAxialPositionRestraint 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__(ZAxialPositionRestraint self, Model m, _SingletonContainerAdaptor sc, double lower_bound, double upper_bound, bool consider_radius, double sigma=1) -> ZAxialPositionRestraint
        __init__(ZAxialPositionRestraint self, Model m, double lower_bound, double upper_bound, bool consider_radius, double sigma=1) -> ZAxialPositionRestraint
        __init__(ZAxialPositionRestraint self) -> ZAxialPositionRestraint
        """
        _IMP_npc.ZAxialPositionRestraint_swiginit(self, _IMP_npc.new_ZAxialPositionRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(ZAxialPositionRestraint self, Particle p)"""
        return _IMP_npc.ZAxialPositionRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(ZAxialPositionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ZAxialPositionRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(ZAxialPositionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ZAxialPositionRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(ZAxialPositionRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.ZAxialPositionRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ZAxialPositionRestraint self) -> VersionInfo"""
        return _IMP_npc.ZAxialPositionRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_ZAxialPositionRestraint

    def __str__(self):
        r"""__str__(ZAxialPositionRestraint self) -> std::string"""
        return _IMP_npc.ZAxialPositionRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ZAxialPositionRestraint self) -> std::string"""
        return _IMP_npc.ZAxialPositionRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ZAxialPositionRestraint self) -> PyObject *"""
        return _IMP_npc.ZAxialPositionRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ZAxialPositionRestraint self, PyObject * p)"""
        return _IMP_npc.ZAxialPositionRestraint__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)


# Register ZAxialPositionRestraint in _IMP_npc:
_IMP_npc.ZAxialPositionRestraint_swigregister(ZAxialPositionRestraint)
class ZAxialPositionLowerRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::ZAxialPositionLowerRestraint 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__(ZAxialPositionLowerRestraint self, Model m, _SingletonContainerAdaptor sc, double lower_bound, bool consider_radius, double sigma=1) -> ZAxialPositionLowerRestraint
        __init__(ZAxialPositionLowerRestraint self, Model m, double lower_bound, bool consider_radius, double sigma=1) -> ZAxialPositionLowerRestraint
        __init__(ZAxialPositionLowerRestraint self) -> ZAxialPositionLowerRestraint
        """
        _IMP_npc.ZAxialPositionLowerRestraint_swiginit(self, _IMP_npc.new_ZAxialPositionLowerRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(ZAxialPositionLowerRestraint self, Particle p)"""
        return _IMP_npc.ZAxialPositionLowerRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(ZAxialPositionLowerRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ZAxialPositionLowerRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(ZAxialPositionLowerRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ZAxialPositionLowerRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(ZAxialPositionLowerRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.ZAxialPositionLowerRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ZAxialPositionLowerRestraint self) -> VersionInfo"""
        return _IMP_npc.ZAxialPositionLowerRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_ZAxialPositionLowerRestraint

    def __str__(self):
        r"""__str__(ZAxialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.ZAxialPositionLowerRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ZAxialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.ZAxialPositionLowerRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ZAxialPositionLowerRestraint self) -> PyObject *"""
        return _IMP_npc.ZAxialPositionLowerRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ZAxialPositionLowerRestraint self, PyObject * p)"""
        return _IMP_npc.ZAxialPositionLowerRestraint__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)


# Register ZAxialPositionLowerRestraint in _IMP_npc:
_IMP_npc.ZAxialPositionLowerRestraint_swigregister(ZAxialPositionLowerRestraint)
class ZAxialPositionUpperRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::ZAxialPositionUpperRestraint 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__(ZAxialPositionUpperRestraint self, Model m, _SingletonContainerAdaptor sc, double upper_bound, bool consider_radius, double sigma=1) -> ZAxialPositionUpperRestraint
        __init__(ZAxialPositionUpperRestraint self, Model m, double upper_bound, bool consider_radius, double sigma=1) -> ZAxialPositionUpperRestraint
        __init__(ZAxialPositionUpperRestraint self) -> ZAxialPositionUpperRestraint
        """
        _IMP_npc.ZAxialPositionUpperRestraint_swiginit(self, _IMP_npc.new_ZAxialPositionUpperRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(ZAxialPositionUpperRestraint self, Particle p)"""
        return _IMP_npc.ZAxialPositionUpperRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(ZAxialPositionUpperRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ZAxialPositionUpperRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(ZAxialPositionUpperRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ZAxialPositionUpperRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(ZAxialPositionUpperRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.ZAxialPositionUpperRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ZAxialPositionUpperRestraint self) -> VersionInfo"""
        return _IMP_npc.ZAxialPositionUpperRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_ZAxialPositionUpperRestraint

    def __str__(self):
        r"""__str__(ZAxialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.ZAxialPositionUpperRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ZAxialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.ZAxialPositionUpperRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ZAxialPositionUpperRestraint self) -> PyObject *"""
        return _IMP_npc.ZAxialPositionUpperRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ZAxialPositionUpperRestraint self, PyObject * p)"""
        return _IMP_npc.ZAxialPositionUpperRestraint__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)


# Register ZAxialPositionUpperRestraint in _IMP_npc:
_IMP_npc.ZAxialPositionUpperRestraint_swigregister(ZAxialPositionUpperRestraint)
class YAxialPositionRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::YAxialPositionRestraint 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__(YAxialPositionRestraint self, Model m, _SingletonContainerAdaptor sc, double lower_bound, double upper_bound, bool consider_radius, double sigma=1) -> YAxialPositionRestraint
        __init__(YAxialPositionRestraint self, Model m, double lower_bound, double upper_bound, bool consider_radius, double sigma=1) -> YAxialPositionRestraint
        __init__(YAxialPositionRestraint self) -> YAxialPositionRestraint
        """
        _IMP_npc.YAxialPositionRestraint_swiginit(self, _IMP_npc.new_YAxialPositionRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(YAxialPositionRestraint self, Particle p)"""
        return _IMP_npc.YAxialPositionRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(YAxialPositionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.YAxialPositionRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(YAxialPositionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.YAxialPositionRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(YAxialPositionRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.YAxialPositionRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(YAxialPositionRestraint self) -> VersionInfo"""
        return _IMP_npc.YAxialPositionRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_YAxialPositionRestraint

    def __str__(self):
        r"""__str__(YAxialPositionRestraint self) -> std::string"""
        return _IMP_npc.YAxialPositionRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(YAxialPositionRestraint self) -> std::string"""
        return _IMP_npc.YAxialPositionRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(YAxialPositionRestraint self) -> PyObject *"""
        return _IMP_npc.YAxialPositionRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(YAxialPositionRestraint self, PyObject * p)"""
        return _IMP_npc.YAxialPositionRestraint__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)


# Register YAxialPositionRestraint in _IMP_npc:
_IMP_npc.YAxialPositionRestraint_swigregister(YAxialPositionRestraint)
class YAxialPositionLowerRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::YAxialPositionLowerRestraint 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__(YAxialPositionLowerRestraint self, Model m, _SingletonContainerAdaptor sc, double lower_bound, bool consider_radius, double sigma=1) -> YAxialPositionLowerRestraint
        __init__(YAxialPositionLowerRestraint self, Model m, double lower_bound, bool consider_radius, double sigma=1) -> YAxialPositionLowerRestraint
        __init__(YAxialPositionLowerRestraint self) -> YAxialPositionLowerRestraint
        """
        _IMP_npc.YAxialPositionLowerRestraint_swiginit(self, _IMP_npc.new_YAxialPositionLowerRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(YAxialPositionLowerRestraint self, Particle p)"""
        return _IMP_npc.YAxialPositionLowerRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(YAxialPositionLowerRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.YAxialPositionLowerRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(YAxialPositionLowerRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.YAxialPositionLowerRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(YAxialPositionLowerRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.YAxialPositionLowerRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(YAxialPositionLowerRestraint self) -> VersionInfo"""
        return _IMP_npc.YAxialPositionLowerRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_YAxialPositionLowerRestraint

    def __str__(self):
        r"""__str__(YAxialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.YAxialPositionLowerRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(YAxialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.YAxialPositionLowerRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(YAxialPositionLowerRestraint self) -> PyObject *"""
        return _IMP_npc.YAxialPositionLowerRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(YAxialPositionLowerRestraint self, PyObject * p)"""
        return _IMP_npc.YAxialPositionLowerRestraint__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)


# Register YAxialPositionLowerRestraint in _IMP_npc:
_IMP_npc.YAxialPositionLowerRestraint_swigregister(YAxialPositionLowerRestraint)
class YAxialPositionUpperRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::YAxialPositionUpperRestraint 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__(YAxialPositionUpperRestraint self, Model m, _SingletonContainerAdaptor sc, double upper_bound, bool consider_radius, double sigma=1) -> YAxialPositionUpperRestraint
        __init__(YAxialPositionUpperRestraint self, Model m, double upper_bound, bool consider_radius, double sigma=1) -> YAxialPositionUpperRestraint
        __init__(YAxialPositionUpperRestraint self) -> YAxialPositionUpperRestraint
        """
        _IMP_npc.YAxialPositionUpperRestraint_swiginit(self, _IMP_npc.new_YAxialPositionUpperRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(YAxialPositionUpperRestraint self, Particle p)"""
        return _IMP_npc.YAxialPositionUpperRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(YAxialPositionUpperRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.YAxialPositionUpperRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(YAxialPositionUpperRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.YAxialPositionUpperRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(YAxialPositionUpperRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.YAxialPositionUpperRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(YAxialPositionUpperRestraint self) -> VersionInfo"""
        return _IMP_npc.YAxialPositionUpperRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_YAxialPositionUpperRestraint

    def __str__(self):
        r"""__str__(YAxialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.YAxialPositionUpperRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(YAxialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.YAxialPositionUpperRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(YAxialPositionUpperRestraint self) -> PyObject *"""
        return _IMP_npc.YAxialPositionUpperRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(YAxialPositionUpperRestraint self, PyObject * p)"""
        return _IMP_npc.YAxialPositionUpperRestraint__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)


# Register YAxialPositionUpperRestraint in _IMP_npc:
_IMP_npc.YAxialPositionUpperRestraint_swigregister(YAxialPositionUpperRestraint)
class XYRadialPositionRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::XYRadialPositionRestraint 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__(XYRadialPositionRestraint self, Model m, _SingletonContainerAdaptor sc, double lower_bound, double upper_bound, bool consider_radius, double sigma=1) -> XYRadialPositionRestraint
        __init__(XYRadialPositionRestraint self, Model m, double lower_bound, double upper_bound, bool consider_radius, double sigma=1) -> XYRadialPositionRestraint
        __init__(XYRadialPositionRestraint self) -> XYRadialPositionRestraint
        """
        _IMP_npc.XYRadialPositionRestraint_swiginit(self, _IMP_npc.new_XYRadialPositionRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(XYRadialPositionRestraint self, Particle p)"""
        return _IMP_npc.XYRadialPositionRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(XYRadialPositionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.XYRadialPositionRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(XYRadialPositionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.XYRadialPositionRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(XYRadialPositionRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.XYRadialPositionRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(XYRadialPositionRestraint self) -> VersionInfo"""
        return _IMP_npc.XYRadialPositionRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_XYRadialPositionRestraint

    def __str__(self):
        r"""__str__(XYRadialPositionRestraint self) -> std::string"""
        return _IMP_npc.XYRadialPositionRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(XYRadialPositionRestraint self) -> std::string"""
        return _IMP_npc.XYRadialPositionRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(XYRadialPositionRestraint self) -> PyObject *"""
        return _IMP_npc.XYRadialPositionRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XYRadialPositionRestraint self, PyObject * p)"""
        return _IMP_npc.XYRadialPositionRestraint__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)


# Register XYRadialPositionRestraint in _IMP_npc:
_IMP_npc.XYRadialPositionRestraint_swigregister(XYRadialPositionRestraint)
class XYRadialPositionLowerRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::XYRadialPositionLowerRestraint 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__(XYRadialPositionLowerRestraint self, Model m, _SingletonContainerAdaptor sc, double lower_bound, bool consider_radius, double sigma=1) -> XYRadialPositionLowerRestraint
        __init__(XYRadialPositionLowerRestraint self, Model m, double lower_bound, bool consider_radius, double sigma=1) -> XYRadialPositionLowerRestraint
        __init__(XYRadialPositionLowerRestraint self) -> XYRadialPositionLowerRestraint
        """
        _IMP_npc.XYRadialPositionLowerRestraint_swiginit(self, _IMP_npc.new_XYRadialPositionLowerRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(XYRadialPositionLowerRestraint self, Particle p)"""
        return _IMP_npc.XYRadialPositionLowerRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(XYRadialPositionLowerRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.XYRadialPositionLowerRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(XYRadialPositionLowerRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.XYRadialPositionLowerRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(XYRadialPositionLowerRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.XYRadialPositionLowerRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(XYRadialPositionLowerRestraint self) -> VersionInfo"""
        return _IMP_npc.XYRadialPositionLowerRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_XYRadialPositionLowerRestraint

    def __str__(self):
        r"""__str__(XYRadialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.XYRadialPositionLowerRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(XYRadialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.XYRadialPositionLowerRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(XYRadialPositionLowerRestraint self) -> PyObject *"""
        return _IMP_npc.XYRadialPositionLowerRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XYRadialPositionLowerRestraint self, PyObject * p)"""
        return _IMP_npc.XYRadialPositionLowerRestraint__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)


# Register XYRadialPositionLowerRestraint in _IMP_npc:
_IMP_npc.XYRadialPositionLowerRestraint_swigregister(XYRadialPositionLowerRestraint)
class XYRadialPositionUpperRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::XYRadialPositionUpperRestraint 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__(XYRadialPositionUpperRestraint self, Model m, _SingletonContainerAdaptor sc, double upper_bound, bool consider_radius, double sigma=1) -> XYRadialPositionUpperRestraint
        __init__(XYRadialPositionUpperRestraint self, Model m, double upper_bound, bool consider_radius, double sigma=1) -> XYRadialPositionUpperRestraint
        __init__(XYRadialPositionUpperRestraint self) -> XYRadialPositionUpperRestraint
        """
        _IMP_npc.XYRadialPositionUpperRestraint_swiginit(self, _IMP_npc.new_XYRadialPositionUpperRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(XYRadialPositionUpperRestraint self, Particle p)"""
        return _IMP_npc.XYRadialPositionUpperRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(XYRadialPositionUpperRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.XYRadialPositionUpperRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(XYRadialPositionUpperRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.XYRadialPositionUpperRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(XYRadialPositionUpperRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.XYRadialPositionUpperRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(XYRadialPositionUpperRestraint self) -> VersionInfo"""
        return _IMP_npc.XYRadialPositionUpperRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_XYRadialPositionUpperRestraint

    def __str__(self):
        r"""__str__(XYRadialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.XYRadialPositionUpperRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(XYRadialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.XYRadialPositionUpperRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(XYRadialPositionUpperRestraint self) -> PyObject *"""
        return _IMP_npc.XYRadialPositionUpperRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XYRadialPositionUpperRestraint self, PyObject * p)"""
        return _IMP_npc.XYRadialPositionUpperRestraint__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)


# Register XYRadialPositionUpperRestraint in _IMP_npc:
_IMP_npc.XYRadialPositionUpperRestraint_swigregister(XYRadialPositionUpperRestraint)
class ProteinContactRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::ProteinContactRestraint 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__(ProteinContactRestraint self, Model m, _SingletonContainerAdaptor sc, double tolerance_factor, double sigma=0.1) -> ProteinContactRestraint
        __init__(ProteinContactRestraint self, Model m, double tolerance_factor, double sigma=0.1) -> ProteinContactRestraint
        __init__(ProteinContactRestraint self) -> ProteinContactRestraint
        """
        _IMP_npc.ProteinContactRestraint_swiginit(self, _IMP_npc.new_ProteinContactRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(ProteinContactRestraint self, Particle p)"""
        return _IMP_npc.ProteinContactRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(ProteinContactRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ProteinContactRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(ProteinContactRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ProteinContactRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(ProteinContactRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.ProteinContactRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ProteinContactRestraint self) -> VersionInfo"""
        return _IMP_npc.ProteinContactRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_ProteinContactRestraint

    def __str__(self):
        r"""__str__(ProteinContactRestraint self) -> std::string"""
        return _IMP_npc.ProteinContactRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ProteinContactRestraint self) -> std::string"""
        return _IMP_npc.ProteinContactRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ProteinContactRestraint self) -> PyObject *"""
        return _IMP_npc.ProteinContactRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ProteinContactRestraint self, PyObject * p)"""
        return _IMP_npc.ProteinContactRestraint__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)


# Register ProteinContactRestraint in _IMP_npc:
_IMP_npc.ProteinContactRestraint_swigregister(ProteinContactRestraint)
class ProteinChainRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::ProteinChainRestraint 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__(ProteinChainRestraint self, Model m, _SingletonContainerAdaptor sc, double sigma=0.1) -> ProteinChainRestraint
        __init__(ProteinChainRestraint self, Model m, double sigma=0.1) -> ProteinChainRestraint
        __init__(ProteinChainRestraint self) -> ProteinChainRestraint
        """
        _IMP_npc.ProteinChainRestraint_swiginit(self, _IMP_npc.new_ProteinChainRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(ProteinChainRestraint self, Particle p)"""
        return _IMP_npc.ProteinChainRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(ProteinChainRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ProteinChainRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(ProteinChainRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ProteinChainRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(ProteinChainRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.ProteinChainRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ProteinChainRestraint self) -> VersionInfo"""
        return _IMP_npc.ProteinChainRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_ProteinChainRestraint

    def __str__(self):
        r"""__str__(ProteinChainRestraint self) -> std::string"""
        return _IMP_npc.ProteinChainRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ProteinChainRestraint self) -> std::string"""
        return _IMP_npc.ProteinChainRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ProteinChainRestraint self) -> PyObject *"""
        return _IMP_npc.ProteinChainRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ProteinChainRestraint self, PyObject * p)"""
        return _IMP_npc.ProteinChainRestraint__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)


# Register ProteinChainRestraint in _IMP_npc:
_IMP_npc.ProteinChainRestraint_swigregister(ProteinChainRestraint)
class MembraneSurfaceLocationRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::MembraneSurfaceLocationRestraint 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__(MembraneSurfaceLocationRestraint self, Model m, _SingletonContainerAdaptor sc, double R, double r, double thickness, double sigma=2) -> MembraneSurfaceLocationRestraint
        __init__(MembraneSurfaceLocationRestraint self, Model m, double R, double r, double thickness, double sigma=2) -> MembraneSurfaceLocationRestraint
        __init__(MembraneSurfaceLocationRestraint self) -> MembraneSurfaceLocationRestraint
        """
        _IMP_npc.MembraneSurfaceLocationRestraint_swiginit(self, _IMP_npc.new_MembraneSurfaceLocationRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(MembraneSurfaceLocationRestraint self, Particle p)"""
        return _IMP_npc.MembraneSurfaceLocationRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(MembraneSurfaceLocationRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneSurfaceLocationRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(MembraneSurfaceLocationRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneSurfaceLocationRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(MembraneSurfaceLocationRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.MembraneSurfaceLocationRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(MembraneSurfaceLocationRestraint self) -> VersionInfo"""
        return _IMP_npc.MembraneSurfaceLocationRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_MembraneSurfaceLocationRestraint

    def __str__(self):
        r"""__str__(MembraneSurfaceLocationRestraint self) -> std::string"""
        return _IMP_npc.MembraneSurfaceLocationRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(MembraneSurfaceLocationRestraint self) -> std::string"""
        return _IMP_npc.MembraneSurfaceLocationRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(MembraneSurfaceLocationRestraint self) -> PyObject *"""
        return _IMP_npc.MembraneSurfaceLocationRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(MembraneSurfaceLocationRestraint self, PyObject * p)"""
        return _IMP_npc.MembraneSurfaceLocationRestraint__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)


# Register MembraneSurfaceLocationRestraint in _IMP_npc:
_IMP_npc.MembraneSurfaceLocationRestraint_swigregister(MembraneSurfaceLocationRestraint)
class MembraneSurfaceLocationConditionalRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::MembraneSurfaceLocationConditionalRestraint 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__(MembraneSurfaceLocationConditionalRestraint self, Model m, _SingletonContainerAdaptor sc1, _SingletonContainerAdaptor sc2, double R, double r, double thickness, double sigma=2) -> MembraneSurfaceLocationConditionalRestraint
        __init__(MembraneSurfaceLocationConditionalRestraint self, Model m, double R, double r, double thickness, double sigma=2) -> MembraneSurfaceLocationConditionalRestraint
        __init__(MembraneSurfaceLocationConditionalRestraint self) -> MembraneSurfaceLocationConditionalRestraint
        """
        _IMP_npc.MembraneSurfaceLocationConditionalRestraint_swiginit(self, _IMP_npc.new_MembraneSurfaceLocationConditionalRestraint(*args))

    def add_particle1(self, p):
        r"""add_particle1(MembraneSurfaceLocationConditionalRestraint self, Particle p)"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_add_particle1(self, p)

    def add_particle2(self, p):
        r"""add_particle2(MembraneSurfaceLocationConditionalRestraint self, Particle p)"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_add_particle2(self, p)

    def add_particles1(self, ps):
        r"""add_particles1(MembraneSurfaceLocationConditionalRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_add_particles1(self, ps)

    def add_particles2(self, ps):
        r"""add_particles2(MembraneSurfaceLocationConditionalRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_add_particles2(self, ps)

    def set_particles1(self, ps):
        r"""set_particles1(MembraneSurfaceLocationConditionalRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_set_particles1(self, ps)

    def set_particles2(self, ps):
        r"""set_particles2(MembraneSurfaceLocationConditionalRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_set_particles2(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(MembraneSurfaceLocationConditionalRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(MembraneSurfaceLocationConditionalRestraint self) -> VersionInfo"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_MembraneSurfaceLocationConditionalRestraint

    def __str__(self):
        r"""__str__(MembraneSurfaceLocationConditionalRestraint self) -> std::string"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(MembraneSurfaceLocationConditionalRestraint self) -> std::string"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(MembraneSurfaceLocationConditionalRestraint self) -> PyObject *"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(MembraneSurfaceLocationConditionalRestraint self, PyObject * p)"""
        return _IMP_npc.MembraneSurfaceLocationConditionalRestraint__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)


# Register MembraneSurfaceLocationConditionalRestraint in _IMP_npc:
_IMP_npc.MembraneSurfaceLocationConditionalRestraint_swigregister(MembraneSurfaceLocationConditionalRestraint)
class MembraneExclusionRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::MembraneExclusionRestraint 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__(MembraneExclusionRestraint self, Model m, _SingletonContainerAdaptor sc, double R, double r, double thickness, double sigma=2) -> MembraneExclusionRestraint
        __init__(MembraneExclusionRestraint self, Model m, double R, double r, double thickness, double sigma=2) -> MembraneExclusionRestraint
        __init__(MembraneExclusionRestraint self) -> MembraneExclusionRestraint
        """
        _IMP_npc.MembraneExclusionRestraint_swiginit(self, _IMP_npc.new_MembraneExclusionRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(MembraneExclusionRestraint self, Particle p)"""
        return _IMP_npc.MembraneExclusionRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(MembraneExclusionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneExclusionRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(MembraneExclusionRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.MembraneExclusionRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(MembraneExclusionRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.MembraneExclusionRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(MembraneExclusionRestraint self) -> VersionInfo"""
        return _IMP_npc.MembraneExclusionRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_MembraneExclusionRestraint

    def __str__(self):
        r"""__str__(MembraneExclusionRestraint self) -> std::string"""
        return _IMP_npc.MembraneExclusionRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(MembraneExclusionRestraint self) -> std::string"""
        return _IMP_npc.MembraneExclusionRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(MembraneExclusionRestraint self) -> PyObject *"""
        return _IMP_npc.MembraneExclusionRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(MembraneExclusionRestraint self, PyObject * p)"""
        return _IMP_npc.MembraneExclusionRestraint__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)


# Register MembraneExclusionRestraint in _IMP_npc:
_IMP_npc.MembraneExclusionRestraint_swigregister(MembraneExclusionRestraint)
class PoreSideVolumeLocationRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::PoreSideVolumeLocationRestraint 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__(PoreSideVolumeLocationRestraint self, Model m, _SingletonContainerAdaptor sc, double R, double r, double thickness, bool consider_radius, double sigma=2) -> PoreSideVolumeLocationRestraint
        __init__(PoreSideVolumeLocationRestraint self, Model m, double R, double r, double thickness, bool consider_radius, double sigma=2) -> PoreSideVolumeLocationRestraint
        __init__(PoreSideVolumeLocationRestraint self) -> PoreSideVolumeLocationRestraint
        """
        _IMP_npc.PoreSideVolumeLocationRestraint_swiginit(self, _IMP_npc.new_PoreSideVolumeLocationRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(PoreSideVolumeLocationRestraint self, Particle p)"""
        return _IMP_npc.PoreSideVolumeLocationRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(PoreSideVolumeLocationRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.PoreSideVolumeLocationRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(PoreSideVolumeLocationRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.PoreSideVolumeLocationRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(PoreSideVolumeLocationRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.PoreSideVolumeLocationRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(PoreSideVolumeLocationRestraint self) -> VersionInfo"""
        return _IMP_npc.PoreSideVolumeLocationRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_PoreSideVolumeLocationRestraint

    def __str__(self):
        r"""__str__(PoreSideVolumeLocationRestraint self) -> std::string"""
        return _IMP_npc.PoreSideVolumeLocationRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(PoreSideVolumeLocationRestraint self) -> std::string"""
        return _IMP_npc.PoreSideVolumeLocationRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(PoreSideVolumeLocationRestraint self) -> PyObject *"""
        return _IMP_npc.PoreSideVolumeLocationRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PoreSideVolumeLocationRestraint self, PyObject * p)"""
        return _IMP_npc.PoreSideVolumeLocationRestraint__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)


# Register PoreSideVolumeLocationRestraint in _IMP_npc:
_IMP_npc.PoreSideVolumeLocationRestraint_swigregister(PoreSideVolumeLocationRestraint)
class PerinuclearVolumeLocationRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::PerinuclearVolumeLocationRestraint 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__(PerinuclearVolumeLocationRestraint self, Model m, _SingletonContainerAdaptor sc, double R, double r, double thickness, bool consider_radius, double sigma=2) -> PerinuclearVolumeLocationRestraint
        __init__(PerinuclearVolumeLocationRestraint self, Model m, double R, double r, double thickness, bool consider_radius, double sigma=2) -> PerinuclearVolumeLocationRestraint
        __init__(PerinuclearVolumeLocationRestraint self) -> PerinuclearVolumeLocationRestraint
        """
        _IMP_npc.PerinuclearVolumeLocationRestraint_swiginit(self, _IMP_npc.new_PerinuclearVolumeLocationRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(PerinuclearVolumeLocationRestraint self, Particle p)"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(PerinuclearVolumeLocationRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(PerinuclearVolumeLocationRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(PerinuclearVolumeLocationRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(PerinuclearVolumeLocationRestraint self) -> VersionInfo"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_PerinuclearVolumeLocationRestraint

    def __str__(self):
        r"""__str__(PerinuclearVolumeLocationRestraint self) -> std::string"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(PerinuclearVolumeLocationRestraint self) -> std::string"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(PerinuclearVolumeLocationRestraint self) -> PyObject *"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(PerinuclearVolumeLocationRestraint self, PyObject * p)"""
        return _IMP_npc.PerinuclearVolumeLocationRestraint__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)


# Register PerinuclearVolumeLocationRestraint in _IMP_npc:
_IMP_npc.PerinuclearVolumeLocationRestraint_swigregister(PerinuclearVolumeLocationRestraint)
class AssemblySymmetryByDistanceRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::AssemblySymmetryByDistanceRestraint 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__(AssemblySymmetryByDistanceRestraint self, Model m, _SingletonContainerAdaptor sc, double sigma=4) -> AssemblySymmetryByDistanceRestraint
        __init__(AssemblySymmetryByDistanceRestraint self, Model m, double sigma=4) -> AssemblySymmetryByDistanceRestraint
        __init__(AssemblySymmetryByDistanceRestraint self) -> AssemblySymmetryByDistanceRestraint
        """
        _IMP_npc.AssemblySymmetryByDistanceRestraint_swiginit(self, _IMP_npc.new_AssemblySymmetryByDistanceRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(AssemblySymmetryByDistanceRestraint self, Particle p)"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(AssemblySymmetryByDistanceRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(AssemblySymmetryByDistanceRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(AssemblySymmetryByDistanceRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(AssemblySymmetryByDistanceRestraint self) -> VersionInfo"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_AssemblySymmetryByDistanceRestraint

    def __str__(self):
        r"""__str__(AssemblySymmetryByDistanceRestraint self) -> std::string"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(AssemblySymmetryByDistanceRestraint self) -> std::string"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(AssemblySymmetryByDistanceRestraint self) -> PyObject *"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AssemblySymmetryByDistanceRestraint self, PyObject * p)"""
        return _IMP_npc.AssemblySymmetryByDistanceRestraint__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)


# Register AssemblySymmetryByDistanceRestraint in _IMP_npc:
_IMP_npc.AssemblySymmetryByDistanceRestraint_swigregister(AssemblySymmetryByDistanceRestraint)
class AssemblySymmetryByDihedralRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::AssemblySymmetryByDihedralRestraint 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__(AssemblySymmetryByDihedralRestraint self, Model m, _SingletonContainerAdaptor sc, double sigma=0.1) -> AssemblySymmetryByDihedralRestraint
        __init__(AssemblySymmetryByDihedralRestraint self, Model m, double sigma=0.1) -> AssemblySymmetryByDihedralRestraint
        __init__(AssemblySymmetryByDihedralRestraint self) -> AssemblySymmetryByDihedralRestraint
        """
        _IMP_npc.AssemblySymmetryByDihedralRestraint_swiginit(self, _IMP_npc.new_AssemblySymmetryByDihedralRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(AssemblySymmetryByDihedralRestraint self, Particle p)"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(AssemblySymmetryByDihedralRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(AssemblySymmetryByDihedralRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(AssemblySymmetryByDihedralRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(AssemblySymmetryByDihedralRestraint self) -> VersionInfo"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_AssemblySymmetryByDihedralRestraint

    def __str__(self):
        r"""__str__(AssemblySymmetryByDihedralRestraint self) -> std::string"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(AssemblySymmetryByDihedralRestraint self) -> std::string"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(AssemblySymmetryByDihedralRestraint self) -> PyObject *"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AssemblySymmetryByDihedralRestraint self, PyObject * p)"""
        return _IMP_npc.AssemblySymmetryByDihedralRestraint__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)


# Register AssemblySymmetryByDihedralRestraint in _IMP_npc:
_IMP_npc.AssemblySymmetryByDihedralRestraint_swigregister(AssemblySymmetryByDihedralRestraint)
class ProteinProximityRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::ProteinProximityRestraint 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__(ProteinProximityRestraint self, Model m, _SingletonContainerAdaptor sc, double max_dist, double sigma=0.1) -> ProteinProximityRestraint
        __init__(ProteinProximityRestraint self, Model m, double max_dist, double sigma=0.1) -> ProteinProximityRestraint
        __init__(ProteinProximityRestraint self) -> ProteinProximityRestraint
        """
        _IMP_npc.ProteinProximityRestraint_swiginit(self, _IMP_npc.new_ProteinProximityRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(ProteinProximityRestraint self, Particle p)"""
        return _IMP_npc.ProteinProximityRestraint_add_particle(self, p)

    def add_particles(self, ps):
        r"""add_particles(ProteinProximityRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ProteinProximityRestraint_add_particles(self, ps)

    def set_particles(self, ps):
        r"""set_particles(ProteinProximityRestraint self, IMP::ParticlesTemp const & ps)"""
        return _IMP_npc.ProteinProximityRestraint_set_particles(self, ps)

    def do_get_inputs(self):
        r"""do_get_inputs(ProteinProximityRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.ProteinProximityRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(ProteinProximityRestraint self) -> VersionInfo"""
        return _IMP_npc.ProteinProximityRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_ProteinProximityRestraint

    def __str__(self):
        r"""__str__(ProteinProximityRestraint self) -> std::string"""
        return _IMP_npc.ProteinProximityRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(ProteinProximityRestraint self) -> std::string"""
        return _IMP_npc.ProteinProximityRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(ProteinProximityRestraint self) -> PyObject *"""
        return _IMP_npc.ProteinProximityRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(ProteinProximityRestraint self, PyObject * p)"""
        return _IMP_npc.ProteinProximityRestraint__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)


# Register ProteinProximityRestraint in _IMP_npc:
_IMP_npc.ProteinProximityRestraint_swigregister(ProteinProximityRestraint)
class CompositeRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::CompositeRestraint class."""

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

    def __init__(self, m, ps):
        r"""__init__(CompositeRestraint self, Model m, PairScore ps) -> CompositeRestraint"""
        _IMP_npc.CompositeRestraint_swiginit(self, _IMP_npc.new_CompositeRestraint(m, ps))

    def add_type(self, ps):
        r"""add_type(CompositeRestraint self, IMP::ParticleIndexes ps)"""
        return _IMP_npc.CompositeRestraint_add_type(self, ps)

    def get_connected_pairs(self):
        r"""get_connected_pairs(CompositeRestraint self) -> IMP::ParticleIndexPairs"""
        return _IMP_npc.CompositeRestraint_get_connected_pairs(self)

    def do_get_inputs(self):
        r"""do_get_inputs(CompositeRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.CompositeRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(CompositeRestraint self) -> VersionInfo"""
        return _IMP_npc.CompositeRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_CompositeRestraint

    def __str__(self):
        r"""__str__(CompositeRestraint self) -> std::string"""
        return _IMP_npc.CompositeRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(CompositeRestraint self) -> std::string"""
        return _IMP_npc.CompositeRestraint___repr__(self)

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


# Register CompositeRestraint in _IMP_npc:
_IMP_npc.CompositeRestraint_swigregister(CompositeRestraint)
class MinimumSphereDistancePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npc::MinimumSphereDistancePairScore 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__(MinimumSphereDistancePairScore self, UnaryFunction f, IMP::algebra::Transformation3Ds transforms) -> MinimumSphereDistancePairScore
        __init__(MinimumSphereDistancePairScore self) -> MinimumSphereDistancePairScore
        """
        _IMP_npc.MinimumSphereDistancePairScore_swiginit(self, _IMP_npc.new_MinimumSphereDistancePairScore(*args))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(MinimumSphereDistancePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.MinimumSphereDistancePairScore_do_get_inputs(self, m, pis)

    def get_version_info(self):
        r"""get_version_info(MinimumSphereDistancePairScore self) -> VersionInfo"""
        return _IMP_npc.MinimumSphereDistancePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_MinimumSphereDistancePairScore

    def __str__(self):
        r"""__str__(MinimumSphereDistancePairScore self) -> std::string"""
        return _IMP_npc.MinimumSphereDistancePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(MinimumSphereDistancePairScore self) -> std::string"""
        return _IMP_npc.MinimumSphereDistancePairScore___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(MinimumSphereDistancePairScore self) -> PyObject *"""
        return _IMP_npc.MinimumSphereDistancePairScore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(MinimumSphereDistancePairScore self, PyObject * p)"""
        return _IMP_npc.MinimumSphereDistancePairScore__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)


# Register MinimumSphereDistancePairScore in _IMP_npc:
_IMP_npc.MinimumSphereDistancePairScore_swigregister(MinimumSphereDistancePairScore)

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

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

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

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