npc/__init__.py

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




import typing
import _IMP_npc

import builtins as __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


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 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_BOOST_SYSTEM = _IMP_npc.IMP_KERNEL_HAS_BOOST_SYSTEM

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:
    """@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_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_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_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_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_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_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)

_object_types.append("XAxialPositionLowerRestraint")


def _object_cast_to_XAxialPositionLowerRestraint(o):
    r"""_object_cast_to_XAxialPositionLowerRestraint(Object o) -> XAxialPositionLowerRestraint"""
    return _IMP_npc._object_cast_to_XAxialPositionLowerRestraint(o)

_object_types.append("XAxialPositionRestraint")


def _object_cast_to_XAxialPositionRestraint(o):
    r"""_object_cast_to_XAxialPositionRestraint(Object o) -> XAxialPositionRestraint"""
    return _IMP_npc._object_cast_to_XAxialPositionRestraint(o)

_object_types.append("XAxialPositionUpperRestraint")


def _object_cast_to_XAxialPositionUpperRestraint(o):
    r"""_object_cast_to_XAxialPositionUpperRestraint(Object o) -> XAxialPositionUpperRestraint"""
    return _IMP_npc._object_cast_to_XAxialPositionUpperRestraint(o)

_object_types.append("OverallPositionRestraint")


def _object_cast_to_OverallPositionRestraint(o):
    r"""_object_cast_to_OverallPositionRestraint(Object o) -> OverallPositionRestraint"""
    return _IMP_npc._object_cast_to_OverallPositionRestraint(o)

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


_value_types.append("SlabWithSphericalIndent")


_object_types.append("SlabWithSphericalIndentMBMScore")


def _object_cast_to_SlabWithSphericalIndentMBMScore(o):
    r"""_object_cast_to_SlabWithSphericalIndentMBMScore(Object o) -> SlabWithSphericalIndentMBMScore"""
    return _IMP_npc._object_cast_to_SlabWithSphericalIndentMBMScore(o)

_object_types.append("SlabWithSphericalIndentGeometry")


def _object_cast_to_SlabWithSphericalIndentGeometry(o):
    r"""_object_cast_to_SlabWithSphericalIndentGeometry(Object o) -> SlabWithSphericalIndentGeometry"""
    return _IMP_npc._object_cast_to_SlabWithSphericalIndentGeometry(o)

_object_types.append("SphericalIndentSurfaceDepthPairScore")


def _object_cast_to_SphericalIndentSurfaceDepthPairScore(o):
    r"""_object_cast_to_SphericalIndentSurfaceDepthPairScore(Object o) -> SphericalIndentSurfaceDepthPairScore"""
    return _IMP_npc._object_cast_to_SphericalIndentSurfaceDepthPairScore(o)

_object_types.append("SlabWithToroidalPoreMBMScore")


def _object_cast_to_SlabWithToroidalPoreMBMScore(o):
    r"""_object_cast_to_SlabWithToroidalPoreMBMScore(Object o) -> SlabWithToroidalPoreMBMScore"""
    return _IMP_npc._object_cast_to_SlabWithToroidalPoreMBMScore(o)

_object_types.append("SlabWithToroidalPoreGoPairScore")


def _object_cast_to_SlabWithToroidalPoreGoPairScore(o):
    r"""_object_cast_to_SlabWithToroidalPoreGoPairScore(Object o) -> SlabWithToroidalPoreGoPairScore"""
    return _IMP_npc._object_cast_to_SlabWithToroidalPoreGoPairScore(o)

_object_types.append("ToroidalPoreSurfaceDepthPairScore")


def _object_cast_to_ToroidalPoreSurfaceDepthPairScore(o):
    r"""_object_cast_to_ToroidalPoreSurfaceDepthPairScore(Object o) -> ToroidalPoreSurfaceDepthPairScore"""
    return _IMP_npc._object_cast_to_ToroidalPoreSurfaceDepthPairScore(o)

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


_value_types.append("SlabWithPore")


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


_value_types.append("SlabWithToroidalPore")


_object_types.append("SlabWithToroidalPoreWireGeometry")


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

    def add_particle(self, p):
        r"""add_particle(XAxialPositionRestraint self, Particle p)"""
        return _IMP_npc.XAxialPositionRestraint_add_particle(self, p)

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

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

    def do_get_inputs(self):
        r"""do_get_inputs(XAxialPositionRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.XAxialPositionRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(XAxialPositionRestraint self) -> VersionInfo"""
        return _IMP_npc.XAxialPositionRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_XAxialPositionRestraint

    def __str__(self):
        r"""__str__(XAxialPositionRestraint self) -> std::string"""
        return _IMP_npc.XAxialPositionRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(XAxialPositionRestraint self) -> std::string"""
        return _IMP_npc.XAxialPositionRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(XAxialPositionRestraint self) -> PyObject *"""
        return _IMP_npc.XAxialPositionRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XAxialPositionRestraint self, PyObject * p)"""
        return _IMP_npc.XAxialPositionRestraint__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 XAxialPositionRestraint in _IMP_npc:
_IMP_npc.XAxialPositionRestraint_swigregister(XAxialPositionRestraint)
class XAxialPositionLowerRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::XAxialPositionLowerRestraint 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__(XAxialPositionLowerRestraint self, Model m, _SingletonContainerAdaptor sc, double lower_bound, bool consider_radius, double sigma=1) -> XAxialPositionLowerRestraint
        __init__(XAxialPositionLowerRestraint self, Model m, double lower_bound, bool consider_radius, double sigma=1) -> XAxialPositionLowerRestraint
        __init__(XAxialPositionLowerRestraint self) -> XAxialPositionLowerRestraint
        """
        _IMP_npc.XAxialPositionLowerRestraint_swiginit(self, _IMP_npc.new_XAxialPositionLowerRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(XAxialPositionLowerRestraint self, Particle p)"""
        return _IMP_npc.XAxialPositionLowerRestraint_add_particle(self, p)

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

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

    def do_get_inputs(self):
        r"""do_get_inputs(XAxialPositionLowerRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.XAxialPositionLowerRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(XAxialPositionLowerRestraint self) -> VersionInfo"""
        return _IMP_npc.XAxialPositionLowerRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_XAxialPositionLowerRestraint

    def __str__(self):
        r"""__str__(XAxialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.XAxialPositionLowerRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(XAxialPositionLowerRestraint self) -> std::string"""
        return _IMP_npc.XAxialPositionLowerRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(XAxialPositionLowerRestraint self) -> PyObject *"""
        return _IMP_npc.XAxialPositionLowerRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XAxialPositionLowerRestraint self, PyObject * p)"""
        return _IMP_npc.XAxialPositionLowerRestraint__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 XAxialPositionLowerRestraint in _IMP_npc:
_IMP_npc.XAxialPositionLowerRestraint_swigregister(XAxialPositionLowerRestraint)
class XAxialPositionUpperRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::XAxialPositionUpperRestraint 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__(XAxialPositionUpperRestraint self, Model m, _SingletonContainerAdaptor sc, double upper_bound, bool consider_radius, double sigma=1) -> XAxialPositionUpperRestraint
        __init__(XAxialPositionUpperRestraint self, Model m, double upper_bound, bool consider_radius, double sigma=1) -> XAxialPositionUpperRestraint
        __init__(XAxialPositionUpperRestraint self) -> XAxialPositionUpperRestraint
        """
        _IMP_npc.XAxialPositionUpperRestraint_swiginit(self, _IMP_npc.new_XAxialPositionUpperRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(XAxialPositionUpperRestraint self, Particle p)"""
        return _IMP_npc.XAxialPositionUpperRestraint_add_particle(self, p)

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

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

    def do_get_inputs(self):
        r"""do_get_inputs(XAxialPositionUpperRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.XAxialPositionUpperRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(XAxialPositionUpperRestraint self) -> VersionInfo"""
        return _IMP_npc.XAxialPositionUpperRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_XAxialPositionUpperRestraint

    def __str__(self):
        r"""__str__(XAxialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.XAxialPositionUpperRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(XAxialPositionUpperRestraint self) -> std::string"""
        return _IMP_npc.XAxialPositionUpperRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(XAxialPositionUpperRestraint self) -> PyObject *"""
        return _IMP_npc.XAxialPositionUpperRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(XAxialPositionUpperRestraint self, PyObject * p)"""
        return _IMP_npc.XAxialPositionUpperRestraint__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 XAxialPositionUpperRestraint in _IMP_npc:
_IMP_npc.XAxialPositionUpperRestraint_swigregister(XAxialPositionUpperRestraint)
class OverallPositionRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::npc::OverallPositionRestraint 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__(OverallPositionRestraint self, Model m, _SingletonContainerAdaptor sc, double x_start, double y_start, double z_start, double tolerance, bool consider_radius, double sigma=1) -> OverallPositionRestraint
        __init__(OverallPositionRestraint self, Model m, double x_start, double y_start, double z_start, double tolerance, bool consider_radius, double sigma=1) -> OverallPositionRestraint
        __init__(OverallPositionRestraint self) -> OverallPositionRestraint
        """
        _IMP_npc.OverallPositionRestraint_swiginit(self, _IMP_npc.new_OverallPositionRestraint(*args))

    def add_particle(self, p):
        r"""add_particle(OverallPositionRestraint self, Particle p)"""
        return _IMP_npc.OverallPositionRestraint_add_particle(self, p)

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

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

    def do_get_inputs(self):
        r"""do_get_inputs(OverallPositionRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_npc.OverallPositionRestraint_do_get_inputs(self)

    def get_version_info(self):
        r"""get_version_info(OverallPositionRestraint self) -> VersionInfo"""
        return _IMP_npc.OverallPositionRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_OverallPositionRestraint

    def __str__(self):
        r"""__str__(OverallPositionRestraint self) -> std::string"""
        return _IMP_npc.OverallPositionRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(OverallPositionRestraint self) -> std::string"""
        return _IMP_npc.OverallPositionRestraint___repr__(self)

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


    def _get_as_binary(self):
        r"""_get_as_binary(OverallPositionRestraint self) -> PyObject *"""
        return _IMP_npc.OverallPositionRestraint__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(OverallPositionRestraint self, PyObject * p)"""
        return _IMP_npc.OverallPositionRestraint__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 OverallPositionRestraint in _IMP_npc:
_IMP_npc.OverallPositionRestraint_swigregister(OverallPositionRestraint)
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 evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(MinimumSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.MinimumSphereDistancePairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(MinimumSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.MinimumSphereDistancePairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(MinimumSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.MinimumSphereDistancePairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(MinimumSphereDistancePairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.MinimumSphereDistancePairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    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)
class SlabWithSphericalIndent(IMP.Decorator):
    r"""Proxy of C++ IMP::npc::SlabWithSphericalIndent class."""

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

    def set_sphere_radius(self, R):
        r"""set_sphere_radius(SlabWithSphericalIndent self, double R)"""
        return _IMP_npc.SlabWithSphericalIndent_set_sphere_radius(self, R)

    def set_sphere_depth(self, h):
        r"""set_sphere_depth(SlabWithSphericalIndent self, double h)"""
        return _IMP_npc.SlabWithSphericalIndent_set_sphere_depth(self, h)

    def get_sphere_radius(self):
        r"""get_sphere_radius(SlabWithSphericalIndent self) -> IMP::Float"""
        return _IMP_npc.SlabWithSphericalIndent_get_sphere_radius(self)

    def get_sphere_depth(self):
        r"""get_sphere_depth(SlabWithSphericalIndent self) -> IMP::Float"""
        return _IMP_npc.SlabWithSphericalIndent_get_sphere_depth(self)

    @staticmethod
    def get_sphere_radius_key():
        r"""get_sphere_radius_key() -> FloatKey"""
        return _IMP_npc.SlabWithSphericalIndent_get_sphere_radius_key()

    @staticmethod
    def get_sphere_depth_key():
        r"""get_sphere_depth_key() -> FloatKey"""
        return _IMP_npc.SlabWithSphericalIndent_get_sphere_depth_key()

    def get_decorator_name(self):
        r"""get_decorator_name(SlabWithSphericalIndent self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndent_get_decorator_name(self)

    def set_decorator_name(self, nm):
        r"""set_decorator_name(SlabWithSphericalIndent self, std::string nm)"""
        return _IMP_npc.SlabWithSphericalIndent_set_decorator_name(self, nm)

    def __init__(self, *args):
        r"""
        __init__(SlabWithSphericalIndent self) -> SlabWithSphericalIndent
        __init__(SlabWithSphericalIndent self, Model m, ParticleIndex id) -> SlabWithSphericalIndent
        __init__(SlabWithSphericalIndent self, _ParticleAdaptor d) -> SlabWithSphericalIndent
        """
        _IMP_npc.SlabWithSphericalIndent_swiginit(self, _IMP_npc.new_SlabWithSphericalIndent(*args))

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent_get_is_setup(*args)

    def show(self, *args):
        r"""show(SlabWithSphericalIndent self, _ostream out=std::cout)"""
        return _IMP_npc.SlabWithSphericalIndent_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, double R, double h) -> SlabWithSphericalIndent
        setup_particle(_ParticleAdaptor pa, double R, double h) -> SlabWithSphericalIndent
        """
        return _IMP_npc.SlabWithSphericalIndent_setup_particle(*args)

    def add_attribute(self, *args):
        r"""
        add_attribute(SlabWithSphericalIndent self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(SlabWithSphericalIndent self, FloatKey a0, IMP::Float a1)
        add_attribute(SlabWithSphericalIndent self, IntKey a0, IMP::Int a1)
        add_attribute(SlabWithSphericalIndent self, FloatsKey a0, IMP::Floats a1)
        add_attribute(SlabWithSphericalIndent self, IntsKey a0, IMP::Ints a1)
        add_attribute(SlabWithSphericalIndent self, StringKey a0, IMP::String a1)
        add_attribute(SlabWithSphericalIndent self, ParticleIndexKey a0, Particle a1)
        add_attribute(SlabWithSphericalIndent self, ObjectKey a0, Object a1)
        add_attribute(SlabWithSphericalIndent self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(SlabWithSphericalIndent self, SparseIntKey a0, IMP::Int a1)
        add_attribute(SlabWithSphericalIndent self, SparseStringKey a0, IMP::String a1)
        add_attribute(SlabWithSphericalIndent self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_npc.SlabWithSphericalIndent_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        get_value(SlabWithSphericalIndent self, FloatKey a0) -> IMP::Float
        get_value(SlabWithSphericalIndent self, IntKey a0) -> IMP::Int
        get_value(SlabWithSphericalIndent self, FloatsKey a0) -> IMP::Floats
        get_value(SlabWithSphericalIndent self, IntsKey a0) -> IMP::Ints
        get_value(SlabWithSphericalIndent self, StringKey a0) -> IMP::String
        get_value(SlabWithSphericalIndent self, ParticleIndexKey a0) -> Particle
        get_value(SlabWithSphericalIndent self, ObjectKey a0) -> Object
        get_value(SlabWithSphericalIndent self, SparseFloatKey a0) -> IMP::Float
        get_value(SlabWithSphericalIndent self, SparseIntKey a0) -> IMP::Int
        get_value(SlabWithSphericalIndent self, SparseStringKey a0) -> IMP::String
        get_value(SlabWithSphericalIndent self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_npc.SlabWithSphericalIndent_get_value(self, *args)

    def set_value(self, *args):
        r"""
        set_value(SlabWithSphericalIndent self, FloatKey a0, IMP::Float a1)
        set_value(SlabWithSphericalIndent self, IntKey a0, IMP::Int a1)
        set_value(SlabWithSphericalIndent self, FloatsKey a0, IMP::Floats a1)
        set_value(SlabWithSphericalIndent self, IntsKey a0, IMP::Ints a1)
        set_value(SlabWithSphericalIndent self, StringKey a0, IMP::String a1)
        set_value(SlabWithSphericalIndent self, ParticleIndexKey a0, Particle a1)
        set_value(SlabWithSphericalIndent self, ObjectKey a0, Object a1)
        set_value(SlabWithSphericalIndent self, SparseFloatKey a0, IMP::Float a1)
        set_value(SlabWithSphericalIndent self, SparseIntKey a0, IMP::Int a1)
        set_value(SlabWithSphericalIndent self, SparseStringKey a0, IMP::String a1)
        set_value(SlabWithSphericalIndent self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_npc.SlabWithSphericalIndent_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        remove_attribute(SlabWithSphericalIndent self, FloatKey a0)
        remove_attribute(SlabWithSphericalIndent self, IntKey a0)
        remove_attribute(SlabWithSphericalIndent self, FloatsKey a0)
        remove_attribute(SlabWithSphericalIndent self, IntsKey a0)
        remove_attribute(SlabWithSphericalIndent self, StringKey a0)
        remove_attribute(SlabWithSphericalIndent self, ParticleIndexKey a0)
        remove_attribute(SlabWithSphericalIndent self, ObjectKey a0)
        remove_attribute(SlabWithSphericalIndent self, SparseFloatKey a0)
        remove_attribute(SlabWithSphericalIndent self, SparseIntKey a0)
        remove_attribute(SlabWithSphericalIndent self, SparseStringKey a0)
        remove_attribute(SlabWithSphericalIndent self, SparseParticleIndexKey a0)
        """
        return _IMP_npc.SlabWithSphericalIndent_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        has_attribute(SlabWithSphericalIndent self, FloatKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, IntKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, FloatsKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, IntsKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, StringKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, ParticleIndexKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, ObjectKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, SparseFloatKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, SparseIntKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, SparseStringKey a0) -> bool
        has_attribute(SlabWithSphericalIndent self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(SlabWithSphericalIndent self, FloatKey a0) -> double"""
        return _IMP_npc.SlabWithSphericalIndent_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(SlabWithSphericalIndent self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndent_get_name(self)

    def clear_caches(self):
        r"""clear_caches(SlabWithSphericalIndent self)"""
        return _IMP_npc.SlabWithSphericalIndent_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(SlabWithSphericalIndent self, std::string a0)"""
        return _IMP_npc.SlabWithSphericalIndent_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(SlabWithSphericalIndent self, IMP::CheckLevel a0)"""
        return _IMP_npc.SlabWithSphericalIndent_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(SlabWithSphericalIndent self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_npc.SlabWithSphericalIndent_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(SlabWithSphericalIndent self, FloatKey a0, bool a1)"""
        return _IMP_npc.SlabWithSphericalIndent_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(SlabWithSphericalIndent self, FloatKey a0) -> bool"""
        return _IMP_npc.SlabWithSphericalIndent_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(SlabWithSphericalIndent self) -> IMP::CheckLevel"""
        return _IMP_npc.SlabWithSphericalIndent_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(SlabWithSphericalIndent self, SlabWithSphericalIndent o) -> bool
        __eq__(SlabWithSphericalIndent self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(SlabWithSphericalIndent self, SlabWithSphericalIndent o) -> bool
        __ne__(SlabWithSphericalIndent self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(SlabWithSphericalIndent self, SlabWithSphericalIndent o) -> bool
        __le__(SlabWithSphericalIndent self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(SlabWithSphericalIndent self, SlabWithSphericalIndent o) -> bool
        __lt__(SlabWithSphericalIndent self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(SlabWithSphericalIndent self, SlabWithSphericalIndent o) -> bool
        __ge__(SlabWithSphericalIndent self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(SlabWithSphericalIndent self, SlabWithSphericalIndent o) -> bool
        __gt__(SlabWithSphericalIndent self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithSphericalIndent___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(SlabWithSphericalIndent self) -> std::size_t"""
        return _IMP_npc.SlabWithSphericalIndent___hash__(self)

    def __str__(self):
        r"""__str__(SlabWithSphericalIndent self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndent___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithSphericalIndent self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndent___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(SlabWithSphericalIndent self) -> PyObject *"""
        return _IMP_npc.SlabWithSphericalIndent__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SlabWithSphericalIndent self, PyObject * p)"""
        return _IMP_npc.SlabWithSphericalIndent__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_npc.delete_SlabWithSphericalIndent

# Register SlabWithSphericalIndent in _IMP_npc:
_IMP_npc.SlabWithSphericalIndent_swigregister(SlabWithSphericalIndent)
class SlabWithSphericalIndentMBMScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npc::SlabWithSphericalIndentMBMScore class."""

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

    def __init__(self, x0, k):
        r"""__init__(SlabWithSphericalIndentMBMScore self, double x0, double k) -> SlabWithSphericalIndentMBMScore"""
        _IMP_npc.SlabWithSphericalIndentMBMScore_swiginit(self, _IMP_npc.new_SlabWithSphericalIndentMBMScore(x0, k))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SlabWithSphericalIndentMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithSphericalIndentMBMScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(SlabWithSphericalIndentMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithSphericalIndentMBMScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(SlabWithSphericalIndentMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithSphericalIndentMBMScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(SlabWithSphericalIndentMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithSphericalIndentMBMScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(SlabWithSphericalIndentMBMScore self) -> VersionInfo"""
        return _IMP_npc.SlabWithSphericalIndentMBMScore_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_SlabWithSphericalIndentMBMScore

    def __str__(self):
        r"""__str__(SlabWithSphericalIndentMBMScore self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndentMBMScore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithSphericalIndentMBMScore self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndentMBMScore___repr__(self)

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


# Register SlabWithSphericalIndentMBMScore in _IMP_npc:
_IMP_npc.SlabWithSphericalIndentMBMScore_swigregister(SlabWithSphericalIndentMBMScore)
class SlabWithSphericalIndentGeometry(IMP.display.Geometry):
    r"""Proxy of C++ IMP::npc::SlabWithSphericalIndentGeometry class."""

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

    def __init__(self, radius, depth, length):
        r"""__init__(SlabWithSphericalIndentGeometry self, double radius, double depth, double length) -> SlabWithSphericalIndentGeometry"""
        _IMP_npc.SlabWithSphericalIndentGeometry_swiginit(self, _IMP_npc.new_SlabWithSphericalIndentGeometry(radius, depth, length))

    def get_version_info(self):
        r"""get_version_info(SlabWithSphericalIndentGeometry self) -> VersionInfo"""
        return _IMP_npc.SlabWithSphericalIndentGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_SlabWithSphericalIndentGeometry

    def __str__(self):
        r"""__str__(SlabWithSphericalIndentGeometry self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndentGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithSphericalIndentGeometry self) -> std::string"""
        return _IMP_npc.SlabWithSphericalIndentGeometry___repr__(self)

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


# Register SlabWithSphericalIndentGeometry in _IMP_npc:
_IMP_npc.SlabWithSphericalIndentGeometry_swigregister(SlabWithSphericalIndentGeometry)
class SphericalIndentSurfaceDepthPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npc::SphericalIndentSurfaceDepthPairScore class."""

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

    def __init__(self, k):
        r"""__init__(SphericalIndentSurfaceDepthPairScore self, double k) -> SphericalIndentSurfaceDepthPairScore"""
        _IMP_npc.SphericalIndentSurfaceDepthPairScore_swiginit(self, _IMP_npc.new_SphericalIndentSurfaceDepthPairScore(k))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SphericalIndentSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SphericalIndentSurfaceDepthPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(SphericalIndentSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SphericalIndentSurfaceDepthPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(SphericalIndentSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SphericalIndentSurfaceDepthPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(SphericalIndentSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SphericalIndentSurfaceDepthPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(SphericalIndentSurfaceDepthPairScore self) -> VersionInfo"""
        return _IMP_npc.SphericalIndentSurfaceDepthPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_SphericalIndentSurfaceDepthPairScore

    def __str__(self):
        r"""__str__(SphericalIndentSurfaceDepthPairScore self) -> std::string"""
        return _IMP_npc.SphericalIndentSurfaceDepthPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(SphericalIndentSurfaceDepthPairScore self) -> std::string"""
        return _IMP_npc.SphericalIndentSurfaceDepthPairScore___repr__(self)

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


# Register SphericalIndentSurfaceDepthPairScore in _IMP_npc:
_IMP_npc.SphericalIndentSurfaceDepthPairScore_swigregister(SphericalIndentSurfaceDepthPairScore)
class SlabWithToroidalPoreMBMScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npc::SlabWithToroidalPoreMBMScore class."""

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

    def __init__(self, x0_upper, x0_lower, k):
        r"""__init__(SlabWithToroidalPoreMBMScore self, double x0_upper, double x0_lower, double k) -> SlabWithToroidalPoreMBMScore"""
        _IMP_npc.SlabWithToroidalPoreMBMScore_swiginit(self, _IMP_npc.new_SlabWithToroidalPoreMBMScore(x0_upper, x0_lower, k))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SlabWithToroidalPoreMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreMBMScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(SlabWithToroidalPoreMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreMBMScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(SlabWithToroidalPoreMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreMBMScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(SlabWithToroidalPoreMBMScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreMBMScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(SlabWithToroidalPoreMBMScore self) -> VersionInfo"""
        return _IMP_npc.SlabWithToroidalPoreMBMScore_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_SlabWithToroidalPoreMBMScore

    def __str__(self):
        r"""__str__(SlabWithToroidalPoreMBMScore self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPoreMBMScore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithToroidalPoreMBMScore self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPoreMBMScore___repr__(self)

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


# Register SlabWithToroidalPoreMBMScore in _IMP_npc:
_IMP_npc.SlabWithToroidalPoreMBMScore_swigregister(SlabWithToroidalPoreMBMScore)
class SlabWithToroidalPoreGoPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npc::SlabWithToroidalPoreGoPairScore class."""

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

    def __init__(self, x0, k):
        r"""__init__(SlabWithToroidalPoreGoPairScore self, double x0, double k) -> SlabWithToroidalPoreGoPairScore"""
        _IMP_npc.SlabWithToroidalPoreGoPairScore_swiginit(self, _IMP_npc.new_SlabWithToroidalPoreGoPairScore(x0, k))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SlabWithToroidalPoreGoPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreGoPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(SlabWithToroidalPoreGoPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreGoPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(SlabWithToroidalPoreGoPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreGoPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(SlabWithToroidalPoreGoPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.SlabWithToroidalPoreGoPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(SlabWithToroidalPoreGoPairScore self) -> VersionInfo"""
        return _IMP_npc.SlabWithToroidalPoreGoPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_SlabWithToroidalPoreGoPairScore

    def __str__(self):
        r"""__str__(SlabWithToroidalPoreGoPairScore self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPoreGoPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithToroidalPoreGoPairScore self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPoreGoPairScore___repr__(self)

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


# Register SlabWithToroidalPoreGoPairScore in _IMP_npc:
_IMP_npc.SlabWithToroidalPoreGoPairScore_swigregister(SlabWithToroidalPoreGoPairScore)
class ToroidalPoreSurfaceDepthPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npc::ToroidalPoreSurfaceDepthPairScore class."""

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

    def __init__(self, k):
        r"""__init__(ToroidalPoreSurfaceDepthPairScore self, double k) -> ToroidalPoreSurfaceDepthPairScore"""
        _IMP_npc.ToroidalPoreSurfaceDepthPairScore_swiginit(self, _IMP_npc.new_ToroidalPoreSurfaceDepthPairScore(k))

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

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(ToroidalPoreSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.ToroidalPoreSurfaceDepthPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked=False):
        r"""evaluate_indexes_scores(ToroidalPoreSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.ToroidalPoreSurfaceDepthPairScore_evaluate_indexes_scores(self, m, p, da, lower_bound, upper_bound, score, all_indexes_checked)

    def evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked=False):
        r"""evaluate_indexes_delta(ToroidalPoreSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, std::vector< double,std::allocator< double > > & score, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.ToroidalPoreSurfaceDepthPairScore_evaluate_indexes_delta(self, m, p, da, indexes, score, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(ToroidalPoreSurfaceDepthPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npc.ToroidalPoreSurfaceDepthPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(ToroidalPoreSurfaceDepthPairScore self) -> VersionInfo"""
        return _IMP_npc.ToroidalPoreSurfaceDepthPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_ToroidalPoreSurfaceDepthPairScore

    def __str__(self):
        r"""__str__(ToroidalPoreSurfaceDepthPairScore self) -> std::string"""
        return _IMP_npc.ToroidalPoreSurfaceDepthPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(ToroidalPoreSurfaceDepthPairScore self) -> std::string"""
        return _IMP_npc.ToroidalPoreSurfaceDepthPairScore___repr__(self)

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


# Register ToroidalPoreSurfaceDepthPairScore in _IMP_npc:
_IMP_npc.ToroidalPoreSurfaceDepthPairScore_swigregister(ToroidalPoreSurfaceDepthPairScore)
class SlabWithPore(IMP.Decorator):
    r"""Proxy of C++ IMP::npc::SlabWithPore 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__(SlabWithPore self) -> SlabWithPore
        __init__(SlabWithPore self, Model m, ParticleIndex id) -> SlabWithPore
        __init__(SlabWithPore self, _ParticleAdaptor d) -> SlabWithPore
        """
        _IMP_npc.SlabWithPore_swiginit(self, _IMP_npc.new_SlabWithPore(*args))

    def show(self, *args):
        r"""show(SlabWithPore self, _ostream out=std::cout)"""
        return _IMP_npc.SlabWithPore_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, double thickness, double pore_radius) -> SlabWithPore
        setup_particle(_ParticleAdaptor pa, double thickness, double pore_radius) -> SlabWithPore
        """
        return _IMP_npc.SlabWithPore_setup_particle(*args)

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_npc.SlabWithPore_get_is_setup(*args)

    def set_thickness(self, thickness):
        r"""set_thickness(SlabWithPore self, double thickness)"""
        return _IMP_npc.SlabWithPore_set_thickness(self, thickness)

    def get_thickness(self):
        r"""get_thickness(SlabWithPore self) -> IMP::Float"""
        return _IMP_npc.SlabWithPore_get_thickness(self)

    def get_pore_radius(self):
        r"""get_pore_radius(SlabWithPore self) -> IMP::Float"""
        return _IMP_npc.SlabWithPore_get_pore_radius(self)

    def set_pore_radius(self, r):
        r"""set_pore_radius(SlabWithPore self, double r)"""
        return _IMP_npc.SlabWithPore_set_pore_radius(self, r)

    def add_to_pore_radius_derivative(self, v, d):
        r"""add_to_pore_radius_derivative(SlabWithPore self, double v, DerivativeAccumulator d)"""
        return _IMP_npc.SlabWithPore_add_to_pore_radius_derivative(self, v, d)

    def get_pore_radius_is_optimized(self):
        r"""get_pore_radius_is_optimized(SlabWithPore self) -> bool"""
        return _IMP_npc.SlabWithPore_get_pore_radius_is_optimized(self)

    def set_pore_radius_is_optimized(self, tf):
        r"""set_pore_radius_is_optimized(SlabWithPore self, bool tf)"""
        return _IMP_npc.SlabWithPore_set_pore_radius_is_optimized(self, tf)

    @staticmethod
    def get_thickness_key():
        r"""get_thickness_key() -> FloatKey"""
        return _IMP_npc.SlabWithPore_get_thickness_key()

    @staticmethod
    def get_pore_radius_key():
        r"""get_pore_radius_key() -> FloatKey"""
        return _IMP_npc.SlabWithPore_get_pore_radius_key()

    def add_attribute(self, *args):
        r"""
        add_attribute(SlabWithPore self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(SlabWithPore self, FloatKey a0, IMP::Float a1)
        add_attribute(SlabWithPore self, IntKey a0, IMP::Int a1)
        add_attribute(SlabWithPore self, FloatsKey a0, IMP::Floats a1)
        add_attribute(SlabWithPore self, IntsKey a0, IMP::Ints a1)
        add_attribute(SlabWithPore self, StringKey a0, IMP::String a1)
        add_attribute(SlabWithPore self, ParticleIndexKey a0, Particle a1)
        add_attribute(SlabWithPore self, ObjectKey a0, Object a1)
        add_attribute(SlabWithPore self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(SlabWithPore self, SparseIntKey a0, IMP::Int a1)
        add_attribute(SlabWithPore self, SparseStringKey a0, IMP::String a1)
        add_attribute(SlabWithPore self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_npc.SlabWithPore_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        get_value(SlabWithPore self, FloatKey a0) -> IMP::Float
        get_value(SlabWithPore self, IntKey a0) -> IMP::Int
        get_value(SlabWithPore self, FloatsKey a0) -> IMP::Floats
        get_value(SlabWithPore self, IntsKey a0) -> IMP::Ints
        get_value(SlabWithPore self, StringKey a0) -> IMP::String
        get_value(SlabWithPore self, ParticleIndexKey a0) -> Particle
        get_value(SlabWithPore self, ObjectKey a0) -> Object
        get_value(SlabWithPore self, SparseFloatKey a0) -> IMP::Float
        get_value(SlabWithPore self, SparseIntKey a0) -> IMP::Int
        get_value(SlabWithPore self, SparseStringKey a0) -> IMP::String
        get_value(SlabWithPore self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_npc.SlabWithPore_get_value(self, *args)

    def set_value(self, *args):
        r"""
        set_value(SlabWithPore self, FloatKey a0, IMP::Float a1)
        set_value(SlabWithPore self, IntKey a0, IMP::Int a1)
        set_value(SlabWithPore self, FloatsKey a0, IMP::Floats a1)
        set_value(SlabWithPore self, IntsKey a0, IMP::Ints a1)
        set_value(SlabWithPore self, StringKey a0, IMP::String a1)
        set_value(SlabWithPore self, ParticleIndexKey a0, Particle a1)
        set_value(SlabWithPore self, ObjectKey a0, Object a1)
        set_value(SlabWithPore self, SparseFloatKey a0, IMP::Float a1)
        set_value(SlabWithPore self, SparseIntKey a0, IMP::Int a1)
        set_value(SlabWithPore self, SparseStringKey a0, IMP::String a1)
        set_value(SlabWithPore self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_npc.SlabWithPore_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        remove_attribute(SlabWithPore self, FloatKey a0)
        remove_attribute(SlabWithPore self, IntKey a0)
        remove_attribute(SlabWithPore self, FloatsKey a0)
        remove_attribute(SlabWithPore self, IntsKey a0)
        remove_attribute(SlabWithPore self, StringKey a0)
        remove_attribute(SlabWithPore self, ParticleIndexKey a0)
        remove_attribute(SlabWithPore self, ObjectKey a0)
        remove_attribute(SlabWithPore self, SparseFloatKey a0)
        remove_attribute(SlabWithPore self, SparseIntKey a0)
        remove_attribute(SlabWithPore self, SparseStringKey a0)
        remove_attribute(SlabWithPore self, SparseParticleIndexKey a0)
        """
        return _IMP_npc.SlabWithPore_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        has_attribute(SlabWithPore self, FloatKey a0) -> bool
        has_attribute(SlabWithPore self, IntKey a0) -> bool
        has_attribute(SlabWithPore self, FloatsKey a0) -> bool
        has_attribute(SlabWithPore self, IntsKey a0) -> bool
        has_attribute(SlabWithPore self, StringKey a0) -> bool
        has_attribute(SlabWithPore self, ParticleIndexKey a0) -> bool
        has_attribute(SlabWithPore self, ObjectKey a0) -> bool
        has_attribute(SlabWithPore self, SparseFloatKey a0) -> bool
        has_attribute(SlabWithPore self, SparseIntKey a0) -> bool
        has_attribute(SlabWithPore self, SparseStringKey a0) -> bool
        has_attribute(SlabWithPore self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_npc.SlabWithPore_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(SlabWithPore self, FloatKey a0) -> double"""
        return _IMP_npc.SlabWithPore_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(SlabWithPore self) -> std::string"""
        return _IMP_npc.SlabWithPore_get_name(self)

    def clear_caches(self):
        r"""clear_caches(SlabWithPore self)"""
        return _IMP_npc.SlabWithPore_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(SlabWithPore self, std::string a0)"""
        return _IMP_npc.SlabWithPore_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(SlabWithPore self, IMP::CheckLevel a0)"""
        return _IMP_npc.SlabWithPore_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(SlabWithPore self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_npc.SlabWithPore_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(SlabWithPore self, FloatKey a0, bool a1)"""
        return _IMP_npc.SlabWithPore_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(SlabWithPore self, FloatKey a0) -> bool"""
        return _IMP_npc.SlabWithPore_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(SlabWithPore self) -> IMP::CheckLevel"""
        return _IMP_npc.SlabWithPore_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(SlabWithPore self, SlabWithPore o) -> bool
        __eq__(SlabWithPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithPore___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(SlabWithPore self, SlabWithPore o) -> bool
        __ne__(SlabWithPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithPore___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(SlabWithPore self, SlabWithPore o) -> bool
        __le__(SlabWithPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithPore___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(SlabWithPore self, SlabWithPore o) -> bool
        __lt__(SlabWithPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithPore___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(SlabWithPore self, SlabWithPore o) -> bool
        __ge__(SlabWithPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithPore___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(SlabWithPore self, SlabWithPore o) -> bool
        __gt__(SlabWithPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithPore___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(SlabWithPore self) -> std::size_t"""
        return _IMP_npc.SlabWithPore___hash__(self)

    def __str__(self):
        r"""__str__(SlabWithPore self) -> std::string"""
        return _IMP_npc.SlabWithPore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithPore self) -> std::string"""
        return _IMP_npc.SlabWithPore___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(SlabWithPore self) -> PyObject *"""
        return _IMP_npc.SlabWithPore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SlabWithPore self, PyObject * p)"""
        return _IMP_npc.SlabWithPore__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_npc.delete_SlabWithPore

# Register SlabWithPore in _IMP_npc:
_IMP_npc.SlabWithPore_swigregister(SlabWithPore)
class SlabWithToroidalPore(SlabWithPore):
    r"""Proxy of C++ IMP::npc::SlabWithToroidalPore 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__(SlabWithToroidalPore self) -> SlabWithToroidalPore
        __init__(SlabWithToroidalPore self, Model m, ParticleIndex id) -> SlabWithToroidalPore
        __init__(SlabWithToroidalPore self, _ParticleAdaptor d) -> SlabWithToroidalPore
        """
        _IMP_npc.SlabWithToroidalPore_swiginit(self, _IMP_npc.new_SlabWithToroidalPore(*args))

    def show(self, *args):
        r"""show(SlabWithToroidalPore self, _ostream out=std::cout)"""
        return _IMP_npc.SlabWithToroidalPore_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, double thickness, double major_radius) -> SlabWithToroidalPore
        setup_particle(_ParticleAdaptor pa, double thickness, double major_radius) -> SlabWithToroidalPore
        setup_particle(Model m, ParticleIndex pi, double thickness, double major_radius, double minor_radius_h2v_aspect_ratio) -> SlabWithToroidalPore
        setup_particle(_ParticleAdaptor pa, double thickness, double major_radius, double minor_radius_h2v_aspect_ratio) -> SlabWithToroidalPore
        """
        return _IMP_npc.SlabWithToroidalPore_setup_particle(*args)

    @staticmethod
    def get_is_setup(*args):
        r"""
        get_is_setup(_ParticleAdaptor p) -> bool
        get_is_setup(Model m, ParticleIndex pi) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore_get_is_setup(*args)

    def set_minor_radius_h2v_aspect_ratio(self, aspect_ratio):
        r"""set_minor_radius_h2v_aspect_ratio(SlabWithToroidalPore self, double aspect_ratio)"""
        return _IMP_npc.SlabWithToroidalPore_set_minor_radius_h2v_aspect_ratio(self, aspect_ratio)

    def get_minor_radius_h2v_aspect_ratio(self):
        r"""get_minor_radius_h2v_aspect_ratio(SlabWithToroidalPore self) -> double"""
        return _IMP_npc.SlabWithToroidalPore_get_minor_radius_h2v_aspect_ratio(self)

    def get_vertical_minor_radius(self):
        r"""get_vertical_minor_radius(SlabWithToroidalPore self) -> double"""
        return _IMP_npc.SlabWithToroidalPore_get_vertical_minor_radius(self)

    def set_vertical_minor_radius(self, rv):
        r"""set_vertical_minor_radius(SlabWithToroidalPore self, double rv)"""
        return _IMP_npc.SlabWithToroidalPore_set_vertical_minor_radius(self, rv)

    def get_horizontal_minor_radius(self):
        r"""get_horizontal_minor_radius(SlabWithToroidalPore self) -> double"""
        return _IMP_npc.SlabWithToroidalPore_get_horizontal_minor_radius(self)

    def set_horizontal_minor_radius(self, rh):
        r"""set_horizontal_minor_radius(SlabWithToroidalPore self, double rh)"""
        return _IMP_npc.SlabWithToroidalPore_set_horizontal_minor_radius(self, rh)

    @staticmethod
    def get_minor_radius_h2v_aspect_ratio_key():
        r"""get_minor_radius_h2v_aspect_ratio_key() -> FloatKey"""
        return _IMP_npc.SlabWithToroidalPore_get_minor_radius_h2v_aspect_ratio_key()

    @staticmethod
    def get_toroidal_pore_key():
        r"""get_toroidal_pore_key() -> IntKey"""
        return _IMP_npc.SlabWithToroidalPore_get_toroidal_pore_key()

    def add_attribute(self, *args):
        r"""
        add_attribute(SlabWithToroidalPore self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(SlabWithToroidalPore self, FloatKey a0, IMP::Float a1)
        add_attribute(SlabWithToroidalPore self, IntKey a0, IMP::Int a1)
        add_attribute(SlabWithToroidalPore self, FloatsKey a0, IMP::Floats a1)
        add_attribute(SlabWithToroidalPore self, IntsKey a0, IMP::Ints a1)
        add_attribute(SlabWithToroidalPore self, StringKey a0, IMP::String a1)
        add_attribute(SlabWithToroidalPore self, ParticleIndexKey a0, Particle a1)
        add_attribute(SlabWithToroidalPore self, ObjectKey a0, Object a1)
        add_attribute(SlabWithToroidalPore self, SparseFloatKey a0, IMP::Float a1)
        add_attribute(SlabWithToroidalPore self, SparseIntKey a0, IMP::Int a1)
        add_attribute(SlabWithToroidalPore self, SparseStringKey a0, IMP::String a1)
        add_attribute(SlabWithToroidalPore self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_npc.SlabWithToroidalPore_add_attribute(self, *args)

    def get_value(self, *args):
        r"""
        get_value(SlabWithToroidalPore self, FloatKey a0) -> IMP::Float
        get_value(SlabWithToroidalPore self, IntKey a0) -> IMP::Int
        get_value(SlabWithToroidalPore self, FloatsKey a0) -> IMP::Floats
        get_value(SlabWithToroidalPore self, IntsKey a0) -> IMP::Ints
        get_value(SlabWithToroidalPore self, StringKey a0) -> IMP::String
        get_value(SlabWithToroidalPore self, ParticleIndexKey a0) -> Particle
        get_value(SlabWithToroidalPore self, ObjectKey a0) -> Object
        get_value(SlabWithToroidalPore self, SparseFloatKey a0) -> IMP::Float
        get_value(SlabWithToroidalPore self, SparseIntKey a0) -> IMP::Int
        get_value(SlabWithToroidalPore self, SparseStringKey a0) -> IMP::String
        get_value(SlabWithToroidalPore self, SparseParticleIndexKey a0) -> ParticleIndex
        """
        return _IMP_npc.SlabWithToroidalPore_get_value(self, *args)

    def set_value(self, *args):
        r"""
        set_value(SlabWithToroidalPore self, FloatKey a0, IMP::Float a1)
        set_value(SlabWithToroidalPore self, IntKey a0, IMP::Int a1)
        set_value(SlabWithToroidalPore self, FloatsKey a0, IMP::Floats a1)
        set_value(SlabWithToroidalPore self, IntsKey a0, IMP::Ints a1)
        set_value(SlabWithToroidalPore self, StringKey a0, IMP::String a1)
        set_value(SlabWithToroidalPore self, ParticleIndexKey a0, Particle a1)
        set_value(SlabWithToroidalPore self, ObjectKey a0, Object a1)
        set_value(SlabWithToroidalPore self, SparseFloatKey a0, IMP::Float a1)
        set_value(SlabWithToroidalPore self, SparseIntKey a0, IMP::Int a1)
        set_value(SlabWithToroidalPore self, SparseStringKey a0, IMP::String a1)
        set_value(SlabWithToroidalPore self, SparseParticleIndexKey a0, ParticleIndex a1)
        """
        return _IMP_npc.SlabWithToroidalPore_set_value(self, *args)

    def remove_attribute(self, *args):
        r"""
        remove_attribute(SlabWithToroidalPore self, FloatKey a0)
        remove_attribute(SlabWithToroidalPore self, IntKey a0)
        remove_attribute(SlabWithToroidalPore self, FloatsKey a0)
        remove_attribute(SlabWithToroidalPore self, IntsKey a0)
        remove_attribute(SlabWithToroidalPore self, StringKey a0)
        remove_attribute(SlabWithToroidalPore self, ParticleIndexKey a0)
        remove_attribute(SlabWithToroidalPore self, ObjectKey a0)
        remove_attribute(SlabWithToroidalPore self, SparseFloatKey a0)
        remove_attribute(SlabWithToroidalPore self, SparseIntKey a0)
        remove_attribute(SlabWithToroidalPore self, SparseStringKey a0)
        remove_attribute(SlabWithToroidalPore self, SparseParticleIndexKey a0)
        """
        return _IMP_npc.SlabWithToroidalPore_remove_attribute(self, *args)

    def has_attribute(self, *args):
        r"""
        has_attribute(SlabWithToroidalPore self, FloatKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, IntKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, FloatsKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, IntsKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, StringKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, ParticleIndexKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, ObjectKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, SparseFloatKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, SparseIntKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, SparseStringKey a0) -> bool
        has_attribute(SlabWithToroidalPore self, SparseParticleIndexKey a0) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore_has_attribute(self, *args)

    def get_derivative(self, a0):
        r"""get_derivative(SlabWithToroidalPore self, FloatKey a0) -> double"""
        return _IMP_npc.SlabWithToroidalPore_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(SlabWithToroidalPore self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPore_get_name(self)

    def clear_caches(self):
        r"""clear_caches(SlabWithToroidalPore self)"""
        return _IMP_npc.SlabWithToroidalPore_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(SlabWithToroidalPore self, std::string a0)"""
        return _IMP_npc.SlabWithToroidalPore_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(SlabWithToroidalPore self, IMP::CheckLevel a0)"""
        return _IMP_npc.SlabWithToroidalPore_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(SlabWithToroidalPore self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_npc.SlabWithToroidalPore_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(SlabWithToroidalPore self, FloatKey a0, bool a1)"""
        return _IMP_npc.SlabWithToroidalPore_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(SlabWithToroidalPore self, FloatKey a0) -> bool"""
        return _IMP_npc.SlabWithToroidalPore_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(SlabWithToroidalPore self) -> IMP::CheckLevel"""
        return _IMP_npc.SlabWithToroidalPore_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(SlabWithToroidalPore self, SlabWithToroidalPore o) -> bool
        __eq__(SlabWithToroidalPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(SlabWithToroidalPore self, SlabWithToroidalPore o) -> bool
        __ne__(SlabWithToroidalPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(SlabWithToroidalPore self, SlabWithToroidalPore o) -> bool
        __le__(SlabWithToroidalPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(SlabWithToroidalPore self, SlabWithToroidalPore o) -> bool
        __lt__(SlabWithToroidalPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(SlabWithToroidalPore self, SlabWithToroidalPore o) -> bool
        __ge__(SlabWithToroidalPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(SlabWithToroidalPore self, SlabWithToroidalPore o) -> bool
        __gt__(SlabWithToroidalPore self, Particle d) -> bool
        """
        return _IMP_npc.SlabWithToroidalPore___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(SlabWithToroidalPore self) -> std::size_t"""
        return _IMP_npc.SlabWithToroidalPore___hash__(self)

    def __str__(self):
        r"""__str__(SlabWithToroidalPore self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithToroidalPore self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPore___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(SlabWithToroidalPore self) -> PyObject *"""
        return _IMP_npc.SlabWithToroidalPore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SlabWithToroidalPore self, PyObject * p)"""
        return _IMP_npc.SlabWithToroidalPore__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_npc.delete_SlabWithToroidalPore

# Register SlabWithToroidalPore in _IMP_npc:
_IMP_npc.SlabWithToroidalPore_swigregister(SlabWithToroidalPore)

def __lshift__(*args):
    r"""
    __lshift__(_ostream out, SlabWithSphericalIndent n) -> _ostream
    __lshift__(_ostream out, SlabWithPore n) -> _ostream
    __lshift__(_ostream out, SlabWithToroidalPore n) -> _ostream
    """
    return _IMP_npc.__lshift__(*args)
class SlabWithToroidalPoreWireGeometry(IMP.display.Geometry):
    r"""Proxy of C++ IMP::npc::SlabWithToroidalPoreWireGeometry 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__(SlabWithToroidalPoreWireGeometry self, double slab_height, double major_radius, double horizontal_semiaxis, double slab_length) -> SlabWithToroidalPoreWireGeometry
        __init__(SlabWithToroidalPoreWireGeometry self, double slab_height, double major_radius, double slab_length) -> SlabWithToroidalPoreWireGeometry
        """
        _IMP_npc.SlabWithToroidalPoreWireGeometry_swiginit(self, _IMP_npc.new_SlabWithToroidalPoreWireGeometry(*args))

    def get_version_info(self):
        r"""get_version_info(SlabWithToroidalPoreWireGeometry self) -> VersionInfo"""
        return _IMP_npc.SlabWithToroidalPoreWireGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_npc.delete_SlabWithToroidalPoreWireGeometry

    def __str__(self):
        r"""__str__(SlabWithToroidalPoreWireGeometry self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPoreWireGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithToroidalPoreWireGeometry self) -> std::string"""
        return _IMP_npc.SlabWithToroidalPoreWireGeometry___repr__(self)

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


# Register SlabWithToroidalPoreWireGeometry in _IMP_npc:
_IMP_npc.SlabWithToroidalPoreWireGeometry_swigregister(SlabWithToroidalPoreWireGeometry)

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

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