npctransport/__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_npctransport

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_NPCTRANSPORT_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_NPCTRANSPORT_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_npctransport.delete_IMP_NPCTRANSPORT_SwigPyIterator

    def value(self):
        r"""value(IMP_NPCTRANSPORT_SwigPyIterator self) -> PyObject *"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(IMP_NPCTRANSPORT_SwigPyIterator self, size_t n=1) -> IMP_NPCTRANSPORT_SwigPyIterator"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(IMP_NPCTRANSPORT_SwigPyIterator self, size_t n=1) -> IMP_NPCTRANSPORT_SwigPyIterator"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(IMP_NPCTRANSPORT_SwigPyIterator self, IMP_NPCTRANSPORT_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(IMP_NPCTRANSPORT_SwigPyIterator self, IMP_NPCTRANSPORT_SwigPyIterator x) -> bool"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(IMP_NPCTRANSPORT_SwigPyIterator self) -> IMP_NPCTRANSPORT_SwigPyIterator"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_copy(self)

    def __next__(self):
        r"""__next__(IMP_NPCTRANSPORT_SwigPyIterator self) -> PyObject *"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(IMP_NPCTRANSPORT_SwigPyIterator self) -> PyObject *"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(IMP_NPCTRANSPORT_SwigPyIterator self, ptrdiff_t n) -> IMP_NPCTRANSPORT_SwigPyIterator"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(IMP_NPCTRANSPORT_SwigPyIterator self, IMP_NPCTRANSPORT_SwigPyIterator x) -> bool"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(IMP_NPCTRANSPORT_SwigPyIterator self, IMP_NPCTRANSPORT_SwigPyIterator x) -> bool"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(IMP_NPCTRANSPORT_SwigPyIterator self, ptrdiff_t n) -> IMP_NPCTRANSPORT_SwigPyIterator"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(IMP_NPCTRANSPORT_SwigPyIterator self, ptrdiff_t n) -> IMP_NPCTRANSPORT_SwigPyIterator"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(IMP_NPCTRANSPORT_SwigPyIterator self, ptrdiff_t n) -> IMP_NPCTRANSPORT_SwigPyIterator"""
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(IMP_NPCTRANSPORT_SwigPyIterator self, ptrdiff_t n) -> IMP_NPCTRANSPORT_SwigPyIterator
        __sub__(IMP_NPCTRANSPORT_SwigPyIterator self, IMP_NPCTRANSPORT_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register IMP_NPCTRANSPORT_SwigPyIterator in _IMP_npctransport:
_IMP_npctransport.IMP_NPCTRANSPORT_SwigPyIterator_swigregister(IMP_NPCTRANSPORT_SwigPyIterator)

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

IMP_DEBUG = _IMP_npctransport.IMP_DEBUG

IMP_RELEASE = _IMP_npctransport.IMP_RELEASE

IMP_SILENT = _IMP_npctransport.IMP_SILENT

IMP_PROGRESS = _IMP_npctransport.IMP_PROGRESS

IMP_TERSE = _IMP_npctransport.IMP_TERSE

IMP_VERBOSE = _IMP_npctransport.IMP_VERBOSE

IMP_MEMORY = _IMP_npctransport.IMP_MEMORY

IMP_NONE = _IMP_npctransport.IMP_NONE

IMP_USAGE = _IMP_npctransport.IMP_USAGE

IMP_INTERNAL = _IMP_npctransport.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_npctransport.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_npctransport.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_npctransport.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_npctransport.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_npctransport.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_npctransport.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_npctransport.IMP_KERNEL_HAS_BOOST_SYSTEM

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_npctransport.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_npctransport.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_npctransport.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

IMPKERNEL_SHOW_WARNINGS = _IMP_npctransport.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_npctransport._ostream_write(self, osa_buf)

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

import IMP
IMP_BENCHMARK_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_BENCHMARK_HAS_BOOST_FILESYSTEM

IMP_BENCHMARK_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_BENCHMARK_HAS_BOOST_PROGRAMOPTIONS

IMP_BENCHMARK_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_BENCHMARK_HAS_BOOST_RANDOM

IMP_BENCHMARK_HAS_NUMPY = _IMP_npctransport.IMP_BENCHMARK_HAS_NUMPY

IMPBENCHMARK_SHOW_WARNINGS = _IMP_npctransport.IMPBENCHMARK_SHOW_WARNINGS

import IMP.benchmark
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_NUMPY = _IMP_npctransport.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_npctransport.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_npctransport.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_CGAL = _IMP_npctransport.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_npctransport.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_npctransport.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_npctransport.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_npctransport.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_CGAL = _IMP_npctransport.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_npctransport.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_npctransport.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_npctransport.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_npctransport.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_npctransport.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_npctransport.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_npctransport.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_npctransport.IMP_STATISTICS_HAS_IMP_CGAL

IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_STATISTICS_HAS_BOOST_RANDOM

IMP_STATISTICS_HAS_CGAL = _IMP_npctransport.IMP_STATISTICS_HAS_CGAL

IMP_STATISTICS_HAS_NUMPY = _IMP_npctransport.IMP_STATISTICS_HAS_NUMPY

IMPSTATISTICS_SHOW_WARNINGS = _IMP_npctransport.IMPSTATISTICS_SHOW_WARNINGS

import IMP.statistics
IMP_CORE_HAS_IMP_CGAL = _IMP_npctransport.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_npctransport.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_CGAL = _IMP_npctransport.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_npctransport.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_npctransport.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_npctransport.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_npctransport.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_npctransport.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_npctransport.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_npctransport.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_npctransport.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_CGAL = _IMP_npctransport.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_npctransport.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_npctransport.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_npctransport.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_npctransport.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_npctransport.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_npctransport.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
IMP_ATOM_HAS_IMP_CGAL = _IMP_npctransport.IMP_ATOM_HAS_IMP_CGAL

IMP_ATOM_HAS_IMP_KERNEL = _IMP_npctransport.IMP_ATOM_HAS_IMP_KERNEL

IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_npctransport.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

IMP_ATOM_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_ATOM_HAS_BOOST_RANDOM

IMP_ATOM_HAS_BOOST_REGEX = _IMP_npctransport.IMP_ATOM_HAS_BOOST_REGEX

IMP_ATOM_HAS_CGAL = _IMP_npctransport.IMP_ATOM_HAS_CGAL

IMP_ATOM_HAS_HDF5 = _IMP_npctransport.IMP_ATOM_HAS_HDF5

IMP_ATOM_HAS_NUMPY = _IMP_npctransport.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_npctransport.IMP_ATOM_HAS_PYTHON_IHM

IMPATOM_SHOW_WARNINGS = _IMP_npctransport.IMPATOM_SHOW_WARNINGS

IMP_ATOM_TYPE_INDEX = _IMP_npctransport.IMP_ATOM_TYPE_INDEX

IMP_RESIDUE_TYPE_INDEX = _IMP_npctransport.IMP_RESIDUE_TYPE_INDEX

IMP_HIERARCHY_TYPE_INDEX = _IMP_npctransport.IMP_HIERARCHY_TYPE_INDEX

IMP_CHAIN_TYPE_INDEX = _IMP_npctransport.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_npctransport.IMP_EM_HAS_IMP_CGAL

IMP_EM_HAS_IMP_CONTAINER = _IMP_npctransport.IMP_EM_HAS_IMP_CONTAINER

IMP_EM_HAS_IMP_DISPLAY = _IMP_npctransport.IMP_EM_HAS_IMP_DISPLAY

IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_npctransport.IMP_EM_HAS_IMP_SCORE_FUNCTOR

IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_EM_HAS_BOOST_FILESYSTEM

IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_EM_HAS_BOOST_PROGRAMOPTIONS

IMP_EM_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_EM_HAS_BOOST_RANDOM

IMP_EM_HAS_BOOST_REGEX = _IMP_npctransport.IMP_EM_HAS_BOOST_REGEX

IMP_EM_HAS_CGAL = _IMP_npctransport.IMP_EM_HAS_CGAL

IMP_EM_HAS_HDF5 = _IMP_npctransport.IMP_EM_HAS_HDF5

IMP_EM_HAS_NUMPY = _IMP_npctransport.IMP_EM_HAS_NUMPY

IMP_EM_HAS_PYTHON_IHM = _IMP_npctransport.IMP_EM_HAS_PYTHON_IHM

IMPEM_SHOW_WARNINGS = _IMP_npctransport.IMPEM_SHOW_WARNINGS

import IMP.em
IMP_SAXS_HAS_IMP_CGAL = _IMP_npctransport.IMP_SAXS_HAS_IMP_CGAL

IMP_SAXS_HAS_IMP_CONTAINER = _IMP_npctransport.IMP_SAXS_HAS_IMP_CONTAINER

IMP_SAXS_HAS_IMP_DISPLAY = _IMP_npctransport.IMP_SAXS_HAS_IMP_DISPLAY

IMP_SAXS_HAS_IMP_KERNEL = _IMP_npctransport.IMP_SAXS_HAS_IMP_KERNEL

IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_npctransport.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR

IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_SAXS_HAS_BOOST_FILESYSTEM

IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS

IMP_SAXS_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_SAXS_HAS_BOOST_RANDOM

IMP_SAXS_HAS_BOOST_REGEX = _IMP_npctransport.IMP_SAXS_HAS_BOOST_REGEX

IMP_SAXS_HAS_CGAL = _IMP_npctransport.IMP_SAXS_HAS_CGAL

IMP_SAXS_HAS_HDF5 = _IMP_npctransport.IMP_SAXS_HAS_HDF5

IMP_SAXS_HAS_NUMPY = _IMP_npctransport.IMP_SAXS_HAS_NUMPY

IMP_SAXS_HAS_PYTHON_IHM = _IMP_npctransport.IMP_SAXS_HAS_PYTHON_IHM

IMPSAXS_SHOW_WARNINGS = _IMP_npctransport.IMPSAXS_SHOW_WARNINGS

import IMP.saxs
IMP_ISD_HAS_IMP_CGAL = _IMP_npctransport.IMP_ISD_HAS_IMP_CGAL

IMP_ISD_HAS_IMP_DISPLAY = _IMP_npctransport.IMP_ISD_HAS_IMP_DISPLAY

IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_npctransport.IMP_ISD_HAS_IMP_SCORE_FUNCTOR

IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_ISD_HAS_BOOST_FILESYSTEM

IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS

IMP_ISD_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_ISD_HAS_BOOST_RANDOM

IMP_ISD_HAS_BOOST_REGEX = _IMP_npctransport.IMP_ISD_HAS_BOOST_REGEX

IMP_ISD_HAS_CGAL = _IMP_npctransport.IMP_ISD_HAS_CGAL

IMP_ISD_HAS_HDF5 = _IMP_npctransport.IMP_ISD_HAS_HDF5

IMP_ISD_HAS_NUMPY = _IMP_npctransport.IMP_ISD_HAS_NUMPY

IMP_ISD_HAS_PYTHON_IHM = _IMP_npctransport.IMP_ISD_HAS_PYTHON_IHM

IMPISD_SHOW_WARNINGS = _IMP_npctransport.IMPISD_SHOW_WARNINGS

import IMP.isd
IMP_RMF_HAS_IMP_CGAL = _IMP_npctransport.IMP_RMF_HAS_IMP_CGAL

IMP_RMF_HAS_IMP_EM = _IMP_npctransport.IMP_RMF_HAS_IMP_EM

IMP_RMF_HAS_IMP_SAXS = _IMP_npctransport.IMP_RMF_HAS_IMP_SAXS

IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_npctransport.IMP_RMF_HAS_IMP_SCORE_FUNCTOR

IMP_RMF_HAS_IMP_STATISTICS = _IMP_npctransport.IMP_RMF_HAS_IMP_STATISTICS

IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_RMF_HAS_BOOST_FILESYSTEM

IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS

IMP_RMF_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_RMF_HAS_BOOST_RANDOM

IMP_RMF_HAS_BOOST_REGEX = _IMP_npctransport.IMP_RMF_HAS_BOOST_REGEX

IMP_RMF_HAS_CGAL = _IMP_npctransport.IMP_RMF_HAS_CGAL

IMP_RMF_HAS_HDF5 = _IMP_npctransport.IMP_RMF_HAS_HDF5

IMP_RMF_HAS_NUMPY = _IMP_npctransport.IMP_RMF_HAS_NUMPY

IMP_RMF_HAS_PYTHON_IHM = _IMP_npctransport.IMP_RMF_HAS_PYTHON_IHM

IMPRMF_SHOW_WARNINGS = _IMP_npctransport.IMPRMF_SHOW_WARNINGS

import IMP.rmf
import RMF
IMP_NPCTRANSPORT_HAS_IMP_CGAL = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_IMP_CGAL

IMP_NPCTRANSPORT_HAS_IMP_EM = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_IMP_EM

IMP_NPCTRANSPORT_HAS_IMP_ISD = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_IMP_ISD

IMP_NPCTRANSPORT_HAS_IMP_SAXS = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_IMP_SAXS

IMP_NPCTRANSPORT_HAS_ABSEIL = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_ABSEIL

IMP_NPCTRANSPORT_HAS_BOOST_FILESYSTEM = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_BOOST_FILESYSTEM

IMP_NPCTRANSPORT_HAS_BOOST_PROGRAMOPTIONS = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_BOOST_PROGRAMOPTIONS

IMP_NPCTRANSPORT_HAS_BOOST_RANDOM = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_BOOST_RANDOM

IMP_NPCTRANSPORT_HAS_BOOST_REGEX = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_BOOST_REGEX

IMP_NPCTRANSPORT_HAS_CGAL = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_CGAL

IMP_NPCTRANSPORT_HAS_HDF5 = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_HDF5

IMP_NPCTRANSPORT_HAS_NUMPY = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_NUMPY

IMP_NPCTRANSPORT_HAS_PYTHON_IHM = _IMP_npctransport.IMP_NPCTRANSPORT_HAS_PYTHON_IHM

IMPNPCTRANSPORT_SHOW_WARNINGS = _IMP_npctransport.IMPNPCTRANSPORT_SHOW_WARNINGS


_object_types.append("SitesPairScore")


def _object_cast_to_SitesPairScore(o):
    r"""_object_cast_to_SitesPairScore(Object o) -> SitesPairScore"""
    return _IMP_npctransport._object_cast_to_SitesPairScore(o)

_object_types.append("Scoring")


def _object_cast_to_Scoring(o):
    r"""_object_cast_to_Scoring(Object o) -> Scoring"""
    return _IMP_npctransport._object_cast_to_Scoring(o)

_object_types.append("BrownianDynamicsTAMDWithSlabSupport")


def _object_cast_to_BrownianDynamicsTAMDWithSlabSupport(o):
    r"""_object_cast_to_BrownianDynamicsTAMDWithSlabSupport(Object o) -> BrownianDynamicsTAMDWithSlabSupport"""
    return _IMP_npctransport._object_cast_to_BrownianDynamicsTAMDWithSlabSupport(o)

_object_types.append("Statistics")


def _object_cast_to_Statistics(o):
    r"""_object_cast_to_Statistics(Object o) -> Statistics"""
    return _IMP_npctransport._object_cast_to_Statistics(o)

_object_types.append("SimulationData")


def _object_cast_to_SimulationData(o):
    r"""_object_cast_to_SimulationData(Object o) -> SimulationData"""
    return _IMP_npctransport._object_cast_to_SimulationData(o)

_object_types.append("SitesGeometry")


def _object_cast_to_SitesGeometry(o):
    r"""_object_cast_to_SitesGeometry(Object o) -> SitesGeometry"""
    return _IMP_npctransport._object_cast_to_SitesGeometry(o)

_object_types.append("TypedSitesGeometry")


def _object_cast_to_TypedSitesGeometry(o):
    r"""_object_cast_to_TypedSitesGeometry(Object o) -> TypedSitesGeometry"""
    return _IMP_npctransport._object_cast_to_TypedSitesGeometry(o)

_object_types.append("SlabWithCylindricalPorePairScore")


def _object_cast_to_SlabWithCylindricalPorePairScore(o):
    r"""_object_cast_to_SlabWithCylindricalPorePairScore(Object o) -> SlabWithCylindricalPorePairScore"""
    return _IMP_npctransport._object_cast_to_SlabWithCylindricalPorePairScore(o)

_object_types.append("SlabWithToroidalPorePairScore")


def _object_cast_to_SlabWithToroidalPorePairScore(o):
    r"""_object_cast_to_SlabWithToroidalPorePairScore(Object o) -> SlabWithToroidalPorePairScore"""
    return _IMP_npctransport._object_cast_to_SlabWithToroidalPorePairScore(o)

_object_types.append("PoreRadiusSingletonScore")


def _object_cast_to_PoreRadiusSingletonScore(o):
    r"""_object_cast_to_PoreRadiusSingletonScore(Object o) -> PoreRadiusSingletonScore"""
    return _IMP_npctransport._object_cast_to_PoreRadiusSingletonScore(o)

_object_types.append("ExcludeZRangeSingletonScore")


def _object_cast_to_ExcludeZRangeSingletonScore(o):
    r"""_object_cast_to_ExcludeZRangeSingletonScore(Object o) -> ExcludeZRangeSingletonScore"""
    return _IMP_npctransport._object_cast_to_ExcludeZRangeSingletonScore(o)

_object_types.append("ZBiasSingletonScore")


def _object_cast_to_ZBiasSingletonScore(o):
    r"""_object_cast_to_ZBiasSingletonScore(Object o) -> ZBiasSingletonScore"""
    return _IMP_npctransport._object_cast_to_ZBiasSingletonScore(o)

_object_types.append("SlabWithCylindricalPoreWireGeometry")


def _object_cast_to_SlabWithCylindricalPoreWireGeometry(o):
    r"""_object_cast_to_SlabWithCylindricalPoreWireGeometry(Object o) -> SlabWithCylindricalPoreWireGeometry"""
    return _IMP_npctransport._object_cast_to_SlabWithCylindricalPoreWireGeometry(o)

_object_types.append("SlabWithCylindricalPoreSurfaceGeometry")


def _object_cast_to_SlabWithCylindricalPoreSurfaceGeometry(o):
    r"""_object_cast_to_SlabWithCylindricalPoreSurfaceGeometry(Object o) -> SlabWithCylindricalPoreSurfaceGeometry"""
    return _IMP_npctransport._object_cast_to_SlabWithCylindricalPoreSurfaceGeometry(o)

_object_types.append("SlabWithToroidalPoreWireGeometry")


def _object_cast_to_SlabWithToroidalPoreWireGeometry(o):
    r"""_object_cast_to_SlabWithToroidalPoreWireGeometry(Object o) -> SlabWithToroidalPoreWireGeometry"""
    return _IMP_npctransport._object_cast_to_SlabWithToroidalPoreWireGeometry(o)

_object_types.append("LinearSoftSpherePairScore")


def _object_cast_to_LinearSoftSpherePairScore(o):
    r"""_object_cast_to_LinearSoftSpherePairScore(Object o) -> LinearSoftSpherePairScore"""
    return _IMP_npctransport._object_cast_to_LinearSoftSpherePairScore(o)

_object_types.append("FunctorLinearSoftSpherePairScore")


def _object_cast_to_FunctorLinearSoftSpherePairScore(o):
    r"""_object_cast_to_FunctorLinearSoftSpherePairScore(Object o) -> FunctorLinearSoftSpherePairScore"""
    return _IMP_npctransport._object_cast_to_FunctorLinearSoftSpherePairScore(o)

_object_types.append("LinearInteractionPairScore")


def _object_cast_to_LinearInteractionPairScore(o):
    r"""_object_cast_to_LinearInteractionPairScore(Object o) -> LinearInteractionPairScore"""
    return _IMP_npctransport._object_cast_to_LinearInteractionPairScore(o)

_object_types.append("FunctorLinearInteractionPairScore")


def _object_cast_to_FunctorLinearInteractionPairScore(o):
    r"""_object_cast_to_FunctorLinearInteractionPairScore(Object o) -> FunctorLinearInteractionPairScore"""
    return _IMP_npctransport._object_cast_to_FunctorLinearInteractionPairScore(o)

_object_types.append("LinearWellPairScore")


def _object_cast_to_LinearWellPairScore(o):
    r"""_object_cast_to_LinearWellPairScore(Object o) -> LinearWellPairScore"""
    return _IMP_npctransport._object_cast_to_LinearWellPairScore(o)

_object_types.append("HarmonicSpringSingletonScore")


def _object_cast_to_HarmonicSpringSingletonScore(o):
    r"""_object_cast_to_HarmonicSpringSingletonScore(Object o) -> HarmonicSpringSingletonScore"""
    return _IMP_npctransport._object_cast_to_HarmonicSpringSingletonScore(o)

_object_types.append("HierarchyWithSitesSaveLink")


def _object_cast_to_HierarchyWithSitesSaveLink(o):
    r"""_object_cast_to_HierarchyWithSitesSaveLink(Object o) -> HierarchyWithSitesSaveLink"""
    return _IMP_npctransport._object_cast_to_HierarchyWithSitesSaveLink(o)

_object_types.append("HierarchyWithSitesLoadLink")


def _object_cast_to_HierarchyWithSitesLoadLink(o):
    r"""_object_cast_to_HierarchyWithSitesLoadLink(Object o) -> HierarchyWithSitesLoadLink"""
    return _IMP_npctransport._object_cast_to_HierarchyWithSitesLoadLink(o)

_object_types.append("ChainStatisticsOptimizerState")


def _object_cast_to_ChainStatisticsOptimizerState(o):
    r"""_object_cast_to_ChainStatisticsOptimizerState(Object o) -> ChainStatisticsOptimizerState"""
    return _IMP_npctransport._object_cast_to_ChainStatisticsOptimizerState(o)

_object_types.append("BodyStatisticsOptimizerState")


def _object_cast_to_BodyStatisticsOptimizerState(o):
    r"""_object_cast_to_BodyStatisticsOptimizerState(Object o) -> BodyStatisticsOptimizerState"""
    return _IMP_npctransport._object_cast_to_BodyStatisticsOptimizerState(o)

_object_types.append("BipartitePairsStatisticsOptimizerState")


def _object_cast_to_BipartitePairsStatisticsOptimizerState(o):
    r"""_object_cast_to_BipartitePairsStatisticsOptimizerState(Object o) -> BipartitePairsStatisticsOptimizerState"""
    return _IMP_npctransport._object_cast_to_BipartitePairsStatisticsOptimizerState(o)

_object_types.append("ParticleTransportStatisticsOptimizerState")


def _object_cast_to_ParticleTransportStatisticsOptimizerState(o):
    r"""_object_cast_to_ParticleTransportStatisticsOptimizerState(Object o) -> ParticleTransportStatisticsOptimizerState"""
    return _IMP_npctransport._object_cast_to_ParticleTransportStatisticsOptimizerState(o)

_object_types.append("FGChain")


def _object_cast_to_FGChain(o):
    r"""_object_cast_to_FGChain(Object o) -> FGChain"""
    return _IMP_npctransport._object_cast_to_FGChain(o)

_object_types.append("ParticleFactory")


def _object_cast_to_ParticleFactory(o):
    r"""_object_cast_to_ParticleFactory(Object o) -> ParticleFactory"""
    return _IMP_npctransport._object_cast_to_ParticleFactory(o)

Avro2PBReaders=list
_plural_types.append("Avro2PBReaders")
_value_types.append("Avro2PBReader")


SitesPairScoreParametersList=list
_plural_types.append("SitesPairScoreParametersList")
_value_types.append("SitesPairScoreParameters")


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


_value_types.append("Transporting")


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


_value_types.append("SlabWithPore")


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


_value_types.append("SlabWithCylindricalPore")


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


_value_types.append("RelaxingSpring")


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


_value_types.append("SlabWithToroidalPore")

class _DoubleParameter(object):
    r"""Proxy of C++ IMP::npctransport::Parameter< double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_DoubleParameter self) -> _DoubleParameter
        __init__(_DoubleParameter self, double t) -> _DoubleParameter
        """
        _IMP_npctransport._DoubleParameter_swiginit(self, _IMP_npctransport.new__DoubleParameter(*args))

    def get_value(self):
        r"""get_value(_DoubleParameter self) -> double"""
        return _IMP_npctransport._DoubleParameter_get_value(self)

    def is_init(self):
        r"""is_init(_DoubleParameter self) -> bool"""
        return _IMP_npctransport._DoubleParameter_is_init(self)
    __swig_destroy__ = _IMP_npctransport.delete__DoubleParameter

# Register _DoubleParameter in _IMP_npctransport:
_IMP_npctransport._DoubleParameter_swigregister(_DoubleParameter)
class _IntParameter(object):
    r"""Proxy of C++ IMP::npctransport::Parameter< int > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_IntParameter self) -> _IntParameter
        __init__(_IntParameter self, int t) -> _IntParameter
        """
        _IMP_npctransport._IntParameter_swiginit(self, _IMP_npctransport.new__IntParameter(*args))

    def get_value(self):
        r"""get_value(_IntParameter self) -> int"""
        return _IMP_npctransport._IntParameter_get_value(self)

    def is_init(self):
        r"""is_init(_IntParameter self) -> bool"""
        return _IMP_npctransport._IntParameter_is_init(self)
    __swig_destroy__ = _IMP_npctransport.delete__IntParameter

# Register _IntParameter in _IMP_npctransport:
_IMP_npctransport._IntParameter_swigregister(_IntParameter)
class _BoolParameter(object):
    r"""Proxy of C++ IMP::npctransport::Parameter< bool > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_BoolParameter self) -> _BoolParameter
        __init__(_BoolParameter self, bool t) -> _BoolParameter
        """
        _IMP_npctransport._BoolParameter_swiginit(self, _IMP_npctransport.new__BoolParameter(*args))

    def get_value(self):
        r"""get_value(_BoolParameter self) -> bool"""
        return _IMP_npctransport._BoolParameter_get_value(self)

    def is_init(self):
        r"""is_init(_BoolParameter self) -> bool"""
        return _IMP_npctransport._BoolParameter_is_init(self)
    __swig_destroy__ = _IMP_npctransport.delete__BoolParameter

# Register _BoolParameter in _IMP_npctransport:
_IMP_npctransport._BoolParameter_swigregister(_BoolParameter)

def make_ordered_interaction_type(t0, t1):
    r"""make_ordered_interaction_type(ParticleType t0, ParticleType t1) -> IMP::npctransport::InteractionType"""
    return _IMP_npctransport.make_ordered_interaction_type(t0, t1)

def make_unordered_interaction_type(t0, t1):
    r"""make_unordered_interaction_type(ParticleType t0, ParticleType t1) -> IMP::npctransport::InteractionType"""
    return _IMP_npctransport.make_unordered_interaction_type(t0, t1)

def make_unordered_particle_index_pair(*args):
    r"""
    make_unordered_particle_index_pair(ParticleIndex pi0, ParticleIndex pi1) -> IMP::ParticleIndexPair
    make_unordered_particle_index_pair(IMP::ParticleIndexPair pip) -> IMP::ParticleIndexPair
    """
    return _IMP_npctransport.make_unordered_particle_index_pair(*args)
class LinearSoftSpherePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npctransport::LinearSoftSpherePairScore 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__(LinearSoftSpherePairScore self, double k, std::string name="LinearSSPairScore%1%") -> LinearSoftSpherePairScore"""
        _IMP_npctransport.LinearSoftSpherePairScore_swiginit(self, _IMP_npctransport.new_LinearSoftSpherePairScore(*args))

    def evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(LinearSoftSpherePairScore self, Model m, IMP::ParticleIndexPairs const & pips, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.LinearSoftSpherePairScore_evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, 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(LinearSoftSpherePairScore 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_npctransport.LinearSoftSpherePairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(LinearSoftSpherePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.LinearSoftSpherePairScore_do_get_inputs(self, m, pis)

    def get_k(self):
        r"""get_k(LinearSoftSpherePairScore self) -> double"""
        return _IMP_npctransport.LinearSoftSpherePairScore_get_k(self)

    def get_version_info(self):
        r"""get_version_info(LinearSoftSpherePairScore self) -> VersionInfo"""
        return _IMP_npctransport.LinearSoftSpherePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_LinearSoftSpherePairScore

    def __str__(self):
        r"""__str__(LinearSoftSpherePairScore self) -> std::string"""
        return _IMP_npctransport.LinearSoftSpherePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(LinearSoftSpherePairScore self) -> std::string"""
        return _IMP_npctransport.LinearSoftSpherePairScore___repr__(self)

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


# Register LinearSoftSpherePairScore in _IMP_npctransport:
_IMP_npctransport.LinearSoftSpherePairScore_swigregister(LinearSoftSpherePairScore)
class LinearInteractionPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npctransport::LinearInteractionPairScore 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__(LinearInteractionPairScore self, double k_rep, double range_attr, double k_attr, std::string name="LinearIDPairScore%1%") -> LinearInteractionPairScore"""
        _IMP_npctransport.LinearInteractionPairScore_swiginit(self, _IMP_npctransport.new_LinearInteractionPairScore(*args))

    def evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(LinearInteractionPairScore self, Model m, IMP::ParticleIndexPairs const & pips, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.LinearInteractionPairScore_evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_if_good_index(self, *args):
        r"""
        evaluate_if_good_index(LinearInteractionPairScore self, Model m, IMP::ParticleIndexPair const & p, DerivativeAccumulator da, double max) -> double
        evaluate_if_good_index(LinearInteractionPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound) -> double
        """
        return _IMP_npctransport.LinearInteractionPairScore_evaluate_if_good_index(self, *args)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(LinearInteractionPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.LinearInteractionPairScore_do_get_inputs(self, m, pis)

    def get_range_attraction(self):
        r"""get_range_attraction(LinearInteractionPairScore self) -> double"""
        return _IMP_npctransport.LinearInteractionPairScore_get_range_attraction(self)

    def get_k_attraction(self):
        r"""get_k_attraction(LinearInteractionPairScore self) -> double"""
        return _IMP_npctransport.LinearInteractionPairScore_get_k_attraction(self)

    def set_k_attraction(self, k_attr):
        r"""set_k_attraction(LinearInteractionPairScore self, double k_attr)"""
        return _IMP_npctransport.LinearInteractionPairScore_set_k_attraction(self, k_attr)

    def get_k_repulsion(self):
        r"""get_k_repulsion(LinearInteractionPairScore self) -> double"""
        return _IMP_npctransport.LinearInteractionPairScore_get_k_repulsion(self)

    def set_k_repulsion(self, k_rep):
        r"""set_k_repulsion(LinearInteractionPairScore self, double k_rep)"""
        return _IMP_npctransport.LinearInteractionPairScore_set_k_repulsion(self, k_rep)

    def get_version_info(self):
        r"""get_version_info(LinearInteractionPairScore self) -> VersionInfo"""
        return _IMP_npctransport.LinearInteractionPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_LinearInteractionPairScore

    def __str__(self):
        r"""__str__(LinearInteractionPairScore self) -> std::string"""
        return _IMP_npctransport.LinearInteractionPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(LinearInteractionPairScore self) -> std::string"""
        return _IMP_npctransport.LinearInteractionPairScore___repr__(self)

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


# Register LinearInteractionPairScore in _IMP_npctransport:
_IMP_npctransport.LinearInteractionPairScore_swigregister(LinearInteractionPairScore)
class LinearWellPairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npctransport::LinearWellPairScore 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__(LinearWellPairScore self, double rest_length_factor, double k, std::string name="LinearIDPairScore%1%") -> LinearWellPairScore"""
        _IMP_npctransport.LinearWellPairScore_swiginit(self, _IMP_npctransport.new_LinearWellPairScore(*args))

    def set_rest_length_factor(self, rest_length_factor):
        r"""set_rest_length_factor(LinearWellPairScore self, double rest_length_factor)"""
        return _IMP_npctransport.LinearWellPairScore_set_rest_length_factor(self, rest_length_factor)

    def get_rest_length_factor(self):
        r"""get_rest_length_factor(LinearWellPairScore self) -> double"""
        return _IMP_npctransport.LinearWellPairScore_get_rest_length_factor(self)

    def set_k(self, k):
        r"""set_k(LinearWellPairScore self, double k)"""
        return _IMP_npctransport.LinearWellPairScore_set_k(self, k)

    def get_k(self):
        r"""get_k(LinearWellPairScore self) -> double"""
        return _IMP_npctransport.LinearWellPairScore_get_k(self)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(LinearWellPairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.LinearWellPairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(LinearWellPairScore 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_npctransport.LinearWellPairScore_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(LinearWellPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.LinearWellPairScore_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(LinearWellPairScore self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.LinearWellPairScore_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(LinearWellPairScore 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_npctransport.LinearWellPairScore_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(LinearWellPairScore self) -> VersionInfo"""
        return _IMP_npctransport.LinearWellPairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_LinearWellPairScore

    def __str__(self):
        r"""__str__(LinearWellPairScore self) -> std::string"""
        return _IMP_npctransport.LinearWellPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(LinearWellPairScore self) -> std::string"""
        return _IMP_npctransport.LinearWellPairScore___repr__(self)

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


# Register LinearWellPairScore in _IMP_npctransport:
_IMP_npctransport.LinearWellPairScore_swigregister(LinearWellPairScore)
class RelaxingSpring(IMP.Decorator):
    r"""Proxy of C++ IMP::npctransport::RelaxingSpring 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__(RelaxingSpring self) -> RelaxingSpring
        __init__(RelaxingSpring self, Model m, ParticleIndex id) -> RelaxingSpring
        __init__(RelaxingSpring self, _ParticleAdaptor d) -> RelaxingSpring
        """
        _IMP_npctransport.RelaxingSpring_swiginit(self, _IMP_npctransport.new_RelaxingSpring(*args))

    def show(self, *args):
        r"""show(RelaxingSpring self, _ostream out=std::cout)"""
        return _IMP_npctransport.RelaxingSpring_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, ParticleIndex bonded_pi0, ParticleIndex bonded_pi1, double equilibrium_rest_length_factor, double rest_length_diffusion_coefficient) -> RelaxingSpring
        setup_particle(_ParticleAdaptor pa, ParticleIndex bonded_pi0, ParticleIndex bonded_pi1, double equilibrium_rest_length_factor, double rest_length_diffusion_coefficient) -> RelaxingSpring
        """
        return _IMP_npctransport.RelaxingSpring_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_npctransport.RelaxingSpring_get_is_setup(*args)

    @staticmethod
    def get_bonded_particle_0_key():
        r"""get_bonded_particle_0_key() -> ParticleIndexKey"""
        return _IMP_npctransport.RelaxingSpring_get_bonded_particle_0_key()

    @staticmethod
    def get_bonded_particle_1_key():
        r"""get_bonded_particle_1_key() -> ParticleIndexKey"""
        return _IMP_npctransport.RelaxingSpring_get_bonded_particle_1_key()

    @staticmethod
    def get_equilibrium_rest_length_factor_key():
        r"""get_equilibrium_rest_length_factor_key() -> FloatKey"""
        return _IMP_npctransport.RelaxingSpring_get_equilibrium_rest_length_factor_key()

    @staticmethod
    def get_rest_length_key():
        r"""get_rest_length_key() -> FloatKey"""
        return _IMP_npctransport.RelaxingSpring_get_rest_length_key()

    @staticmethod
    def get_rest_length_diffusion_coefficient_key():
        r"""get_rest_length_diffusion_coefficient_key() -> FloatKey"""
        return _IMP_npctransport.RelaxingSpring_get_rest_length_diffusion_coefficient_key()

    def get_bonded_particle_0(self):
        r"""get_bonded_particle_0(RelaxingSpring self) -> Particle"""
        return _IMP_npctransport.RelaxingSpring_get_bonded_particle_0(self)

    def get_bonded_particle_1(self):
        r"""get_bonded_particle_1(RelaxingSpring self) -> Particle"""
        return _IMP_npctransport.RelaxingSpring_get_bonded_particle_1(self)

    def get_bonded_particle_index_0(self):
        r"""get_bonded_particle_index_0(RelaxingSpring self) -> ParticleIndex"""
        return _IMP_npctransport.RelaxingSpring_get_bonded_particle_index_0(self)

    def get_bonded_particle_index_1(self):
        r"""get_bonded_particle_index_1(RelaxingSpring self) -> ParticleIndex"""
        return _IMP_npctransport.RelaxingSpring_get_bonded_particle_index_1(self)

    def get_equilibrium_rest_length_factor(self):
        r"""get_equilibrium_rest_length_factor(RelaxingSpring self) -> IMP::Float"""
        return _IMP_npctransport.RelaxingSpring_get_equilibrium_rest_length_factor(self)

    def set_equilibrium_rest_length_factor(self, t):
        r"""set_equilibrium_rest_length_factor(RelaxingSpring self, IMP::Float t)"""
        return _IMP_npctransport.RelaxingSpring_set_equilibrium_rest_length_factor(self, t)

    def get_rest_length(self):
        r"""get_rest_length(RelaxingSpring self) -> IMP::Float"""
        return _IMP_npctransport.RelaxingSpring_get_rest_length(self)

    def set_rest_length(self, t):
        r"""set_rest_length(RelaxingSpring self, IMP::Float t)"""
        return _IMP_npctransport.RelaxingSpring_set_rest_length(self, t)

    def get_rest_length_diffusion_coefficient(self):
        r"""get_rest_length_diffusion_coefficient(RelaxingSpring self) -> IMP::Float"""
        return _IMP_npctransport.RelaxingSpring_get_rest_length_diffusion_coefficient(self)

    def set_rest_length_diffusion_coefficient(self, t):
        r"""set_rest_length_diffusion_coefficient(RelaxingSpring self, IMP::Float t)"""
        return _IMP_npctransport.RelaxingSpring_set_rest_length_diffusion_coefficient(self, t)

    def add_to_rest_length_derivative(self, d, da):
        r"""add_to_rest_length_derivative(RelaxingSpring self, double d, DerivativeAccumulator da)"""
        return _IMP_npctransport.RelaxingSpring_add_to_rest_length_derivative(self, d, da)

    def get_rest_length_derivative(self):
        r"""get_rest_length_derivative(RelaxingSpring self) -> double"""
        return _IMP_npctransport.RelaxingSpring_get_rest_length_derivative(self)

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

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

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

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

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

    def get_derivative(self, a0):
        r"""get_derivative(RelaxingSpring self, FloatKey a0) -> double"""
        return _IMP_npctransport.RelaxingSpring_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(RelaxingSpring self) -> std::string"""
        return _IMP_npctransport.RelaxingSpring_get_name(self)

    def clear_caches(self):
        r"""clear_caches(RelaxingSpring self)"""
        return _IMP_npctransport.RelaxingSpring_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(RelaxingSpring self, std::string a0)"""
        return _IMP_npctransport.RelaxingSpring_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(RelaxingSpring self, IMP::CheckLevel a0)"""
        return _IMP_npctransport.RelaxingSpring_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(RelaxingSpring self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_npctransport.RelaxingSpring_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(RelaxingSpring self, FloatKey a0, bool a1)"""
        return _IMP_npctransport.RelaxingSpring_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(RelaxingSpring self, FloatKey a0) -> bool"""
        return _IMP_npctransport.RelaxingSpring_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(RelaxingSpring self) -> IMP::CheckLevel"""
        return _IMP_npctransport.RelaxingSpring_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(RelaxingSpring self, RelaxingSpring o) -> bool
        __eq__(RelaxingSpring self, Particle d) -> bool
        """
        return _IMP_npctransport.RelaxingSpring___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(RelaxingSpring self, RelaxingSpring o) -> bool
        __ne__(RelaxingSpring self, Particle d) -> bool
        """
        return _IMP_npctransport.RelaxingSpring___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(RelaxingSpring self, RelaxingSpring o) -> bool
        __le__(RelaxingSpring self, Particle d) -> bool
        """
        return _IMP_npctransport.RelaxingSpring___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(RelaxingSpring self, RelaxingSpring o) -> bool
        __lt__(RelaxingSpring self, Particle d) -> bool
        """
        return _IMP_npctransport.RelaxingSpring___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(RelaxingSpring self, RelaxingSpring o) -> bool
        __ge__(RelaxingSpring self, Particle d) -> bool
        """
        return _IMP_npctransport.RelaxingSpring___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(RelaxingSpring self, RelaxingSpring o) -> bool
        __gt__(RelaxingSpring self, Particle d) -> bool
        """
        return _IMP_npctransport.RelaxingSpring___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(RelaxingSpring self) -> std::size_t"""
        return _IMP_npctransport.RelaxingSpring___hash__(self)

    def __str__(self):
        r"""__str__(RelaxingSpring self) -> std::string"""
        return _IMP_npctransport.RelaxingSpring___str__(self)

    def __repr__(self):
        r"""__repr__(RelaxingSpring self) -> std::string"""
        return _IMP_npctransport.RelaxingSpring___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(RelaxingSpring self) -> PyObject *"""
        return _IMP_npctransport.RelaxingSpring__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(RelaxingSpring self, PyObject * p)"""
        return _IMP_npctransport.RelaxingSpring__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_npctransport.delete_RelaxingSpring

# Register RelaxingSpring in _IMP_npctransport:
_IMP_npctransport.RelaxingSpring_swigregister(RelaxingSpring)
class HarmonicSpringSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::npctransport::HarmonicSpringSingletonScore 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__(HarmonicSpringSingletonScore self, double k1, double k2, std::string name="HarmonicSpringSingletonScore%1%") -> HarmonicSpringSingletonScore"""
        _IMP_npctransport.HarmonicSpringSingletonScore_swiginit(self, _IMP_npctransport.new_HarmonicSpringSingletonScore(*args))

    def set_k1(self, k1):
        r"""set_k1(HarmonicSpringSingletonScore self, double k1)"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_set_k1(self, k1)

    def get_k1(self):
        r"""get_k1(HarmonicSpringSingletonScore self) -> double"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_get_k1(self)

    def set_k2(self, k2):
        r"""set_k2(HarmonicSpringSingletonScore self, double k2)"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_set_k2(self, k2)

    def get_k2(self):
        r"""get_k2(HarmonicSpringSingletonScore self) -> double"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_get_k2(self)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(HarmonicSpringSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(HarmonicSpringSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_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(HarmonicSpringSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_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(HarmonicSpringSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_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(HarmonicSpringSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_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(HarmonicSpringSingletonScore self) -> VersionInfo"""
        return _IMP_npctransport.HarmonicSpringSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_HarmonicSpringSingletonScore

    def __str__(self):
        r"""__str__(HarmonicSpringSingletonScore self) -> std::string"""
        return _IMP_npctransport.HarmonicSpringSingletonScore___str__(self)

    def __repr__(self):
        r"""__repr__(HarmonicSpringSingletonScore self) -> std::string"""
        return _IMP_npctransport.HarmonicSpringSingletonScore___repr__(self)

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


# Register HarmonicSpringSingletonScore in _IMP_npctransport:
_IMP_npctransport.HarmonicSpringSingletonScore_swigregister(HarmonicSpringSingletonScore)
class LinearInteraction(object):
    r"""Proxy of C++ IMP::npctransport::LinearInteraction class."""

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

    def __init__(self, *args):
        r"""
        __init__(LinearInteraction self, double krep, double attr_range, double kattr) -> LinearInteraction
        __init__(LinearInteraction self) -> LinearInteraction
        """
        _IMP_npctransport.LinearInteraction_swiginit(self, _IMP_npctransport.new_LinearInteraction(*args))

    def show(self, *args):
        r"""show(LinearInteraction self, _ostream out=std::cout)"""
        return _IMP_npctransport.LinearInteraction_show(self, *args)
    __swig_destroy__ = _IMP_npctransport.delete_LinearInteraction

# Register LinearInteraction in _IMP_npctransport:
_IMP_npctransport.LinearInteraction_swigregister(LinearInteraction)
class _DistancePairScoreForLinearSoftSphere(IMP.PairScore):
    r"""Proxy of C++ IMP::score_functor::DistancePairScore< IMP::npctransport::LinearSoftSphereScore > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_DistancePairScoreForLinearSoftSphere self, IMP::score_functor::DistancePairScore< IMP::score_functor::SphereDistance< IMP::score_functor::LinearLowerBound > >::DistanceScore const & t0, std::string name="FunctorDistancePairScore %1%") -> _DistancePairScoreForLinearSoftSphere
        __init__(_DistancePairScoreForLinearSoftSphere self) -> _DistancePairScoreForLinearSoftSphere
        """
        _IMP_npctransport._DistancePairScoreForLinearSoftSphere_swiginit(self, _IMP_npctransport.new__DistancePairScoreForLinearSoftSphere(*args))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(_DistancePairScoreForLinearSoftSphere self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport._DistancePairScoreForLinearSoftSphere_do_get_inputs(self, m, pis)

    def get_score_functor(self, *args):
        r"""
        get_score_functor(_DistancePairScoreForLinearSoftSphere self) -> IMP::score_functor::SphereDistance< IMP::score_functor::LinearLowerBound >
        get_score_functor(_DistancePairScoreForLinearSoftSphere self) -> IMP::score_functor::SphereDistance< IMP::score_functor::LinearLowerBound > const &
        """
        return _IMP_npctransport._DistancePairScoreForLinearSoftSphere_get_score_functor(self, *args)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(_DistancePairScoreForLinearSoftSphere 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_npctransport._DistancePairScoreForLinearSoftSphere_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(_DistancePairScoreForLinearSoftSphere self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._DistancePairScoreForLinearSoftSphere_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(_DistancePairScoreForLinearSoftSphere self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._DistancePairScoreForLinearSoftSphere_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(_DistancePairScoreForLinearSoftSphere 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_npctransport._DistancePairScoreForLinearSoftSphere_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(_DistancePairScoreForLinearSoftSphere self) -> VersionInfo"""
        return _IMP_npctransport._DistancePairScoreForLinearSoftSphere_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete__DistancePairScoreForLinearSoftSphere

# Register _DistancePairScoreForLinearSoftSphere in _IMP_npctransport:
_IMP_npctransport._DistancePairScoreForLinearSoftSphere_swigregister(_DistancePairScoreForLinearSoftSphere)
class _DistancePairScoreForLinearInteraction(IMP.PairScore):
    r"""Proxy of C++ IMP::score_functor::DistancePairScore< IMP::npctransport::LinearInteractionScore > class."""

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

    def __init__(self, *args):
        r"""
        __init__(_DistancePairScoreForLinearInteraction self, IMP::score_functor::DistancePairScore< IMP::score_functor::SphereDistance< IMP::npctransport::LinearInteraction > >::DistanceScore const & t0, std::string name="FunctorDistancePairScore %1%") -> _DistancePairScoreForLinearInteraction
        __init__(_DistancePairScoreForLinearInteraction self) -> _DistancePairScoreForLinearInteraction
        """
        _IMP_npctransport._DistancePairScoreForLinearInteraction_swiginit(self, _IMP_npctransport.new__DistancePairScoreForLinearInteraction(*args))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(_DistancePairScoreForLinearInteraction self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport._DistancePairScoreForLinearInteraction_do_get_inputs(self, m, pis)

    def get_score_functor(self, *args):
        r"""
        get_score_functor(_DistancePairScoreForLinearInteraction self) -> IMP::score_functor::SphereDistance< IMP::npctransport::LinearInteraction >
        get_score_functor(_DistancePairScoreForLinearInteraction self) -> IMP::score_functor::SphereDistance< IMP::npctransport::LinearInteraction > const &
        """
        return _IMP_npctransport._DistancePairScoreForLinearInteraction_get_score_functor(self, *args)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(_DistancePairScoreForLinearInteraction 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_npctransport._DistancePairScoreForLinearInteraction_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(_DistancePairScoreForLinearInteraction self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._DistancePairScoreForLinearInteraction_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(_DistancePairScoreForLinearInteraction self, Model m, IMP::ParticleIndexPairs const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._DistancePairScoreForLinearInteraction_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(_DistancePairScoreForLinearInteraction 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_npctransport._DistancePairScoreForLinearInteraction_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(_DistancePairScoreForLinearInteraction self) -> VersionInfo"""
        return _IMP_npctransport._DistancePairScoreForLinearInteraction_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete__DistancePairScoreForLinearInteraction

# Register _DistancePairScoreForLinearInteraction in _IMP_npctransport:
_IMP_npctransport._DistancePairScoreForLinearInteraction_swigregister(_DistancePairScoreForLinearInteraction)
class FunctorLinearSoftSpherePairScore(_DistancePairScoreForLinearSoftSphere):
    r"""Proxy of C++ IMP::npctransport::FunctorLinearSoftSpherePairScore 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__(FunctorLinearSoftSpherePairScore self, double k, std::string name="LinearSSPairScore%1%") -> FunctorLinearSoftSpherePairScore"""
        _IMP_npctransport.FunctorLinearSoftSpherePairScore_swiginit(self, _IMP_npctransport.new_FunctorLinearSoftSpherePairScore(*args))
    __swig_destroy__ = _IMP_npctransport.delete_FunctorLinearSoftSpherePairScore

    def __str__(self):
        r"""__str__(FunctorLinearSoftSpherePairScore self) -> std::string"""
        return _IMP_npctransport.FunctorLinearSoftSpherePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(FunctorLinearSoftSpherePairScore self) -> std::string"""
        return _IMP_npctransport.FunctorLinearSoftSpherePairScore___repr__(self)

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


# Register FunctorLinearSoftSpherePairScore in _IMP_npctransport:
_IMP_npctransport.FunctorLinearSoftSpherePairScore_swigregister(FunctorLinearSoftSpherePairScore)
class FunctorLinearInteractionPairScore(_DistancePairScoreForLinearInteraction):
    r"""Proxy of C++ IMP::npctransport::FunctorLinearInteractionPairScore 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__(FunctorLinearInteractionPairScore self, double krep, double attr_range, double kattr, std::string name="LinearSSPairScore%1%") -> FunctorLinearInteractionPairScore"""
        _IMP_npctransport.FunctorLinearInteractionPairScore_swiginit(self, _IMP_npctransport.new_FunctorLinearInteractionPairScore(*args))
    __swig_destroy__ = _IMP_npctransport.delete_FunctorLinearInteractionPairScore

    def __str__(self):
        r"""__str__(FunctorLinearInteractionPairScore self) -> std::string"""
        return _IMP_npctransport.FunctorLinearInteractionPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(FunctorLinearInteractionPairScore self) -> std::string"""
        return _IMP_npctransport.FunctorLinearInteractionPairScore___repr__(self)

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


# Register FunctorLinearInteractionPairScore in _IMP_npctransport:
_IMP_npctransport.FunctorLinearInteractionPairScore_swigregister(FunctorLinearInteractionPairScore)
class BrownianDynamicsTAMDWithSlabSupport(IMP.atom.BrownianDynamicsTAMD):
    r"""Proxy of C++ IMP::npctransport::BrownianDynamicsTAMDWithSlabSupport 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__(BrownianDynamicsTAMDWithSlabSupport self, Model m, std::string name="BrownianDynamicsTAMDWithSlabSupport%1%", double wave_factor=1.0) -> BrownianDynamicsTAMDWithSlabSupport"""
        _IMP_npctransport.BrownianDynamicsTAMDWithSlabSupport_swiginit(self, _IMP_npctransport.new_BrownianDynamicsTAMDWithSlabSupport(*args))

    def __str__(self):
        r"""__str__(BrownianDynamicsTAMDWithSlabSupport self) -> std::string"""
        return _IMP_npctransport.BrownianDynamicsTAMDWithSlabSupport___str__(self)

    def __repr__(self):
        r"""__repr__(BrownianDynamicsTAMDWithSlabSupport self) -> std::string"""
        return _IMP_npctransport.BrownianDynamicsTAMDWithSlabSupport___repr__(self)

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

    __swig_destroy__ = _IMP_npctransport.delete_BrownianDynamicsTAMDWithSlabSupport

# Register BrownianDynamicsTAMDWithSlabSupport in _IMP_npctransport:
_IMP_npctransport.BrownianDynamicsTAMDWithSlabSupport_swigregister(BrownianDynamicsTAMDWithSlabSupport)
class SitesPairScoreParameters(object):
    r"""Proxy of C++ IMP::npctransport::SitesPairScoreParameters class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    r = property(_IMP_npctransport.SitesPairScoreParameters_r_get, _IMP_npctransport.SitesPairScoreParameters_r_set, doc=r"""r : double""")
    k = property(_IMP_npctransport.SitesPairScoreParameters_k_get, _IMP_npctransport.SitesPairScoreParameters_k_set, doc=r"""k : double""")
    r2 = property(_IMP_npctransport.SitesPairScoreParameters_r2_get, _IMP_npctransport.SitesPairScoreParameters_r2_set, doc=r"""r2 : double""")
    kr = property(_IMP_npctransport.SitesPairScoreParameters_kr_get, _IMP_npctransport.SitesPairScoreParameters_kr_set, doc=r"""kr : double""")
    kr2 = property(_IMP_npctransport.SitesPairScoreParameters_kr2_get, _IMP_npctransport.SitesPairScoreParameters_kr2_set, doc=r"""kr2 : double""")
    cosSigma1_max = property(_IMP_npctransport.SitesPairScoreParameters_cosSigma1_max_get, _IMP_npctransport.SitesPairScoreParameters_cosSigma1_max_set, doc=r"""cosSigma1_max : double""")
    cosSigma2_max = property(_IMP_npctransport.SitesPairScoreParameters_cosSigma2_max_get, _IMP_npctransport.SitesPairScoreParameters_cosSigma2_max_set, doc=r"""cosSigma2_max : double""")
    is_orientational = property(_IMP_npctransport.SitesPairScoreParameters_is_orientational_get, _IMP_npctransport.SitesPairScoreParameters_is_orientational_set, doc=r"""is_orientational : bool""")

    def __init__(self, range, k_coefficient, sigma1_max_deg=0.0, sigma2_max_deg=0.0):
        r"""__init__(SitesPairScoreParameters self, double range, double k_coefficient, double sigma1_max_deg=0.0, double sigma2_max_deg=0.0) -> SitesPairScoreParameters"""
        _IMP_npctransport.SitesPairScoreParameters_swiginit(self, _IMP_npctransport.new_SitesPairScoreParameters(range, k_coefficient, sigma1_max_deg, sigma2_max_deg))

    def set_range(self, r):
        r"""set_range(SitesPairScoreParameters self, double r)"""
        return _IMP_npctransport.SitesPairScoreParameters_set_range(self, r)

    def set_force_coefficient(self, k):
        r"""set_force_coefficient(SitesPairScoreParameters self, double k)"""
        return _IMP_npctransport.SitesPairScoreParameters_set_force_coefficient(self, k)

    def set_sigma1_max(self, sigma1_max_deg):
        r"""set_sigma1_max(SitesPairScoreParameters self, double sigma1_max_deg)"""
        return _IMP_npctransport.SitesPairScoreParameters_set_sigma1_max(self, sigma1_max_deg)

    def set_sigma2_max(self, sigma2_max_deg):
        r"""set_sigma2_max(SitesPairScoreParameters self, double sigma2_max_deg)"""
        return _IMP_npctransport.SitesPairScoreParameters_set_sigma2_max(self, sigma2_max_deg)

    def update_is_orientational(self):
        r"""update_is_orientational(SitesPairScoreParameters self)"""
        return _IMP_npctransport.SitesPairScoreParameters_update_is_orientational(self)

    def show(self, *args):
        r"""show(SitesPairScoreParameters self, _ostream out=std::cout)"""
        return _IMP_npctransport.SitesPairScoreParameters_show(self, *args)

    def __str__(self):
        r"""__str__(SitesPairScoreParameters self) -> std::string"""
        return _IMP_npctransport.SitesPairScoreParameters___str__(self)

    def __repr__(self):
        r"""__repr__(SitesPairScoreParameters self) -> std::string"""
        return _IMP_npctransport.SitesPairScoreParameters___repr__(self)
    __swig_destroy__ = _IMP_npctransport.delete_SitesPairScoreParameters

# Register SitesPairScoreParameters in _IMP_npctransport:
_IMP_npctransport.SitesPairScoreParameters_swigregister(SitesPairScoreParameters)
class SitesGeometry(IMP.core.XYZRGeometry):
    r"""Proxy of C++ IMP::npctransport::SitesGeometry class."""

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

    def __init__(self, p, sites):
        r"""__init__(SitesGeometry self, Particle p, IMP::algebra::Sphere3Ds sites) -> SitesGeometry"""
        _IMP_npctransport.SitesGeometry_swiginit(self, _IMP_npctransport.new_SitesGeometry(p, sites))
    __swig_destroy__ = _IMP_npctransport.delete_SitesGeometry

    def __str__(self):
        r"""__str__(SitesGeometry self) -> std::string"""
        return _IMP_npctransport.SitesGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(SitesGeometry self) -> std::string"""
        return _IMP_npctransport.SitesGeometry___repr__(self)

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


# Register SitesGeometry in _IMP_npctransport:
_IMP_npctransport.SitesGeometry_swigregister(SitesGeometry)
class TypedSitesGeometry(IMP.display.SingletonsGeometry):
    r"""Proxy of C++ IMP::npctransport::TypedSitesGeometry class."""

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

    def __init__(self, sc):
        r"""__init__(TypedSitesGeometry self, _SingletonContainerAdaptor sc) -> TypedSitesGeometry"""
        _IMP_npctransport.TypedSitesGeometry_swiginit(self, _IMP_npctransport.new_TypedSitesGeometry(sc))

    def set_sites(self, t, s):
        r"""set_sites(TypedSitesGeometry self, ParticleType t, IMP::algebra::Sphere3Ds s)"""
        return _IMP_npctransport.TypedSitesGeometry_set_sites(self, t, s)

    def get_version_info(self):
        r"""get_version_info(TypedSitesGeometry self) -> VersionInfo"""
        return _IMP_npctransport.TypedSitesGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_TypedSitesGeometry

    def __str__(self):
        r"""__str__(TypedSitesGeometry self) -> std::string"""
        return _IMP_npctransport.TypedSitesGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(TypedSitesGeometry self) -> std::string"""
        return _IMP_npctransport.TypedSitesGeometry___repr__(self)

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


# Register TypedSitesGeometry in _IMP_npctransport:
_IMP_npctransport.TypedSitesGeometry_swigregister(TypedSitesGeometry)
class SitesPairScore(LinearInteractionPairScore):
    r"""Proxy of C++ IMP::npctransport::SitesPairScore class."""

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

    def __init__(self, range, k, sigma0_deg, sigma1_deg, range_nonspec_attraction, k_nonspec_attraction, k_nonspec_repulsion, sites0, sites1):
        r"""__init__(SitesPairScore self, double range, double k, double sigma0_deg, double sigma1_deg, double range_nonspec_attraction, double k_nonspec_attraction, double k_nonspec_repulsion, IMP::algebra::Sphere3Ds const & sites0, IMP::algebra::Sphere3Ds const & sites1) -> SitesPairScore"""
        _IMP_npctransport.SitesPairScore_swiginit(self, _IMP_npctransport.new_SitesPairScore(range, k, sigma0_deg, sigma1_deg, range_nonspec_attraction, k_nonspec_attraction, k_nonspec_repulsion, sites0, sites1))

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SitesPairScore 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_npctransport.SitesPairScore_evaluate_indexes(self, m, p, da, lower_bound, upper_bound, 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(SitesPairScore 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_npctransport.SitesPairScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_sites_range(self):
        r"""get_sites_range(SitesPairScore self) -> double"""
        return _IMP_npctransport.SitesPairScore_get_sites_range(self)

    def get_sites_k(self):
        r"""get_sites_k(SitesPairScore self) -> double"""
        return _IMP_npctransport.SitesPairScore_get_sites_k(self)

    def get_parameters(self):
        r"""get_parameters(SitesPairScore self) -> SitesPairScoreParameters"""
        return _IMP_npctransport.SitesPairScore_get_parameters(self)
    __swig_destroy__ = _IMP_npctransport.delete_SitesPairScore

    def set_sites(self, sites0, sites1):
        r"""set_sites(SitesPairScore self, IMP::algebra::Sphere3Ds const & sites0, IMP::algebra::Sphere3Ds const & sites1)"""
        return _IMP_npctransport.SitesPairScore_set_sites(self, sites0, sites1)

    def set_sites0(self, sites0):
        r"""set_sites0(SitesPairScore self, IMP::algebra::Sphere3Ds const & sites0)"""
        return _IMP_npctransport.SitesPairScore_set_sites0(self, sites0)

    def set_sites1(self, sites1):
        r"""set_sites1(SitesPairScore self, IMP::algebra::Sphere3Ds const & sites1)"""
        return _IMP_npctransport.SitesPairScore_set_sites1(self, sites1)

    def __str__(self):
        r"""__str__(SitesPairScore self) -> std::string"""
        return _IMP_npctransport.SitesPairScore___str__(self)

    def __repr__(self):
        r"""__repr__(SitesPairScore self) -> std::string"""
        return _IMP_npctransport.SitesPairScore___repr__(self)

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


# Register SitesPairScore in _IMP_npctransport:
_IMP_npctransport.SitesPairScore_swigregister(SitesPairScore)
class FGChain(IMP.Object):
    r"""Proxy of C++ IMP::npctransport::FGChain 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__(FGChain self, Particle root, double backbone_k=0.0, double rest_length_factor=1.0, std::string name="chain %1%") -> FGChain"""
        _IMP_npctransport.FGChain_swiginit(self, _IMP_npctransport.new_FGChain(*args))

    def get_root(self):
        r"""get_root(FGChain self) -> Hierarchy"""
        return _IMP_npctransport.FGChain_get_root(self)

    def get_beads(self):
        r"""get_beads(FGChain self) -> IMP::ParticlesTemp"""
        return _IMP_npctransport.FGChain_get_beads(self)

    def get_bead(self, i):
        r"""get_bead(FGChain self, unsigned int i) -> Particle"""
        return _IMP_npctransport.FGChain_get_bead(self, i)

    def get_bead_index(self, i):
        r"""get_bead_index(FGChain self, unsigned int i) -> ParticleIndex"""
        return _IMP_npctransport.FGChain_get_bead_index(self, i)

    def get_number_of_beads(self):
        r"""get_number_of_beads(FGChain self) -> unsigned int"""
        return _IMP_npctransport.FGChain_get_number_of_beads(self)

    def get_chain_restraints(self, scoring_manager):
        r"""get_chain_restraints(FGChain self, Scoring scoring_manager) -> IMP::Restraints"""
        return _IMP_npctransport.FGChain_get_chain_restraints(self, scoring_manager)

    def set_rest_length_factor(self, rlf):
        r"""set_rest_length_factor(FGChain self, double rlf)"""
        return _IMP_npctransport.FGChain_set_rest_length_factor(self, rlf)

    def set_backbone_k(self, k):
        r"""set_backbone_k(FGChain self, double k)"""
        return _IMP_npctransport.FGChain_set_backbone_k(self, k)

    def get_rest_length_factor(self):
        r"""get_rest_length_factor(FGChain self) -> double"""
        return _IMP_npctransport.FGChain_get_rest_length_factor(self)

    def get_backbone_k(self):
        r"""get_backbone_k(FGChain self) -> double"""
        return _IMP_npctransport.FGChain_get_backbone_k(self)

    def get_version_info(self):
        r"""get_version_info(FGChain self) -> VersionInfo"""
        return _IMP_npctransport.FGChain_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_FGChain

    def __str__(self):
        r"""__str__(FGChain self) -> std::string"""
        return _IMP_npctransport.FGChain___str__(self)

    def __repr__(self):
        r"""__repr__(FGChain self) -> std::string"""
        return _IMP_npctransport.FGChain___repr__(self)

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


# Register FGChain in _IMP_npctransport:
_IMP_npctransport.FGChain_swigregister(FGChain)

def create_fg_chain(sd, parent, fg_data, c):
    r"""create_fg_chain(SimulationData sd, Hierarchy parent, ::npctransport_proto::Assignment_FGAssignment const & fg_data, Color c) -> FGChain"""
    return _IMP_npctransport.create_fg_chain(sd, parent, fg_data, c)

def get_fg_chain(*args):
    r"""
    get_fg_chain(Hierarchy root) -> FGChain
    get_fg_chain(Particle p_root) -> FGChain
    """
    return _IMP_npctransport.get_fg_chain(*args)
class Scoring(IMP.Object):
    r"""Proxy of C++ IMP::npctransport::Scoring class."""

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

    def __init__(self, owner_sd, data):
        r"""__init__(Scoring self, SimulationData owner_sd, ::npctransport_proto::Assignment const & data) -> Scoring"""
        _IMP_npctransport.Scoring_swiginit(self, _IMP_npctransport.new_Scoring(owner_sd, data))

    def get_scoring_function(self, force_update=False):
        r"""get_scoring_function(Scoring self, bool force_update=False) -> ScoringFunction"""
        return _IMP_npctransport.Scoring_get_scoring_function(self, force_update)

    def get_scoring_function_restraints(self, force_update=False):
        r"""get_scoring_function_restraints(Scoring self, bool force_update=False) -> IMP::Restraints"""
        return _IMP_npctransport.Scoring_get_scoring_function_restraints(self, force_update)

    def get_custom_scoring_function(self, *args):
        r"""
        get_custom_scoring_function(Scoring self, IMP::RestraintsTemp const & extra_restraints, _SingletonContainerAdaptor non_optimizable_beads, _SingletonContainerAdaptor optimizable_beads, bool is_attr_interactions_on=True) -> ScoringFunction
        get_custom_scoring_function(Scoring self, IMP::RestraintsTemp const & extra_restraints, IMP::ParticleIndexes non_optimizable_beads, _SingletonContainerAdaptor optimizable_beads, bool is_attr_interactions_on=True) -> ScoringFunction
        """
        return _IMP_npctransport.Scoring_get_custom_scoring_function(self, *args)

    def get_close_beads_container(self, update=False):
        r"""get_close_beads_container(Scoring self, bool update=False) -> PairContainer"""
        return _IMP_npctransport.Scoring_get_close_beads_container(self, update)

    def get_predicates_pair_restraint(self, update=False):
        r"""get_predicates_pair_restraint(Scoring self, bool update=False) -> PredicatePairsRestraint"""
        return _IMP_npctransport.Scoring_get_predicates_pair_restraint(self, update)

    def get_bounding_volume_restraint(self, update=False):
        r"""get_bounding_volume_restraint(Scoring self, bool update=False) -> Restraint"""
        return _IMP_npctransport.Scoring_get_bounding_volume_restraint(self, update)

    def get_slab_restraint(self, update=False):
        r"""get_slab_restraint(Scoring self, bool update=False) -> Restraint"""
        return _IMP_npctransport.Scoring_get_slab_restraint(self, update)

    def add_interaction(self, idata):
        r"""add_interaction(Scoring self, ::npctransport_proto::Assignment_InteractionAssignment const & idata)"""
        return _IMP_npctransport.Scoring_add_interaction(self, idata)

    def create_close_beads_container(self, *args):
        r"""
        create_close_beads_container(Scoring self, _SingletonContainerAdaptor non_optimiziable_beads, _SingletonContainerAdaptor optimizable_beads) -> PairContainer
        create_close_beads_container(Scoring self, IMP::ParticleIndexes non_optimizable_beads, _SingletonContainerAdaptor optimizable_beads) -> PairContainer
        """
        return _IMP_npctransport.Scoring_create_close_beads_container(self, *args)

    def create_predicates_pair_restraint(self, bead_pairs, is_attr_interactions_on=True):
        r"""create_predicates_pair_restraint(Scoring self, PairContainer bead_pairs, bool is_attr_interactions_on=True) -> PredicatePairsRestraint"""
        return _IMP_npctransport.Scoring_create_predicates_pair_restraint(self, bead_pairs, is_attr_interactions_on)

    def create_bounding_volume_restraint(self, beads):
        r"""create_bounding_volume_restraint(Scoring self, _SingletonContainerAdaptor beads) -> Restraint"""
        return _IMP_npctransport.Scoring_create_bounding_volume_restraint(self, beads)

    def create_slab_restraint(self, beads):
        r"""create_slab_restraint(Scoring self, _SingletonContainerAdaptor beads) -> Restraint"""
        return _IMP_npctransport.Scoring_create_slab_restraint(self, beads)

    def get_model(self):
        r"""get_model(Scoring self) -> Model"""
        return _IMP_npctransport.Scoring_get_model(self)

    def get_sd(self):
        r"""get_sd(Scoring self) -> SimulationData"""
        return _IMP_npctransport.Scoring_get_sd(self)

    def get_has_bounding_box(self):
        r"""get_has_bounding_box(Scoring self) -> bool"""
        return _IMP_npctransport.Scoring_get_has_bounding_box(self)

    def get_has_bounding_sphere(self):
        r"""get_has_bounding_sphere(Scoring self) -> bool"""
        return _IMP_npctransport.Scoring_get_has_bounding_sphere(self)

    def get_has_bounding_volume(self):
        r"""get_has_bounding_volume(Scoring self) -> bool"""
        return _IMP_npctransport.Scoring_get_has_bounding_volume(self)

    def get_default_backbone_k(self):
        r"""get_default_backbone_k(Scoring self) -> double"""
        return _IMP_npctransport.Scoring_get_default_backbone_k(self)

    def get_is_backbone_harmonic(self):
        r"""get_is_backbone_harmonic(Scoring self) -> bool"""
        return _IMP_npctransport.Scoring_get_is_backbone_harmonic(self)

    def get_excluded_volume_k(self):
        r"""get_excluded_volume_k(Scoring self) -> double"""
        return _IMP_npctransport.Scoring_get_excluded_volume_k(self)

    def get_interaction_k(self):
        r"""get_interaction_k(Scoring self) -> double"""
        return _IMP_npctransport.Scoring_get_interaction_k(self)

    def get_predicate_pair_score(self, *args):
        r"""
        get_predicate_pair_score(Scoring self, ParticleType t1, ParticleType t2) -> PairScore
        get_predicate_pair_score(Scoring self, ParticleType t1, ParticleType t2) -> PairScore
        """
        return _IMP_npctransport.Scoring_get_predicate_pair_score(self, *args)

    def get_interaction_range_for(self, t1, t2, site_specific=True, non_specific=False):
        r"""get_interaction_range_for(Scoring self, ParticleType t1, ParticleType t2, bool site_specific=True, bool non_specific=False) -> double"""
        return _IMP_npctransport.Scoring_get_interaction_range_for(self, t1, t2, site_specific, non_specific)

    def get_ordered_type_pair_predicate(self):
        r"""get_ordered_type_pair_predicate(Scoring self) -> OrderedTypePairPredicate"""
        return _IMP_npctransport.Scoring_get_ordered_type_pair_predicate(self)

    def add_chain_restraints(self, chain):
        r"""add_chain_restraints(Scoring self, FGChain chain)"""
        return _IMP_npctransport.Scoring_add_chain_restraints(self, chain)

    def get_chain_restraints_on(self, beads):
        r"""get_chain_restraints_on(Scoring self, _SingletonContainerAdaptor beads) -> IMP::Restraints"""
        return _IMP_npctransport.Scoring_get_chain_restraints_on(self, beads)

    def get_all_chain_restraints(self):
        r"""get_all_chain_restraints(Scoring self) -> IMP::Restraints"""
        return _IMP_npctransport.Scoring_get_all_chain_restraints(self)

    def remove_particle_type(self, pt):
        r"""remove_particle_type(Scoring self, ParticleType pt)"""
        return _IMP_npctransport.Scoring_remove_particle_type(self, pt)

    def add_z_bias_restraint(self, *args):
        r"""
        add_z_bias_restraint(Scoring self, _SingletonContainerAdaptor ps, double k, double z)
        add_z_bias_restraint(Scoring self, Particle p, double k, double z)
        """
        return _IMP_npctransport.Scoring_add_z_bias_restraint(self, *args)

    def get_z_bias_restraints(self):
        r"""get_z_bias_restraints(Scoring self) -> IMP::Restraints"""
        return _IMP_npctransport.Scoring_get_z_bias_restraints(self)

    def create_z_bias_restraint(self, ps, k, z):
        r"""create_z_bias_restraint(Scoring self, _SingletonContainerAdaptor ps, double k, double z) -> Restraint"""
        return _IMP_npctransport.Scoring_create_z_bias_restraint(self, ps, k, z)

    def add_custom_restraint(self, r):
        r"""add_custom_restraint(Scoring self, Restraint r)"""
        return _IMP_npctransport.Scoring_add_custom_restraint(self, r)

    def add_custom_restraints(self, R):
        r"""add_custom_restraints(Scoring self, IMP::Restraints R)"""
        return _IMP_npctransport.Scoring_add_custom_restraints(self, R)

    def clear_custom_restraints(self):
        r"""clear_custom_restraints(Scoring self)"""
        return _IMP_npctransport.Scoring_clear_custom_restraints(self)

    def get_custom_restraints(self):
        r"""get_custom_restraints(Scoring self) -> IMP::Restraints"""
        return _IMP_npctransport.Scoring_get_custom_restraints(self)

    def add_restrained_anchor_bead(self, p):
        r"""add_restrained_anchor_bead(Scoring self, Particle p)"""
        return _IMP_npctransport.Scoring_add_restrained_anchor_bead(self, p)

    def get_pore_radius_restraint(self):
        r"""get_pore_radius_restraint(Scoring self) -> Restraint"""
        return _IMP_npctransport.Scoring_get_pore_radius_restraint(self)

    def get_range(self):
        r"""get_range(Scoring self) -> double"""
        return _IMP_npctransport.Scoring_get_range(self)

    def set_interaction_range_factor(self, type, value):
        r"""set_interaction_range_factor(Scoring self, ParticleType type, double value)"""
        return _IMP_npctransport.Scoring_set_interaction_range_factor(self, type, value)

    def set_interaction_k_factor(self, type, value):
        r"""set_interaction_k_factor(Scoring self, ParticleType type, double value)"""
        return _IMP_npctransport.Scoring_set_interaction_k_factor(self, type, value)

    def get_version_info(self):
        r"""get_version_info(Scoring self) -> VersionInfo"""
        return _IMP_npctransport.Scoring_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_Scoring

    def __str__(self):
        r"""__str__(Scoring self) -> std::string"""
        return _IMP_npctransport.Scoring___str__(self)

    def __repr__(self):
        r"""__repr__(Scoring self) -> std::string"""
        return _IMP_npctransport.Scoring___repr__(self)

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


# Register Scoring in _IMP_npctransport:
_IMP_npctransport.Scoring_swigregister(Scoring)
class SimpleTimer(object):
    r"""Proxy of C++ IMP::internal::SimpleTimer class."""

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

    def __init__(self):
        r"""__init__(SimpleTimer self) -> SimpleTimer"""
        _IMP_npctransport.SimpleTimer_swiginit(self, _IMP_npctransport.new_SimpleTimer())
    __swig_destroy__ = _IMP_npctransport.delete_SimpleTimer

# Register SimpleTimer in _IMP_npctransport:
_IMP_npctransport.SimpleTimer_swigregister(SimpleTimer)
class Statistics(IMP.Object):
    r"""Proxy of C++ IMP::npctransport::Statistics class."""

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

    def remove_particle_type(self, pt):
        r"""remove_particle_type(Statistics self, ParticleType pt)"""
        return _IMP_npctransport.Statistics_remove_particle_type(self, pt)

    def __init__(self, sd, statistics_interval_frames, output_file_name):
        r"""__init__(Statistics self, SimulationData sd, unsigned int statistics_interval_frames, std::string output_file_name) -> Statistics"""
        _IMP_npctransport.Statistics_swiginit(self, _IMP_npctransport.new_Statistics(sd, statistics_interval_frames, output_file_name))

    def add_fg_chain_stats(self, fg_chain):
        r"""add_fg_chain_stats(Statistics self, FGChain fg_chain)"""
        return _IMP_npctransport.Statistics_add_fg_chain_stats(self, fg_chain)

    def add_floater_stats(self, p):
        r"""add_floater_stats(Statistics self, Particle p)"""
        return _IMP_npctransport.Statistics_add_floater_stats(self, p)

    def add_interaction_stats(self, type0, type1):
        r"""add_interaction_stats(Statistics self, ParticleType type0, ParticleType type1)"""
        return _IMP_npctransport.Statistics_add_interaction_stats(self, type0, type1)

    def add_optimizer_states(self, o=None):
        r"""add_optimizer_states(Statistics self, Optimizer o=None) -> IMP::OptimizerStates"""
        return _IMP_npctransport.Statistics_add_optimizer_states(self, o)

    def update_particle_type_zr_distribution_map(self, p):
        r"""update_particle_type_zr_distribution_map(Statistics self, Particle p)"""
        return _IMP_npctransport.Statistics_update_particle_type_zr_distribution_map(self, p)

    def update_particle_type_xyz_distribution_map(self, p):
        r"""update_particle_type_xyz_distribution_map(Statistics self, Particle p)"""
        return _IMP_npctransport.Statistics_update_particle_type_xyz_distribution_map(self, p)

    def update(self, timer, nf_new=1, force_full_output=False):
        r"""update(Statistics self, SimpleTimer timer, unsigned int nf_new=1, bool force_full_output=False)"""
        return _IMP_npctransport.Statistics_update(self, timer, nf_new, force_full_output)

    def reset_statistics_optimizer_states(self):
        r"""reset_statistics_optimizer_states(Statistics self)"""
        return _IMP_npctransport.Statistics_reset_statistics_optimizer_states(self)

    def set_interrupted(self, tf):
        r"""set_interrupted(Statistics self, bool tf)"""
        return _IMP_npctransport.Statistics_set_interrupted(self, tf)

    def get_model(self):
        r"""get_model(Statistics self) -> Model"""
        return _IMP_npctransport.Statistics_get_model(self)

    def get_sd(self):
        r"""get_sd(Statistics self) -> SimulationData"""
        return _IMP_npctransport.Statistics_get_sd(self)

    def get_is_activated(self):
        r"""get_is_activated(Statistics self) -> bool"""
        return _IMP_npctransport.Statistics_get_is_activated(self)

    def get_output_file_name(self):
        r"""get_output_file_name(Statistics self) -> std::string"""
        return _IMP_npctransport.Statistics_get_output_file_name(self)

    def get_version_info(self):
        r"""get_version_info(Statistics self) -> VersionInfo"""
        return _IMP_npctransport.Statistics_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_Statistics

    def __str__(self):
        r"""__str__(Statistics self) -> std::string"""
        return _IMP_npctransport.Statistics___str__(self)

    def __repr__(self):
        r"""__repr__(Statistics self) -> std::string"""
        return _IMP_npctransport.Statistics___repr__(self)

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


# Register Statistics in _IMP_npctransport:
_IMP_npctransport.Statistics_swigregister(Statistics)

def create_boost_timer():
    r"""create_boost_timer() -> SimpleTimer"""
    return _IMP_npctransport.create_boost_timer()
IMPNPCTRANSPORT_VERSION = _IMP_npctransport.IMPNPCTRANSPORT_VERSION

class SimulationData(IMP.Object):
    r"""Proxy of C++ IMP::npctransport::SimulationData class."""

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

    def get_output_npctransport_version(self):
        r"""get_output_npctransport_version(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_output_npctransport_version(self)

    def get_range(self):
        r"""get_range(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_range(self)

    def get_output_statistics_interval_frames(self):
        r"""get_output_statistics_interval_frames(SimulationData self) -> int"""
        return _IMP_npctransport.SimulationData_get_output_statistics_interval_frames(self)

    def get_full_output_statistics_interval_factor(self):
        r"""get_full_output_statistics_interval_factor(SimulationData self) -> int"""
        return _IMP_npctransport.SimulationData_get_full_output_statistics_interval_factor(self)

    def get_is_multiple_hdf5s(self):
        r"""get_is_multiple_hdf5s(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_is_multiple_hdf5s(self)

    def get_is_exclude_floaters_from_slab_initially(self):
        r"""get_is_exclude_floaters_from_slab_initially(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_is_exclude_floaters_from_slab_initially(self)

    def get_are_floaters_on_one_slab_side(self):
        r"""get_are_floaters_on_one_slab_side(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_are_floaters_on_one_slab_side(self)

    def get_is_xyz_hist_stats(self):
        r"""get_is_xyz_hist_stats(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_is_xyz_hist_stats(self)

    def get_xyz_stats_crop_factor(self):
        r"""get_xyz_stats_crop_factor(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_xyz_stats_crop_factor(self)

    def get_xyz_stats_voxel_size_A(self):
        r"""get_xyz_stats_voxel_size_A(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_xyz_stats_voxel_size_A(self)

    def get_xyz_stats_max_box_size_A(self):
        r"""get_xyz_stats_max_box_size_A(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_xyz_stats_max_box_size_A(self)

    def get_angular_d_factor(self):
        r"""get_angular_d_factor(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_angular_d_factor(self)

    def __init__(self, *args):
        r"""__init__(SimulationData self, std::string prev_output_file, bool quick, std::string rmf_file_name=std::string(), std::string new_output_file="") -> SimulationData"""
        _IMP_npctransport.SimulationData_swiginit(self, _IMP_npctransport.new_SimulationData(*args))

    def get_model(self):
        r"""get_model(SimulationData self) -> Model"""
        return _IMP_npctransport.SimulationData_get_model(self)

    def get_scoring(self):
        r"""get_scoring(SimulationData self) -> Scoring"""
        return _IMP_npctransport.SimulationData_get_scoring(self)

    def get_statistics(self):
        r"""get_statistics(SimulationData self) -> Statistics"""
        return _IMP_npctransport.SimulationData_get_statistics(self)

    def get_bd(self, recreate=False):
        r"""get_bd(SimulationData self, bool recreate=False) -> BrownianDynamics"""
        return _IMP_npctransport.SimulationData_get_bd(self, recreate)

    def activate_statistics(self):
        r"""activate_statistics(SimulationData self)"""
        return _IMP_npctransport.SimulationData_activate_statistics(self)

    def get_statistics_fraction(self):
        r"""get_statistics_fraction(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_statistics_fraction(self)

    def get_is_fg_bead(self, *args):
        r"""
        get_is_fg_bead(SimulationData self, ParticleIndex pi) -> bool
        get_is_fg_bead(SimulationData self, ParticleType pt) -> bool
        """
        return _IMP_npctransport.SimulationData_get_is_fg_bead(self, *args)

    def get_is_fg_chain(self, *args):
        r"""
        get_is_fg_chain(SimulationData self, ParticleIndex pi) -> bool
        get_is_fg_chain(SimulationData self, ParticleType pt) -> bool
        """
        return _IMP_npctransport.SimulationData_get_is_fg_chain(self, *args)

    def get_fg_bead_types(self):
        r"""get_fg_bead_types(SimulationData self) -> IMP::npctransport::ParticleTypeSet const &"""
        return _IMP_npctransport.SimulationData_get_fg_bead_types(self)

    def get_fg_chain_types(self):
        r"""get_fg_chain_types(SimulationData self) -> IMP::npctransport::ParticleTypeSet const &"""
        return _IMP_npctransport.SimulationData_get_fg_chain_types(self)

    def get_floater_types(self):
        r"""get_floater_types(SimulationData self) -> IMP::npctransport::ParticleTypeSet const &"""
        return _IMP_npctransport.SimulationData_get_floater_types(self)

    def get_obstacle_types(self):
        r"""get_obstacle_types(SimulationData self) -> IMP::npctransport::ParticleTypeSet const &"""
        return _IMP_npctransport.SimulationData_get_obstacle_types(self)

    def get_fg_chain_roots(self):
        r"""get_fg_chain_roots(SimulationData self) -> IMP::atom::Hierarchies"""
        return _IMP_npctransport.SimulationData_get_fg_chain_roots(self)

    def get_fg_chains(self):
        r"""get_fg_chains(SimulationData self) -> IMP::atom::Hierarchies"""
        return _IMP_npctransport.SimulationData_get_fg_chains(self)

    def get_obstacle_particles(self):
        r"""get_obstacle_particles(SimulationData self) -> IMP::ParticlesTemp"""
        return _IMP_npctransport.SimulationData_get_obstacle_particles(self)

    def get_beads(self):
        r"""get_beads(SimulationData self) -> IMP::ParticlesTemp"""
        return _IMP_npctransport.SimulationData_get_beads(self)

    def get_optimizable_beads(self):
        r"""get_optimizable_beads(SimulationData self) -> IMP::ParticlesTemp"""
        return _IMP_npctransport.SimulationData_get_optimizable_beads(self)

    def get_non_optimizable_beads(self):
        r"""get_non_optimizable_beads(SimulationData self) -> IMP::ParticlesTemp"""
        return _IMP_npctransport.SimulationData_get_non_optimizable_beads(self)

    def get_is_backbone_harmonic(self):
        r"""get_is_backbone_harmonic(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_is_backbone_harmonic(self)

    def get_backbone_tau_ns(self):
        r"""get_backbone_tau_ns(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_backbone_tau_ns(self)

    def get_temperature_k(self):
        r"""get_temperature_k(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_temperature_k(self)

    def get_initial_simulation_time_ns(self):
        r"""get_initial_simulation_time_ns(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_initial_simulation_time_ns(self)

    def get_site_centers(self, t0):
        r"""get_site_centers(SimulationData self, ParticleType t0) -> IMP::algebra::Vector3Ds"""
        return _IMP_npctransport.SimulationData_get_site_centers(self, t0)

    def get_sites(self, t0):
        r"""get_sites(SimulationData self, ParticleType t0) -> IMP::algebra::Sphere3Ds"""
        return _IMP_npctransport.SimulationData_get_sites(self, t0)

    def set_sites(self, *args):
        r"""
        set_sites(SimulationData self, ParticleType t0, int n, double r, double sr)
        set_sites(SimulationData self, ParticleType t0, IMP::algebra::Sphere3Ds const & sites)
        """
        return _IMP_npctransport.SimulationData_set_sites(self, *args)

    def get_site_display_radius(self, arg2):
        r"""get_site_display_radius(SimulationData self, ParticleType arg2) -> double"""
        return _IMP_npctransport.SimulationData_get_site_display_radius(self, arg2)

    def get_maximum_number_of_minutes(self):
        r"""get_maximum_number_of_minutes(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_maximum_number_of_minutes(self)

    def remove_particle_type(self, pt):
        r"""remove_particle_type(SimulationData self, ParticleType pt)"""
        return _IMP_npctransport.SimulationData_remove_particle_type(self, pt)

    def remove_fgs_with_prefix(self, s_fg_type):
        r"""remove_fgs_with_prefix(SimulationData self, std::string s_fg_type)"""
        return _IMP_npctransport.SimulationData_remove_fgs_with_prefix(self, s_fg_type)

    def get_bounding_box(self):
        r"""get_bounding_box(SimulationData self) -> BoundingBox3D"""
        return _IMP_npctransport.SimulationData_get_bounding_box(self)

    def get_bounding_sphere(self):
        r"""get_bounding_sphere(SimulationData self) -> Sphere3D"""
        return _IMP_npctransport.SimulationData_get_bounding_sphere(self)

    def get_bounding_box_size(self):
        r"""get_bounding_box_size(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_bounding_box_size(self)

    def set_bounding_box_size(self, box_size):
        r"""set_bounding_box_size(SimulationData self, double box_size)"""
        return _IMP_npctransport.SimulationData_set_bounding_box_size(self, box_size)

    def get_bounding_sphere_radius(self):
        r"""get_bounding_sphere_radius(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_bounding_sphere_radius(self)

    def set_bounding_sphere_radius(self, sphere_radius):
        r"""set_bounding_sphere_radius(SimulationData self, double sphere_radius)"""
        return _IMP_npctransport.SimulationData_set_bounding_sphere_radius(self, sphere_radius)

    def get_bounding_volume(self):
        r"""get_bounding_volume(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_bounding_volume(self)

    def set_bounding_volume(self, volume_A3):
        r"""set_bounding_volume(SimulationData self, double volume_A3)"""
        return _IMP_npctransport.SimulationData_set_bounding_volume(self, volume_A3)

    def get_has_slab(self):
        r"""get_has_slab(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_has_slab(self)

    def get_is_slab_with_cylindrical_pore(self):
        r"""get_is_slab_with_cylindrical_pore(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_is_slab_with_cylindrical_pore(self)

    def get_is_slab_with_toroidal_pore(self):
        r"""get_is_slab_with_toroidal_pore(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_is_slab_with_toroidal_pore(self)

    def get_slab_particle(self):
        r"""get_slab_particle(SimulationData self) -> Particle"""
        return _IMP_npctransport.SimulationData_get_slab_particle(self)

    def get_cylinder(self):
        r"""get_cylinder(SimulationData self) -> Cylinder3D"""
        return _IMP_npctransport.SimulationData_get_cylinder(self)

    def get_has_bounding_box(self):
        r"""get_has_bounding_box(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_has_bounding_box(self)

    def get_has_bounding_sphere(self):
        r"""get_has_bounding_sphere(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_has_bounding_sphere(self)

    def get_has_bounding_volume(self):
        r"""get_has_bounding_volume(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_has_bounding_volume(self)

    def initialize_positions_from_rmf(self, fh, frame_number=-1):
        r"""initialize_positions_from_rmf(SimulationData self, FileConstHandle fh, int frame_number=-1)"""
        return _IMP_npctransport.SimulationData_initialize_positions_from_rmf(self, fh, frame_number)

    def link_rmf_file_handle(self, fh, is_restraints=True):
        r"""link_rmf_file_handle(SimulationData self, FileHandle fh, bool is_restraints=True)"""
        return _IMP_npctransport.SimulationData_link_rmf_file_handle(self, fh, is_restraints)

    def get_rmf_sos_writer(self):
        r"""get_rmf_sos_writer(SimulationData self) -> SaveOptimizerState"""
        return _IMP_npctransport.SimulationData_get_rmf_sos_writer(self)

    def reset_rmf(self):
        r"""reset_rmf(SimulationData self)"""
        return _IMP_npctransport.SimulationData_reset_rmf(self)

    def switch_suspend_rmf(self, suspend):
        r"""switch_suspend_rmf(SimulationData self, bool suspend)"""
        return _IMP_npctransport.SimulationData_switch_suspend_rmf(self, suspend)

    def write_geometry(self, out):
        r"""write_geometry(SimulationData self, std::string out)"""
        return _IMP_npctransport.SimulationData_write_geometry(self, out)

    def dump_geometry(self):
        r"""dump_geometry(SimulationData self)"""
        return _IMP_npctransport.SimulationData_dump_geometry(self)

    def get_root_of_type(self, type):
        r"""get_root_of_type(SimulationData self, ParticleType type) -> Hierarchy"""
        return _IMP_npctransport.SimulationData_get_root_of_type(self, type)

    def get_number_of_frames(self):
        r"""get_number_of_frames(SimulationData self) -> unsigned int"""
        return _IMP_npctransport.SimulationData_get_number_of_frames(self)

    def get_number_of_trials(self):
        r"""get_number_of_trials(SimulationData self) -> unsigned int"""
        return _IMP_npctransport.SimulationData_get_number_of_trials(self)

    def get_root(self):
        r"""get_root(SimulationData self) -> Hierarchy"""
        return _IMP_npctransport.SimulationData_get_root(self)

    def get_slab_thickness(self):
        r"""get_slab_thickness(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_slab_thickness(self)

    def get_tunnel_radius(self):
        r"""get_tunnel_radius(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_tunnel_radius(self)

    def get_pore_radius(self):
        r"""get_pore_radius(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_pore_radius(self)

    def get_tunnel_radius_k(self):
        r"""get_tunnel_radius_k(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_tunnel_radius_k(self)

    def get_pore_radius_k(self):
        r"""get_pore_radius_k(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_pore_radius_k(self)

    def get_is_pore_radius_dynamic(self):
        r"""get_is_pore_radius_dynamic(SimulationData self) -> bool"""
        return _IMP_npctransport.SimulationData_get_is_pore_radius_dynamic(self)

    def get_pore_anchored_beads_k(self):
        r"""get_pore_anchored_beads_k(SimulationData self) -> double"""
        return _IMP_npctransport.SimulationData_get_pore_anchored_beads_k(self)

    def get_static_geometry(self):
        r"""get_static_geometry(SimulationData self) -> Geometry"""
        return _IMP_npctransport.SimulationData_get_static_geometry(self)

    def get_rmf_dump_interval_frames(self):
        r"""get_rmf_dump_interval_frames(SimulationData self) -> int"""
        return _IMP_npctransport.SimulationData_get_rmf_dump_interval_frames(self)

    def get_rmf_file_name(self):
        r"""get_rmf_file_name(SimulationData self) -> std::string"""
        return _IMP_npctransport.SimulationData_get_rmf_file_name(self)

    def set_rmf_file(self, new_name, is_save_restraints_to_rmf=True, is_force_restart=False):
        r"""set_rmf_file(SimulationData self, std::string const & new_name, bool is_save_restraints_to_rmf=True, bool is_force_restart=False)"""
        return _IMP_npctransport.SimulationData_set_rmf_file(self, new_name, is_save_restraints_to_rmf, is_force_restart)

    def get_version_info(self):
        r"""get_version_info(SimulationData self) -> VersionInfo"""
        return _IMP_npctransport.SimulationData_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_SimulationData

    def __str__(self):
        r"""__str__(SimulationData self) -> std::string"""
        return _IMP_npctransport.SimulationData___str__(self)

    def __repr__(self):
        r"""__repr__(SimulationData self) -> std::string"""
        return _IMP_npctransport.SimulationData___repr__(self)

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


# Register SimulationData in _IMP_npctransport:
_IMP_npctransport.SimulationData_swigregister(SimulationData)

def get_simulation_data_key():
    r"""get_simulation_data_key() -> IMP::WeakObjectKey"""
    return _IMP_npctransport.get_simulation_data_key()

def write_geometry(kaps, kap_sites, chains, chain_sites, rs, out):
    r"""write_geometry(IMP::ParticlesTemp const & kaps, IMP::algebra::Sphere3Ds const & kap_sites, IMP::ParticlesTemp const & chains, IMP::algebra::Sphere3Ds const & chain_sites, IMP::RestraintsTemp const & rs, Writer out)"""
    return _IMP_npctransport.write_geometry(kaps, kap_sites, chains, chain_sites, rs, out)
class ParticleFactory(IMP.Object):
    r"""Proxy of C++ IMP::npctransport::ParticleFactory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    sd_ = property(_IMP_npctransport.ParticleFactory_sd__get, _IMP_npctransport.ParticleFactory_sd__set, doc=r"""sd_ : IMP::WeakPointer<(IMP::npctransport::SimulationData)>""")
    radius_ = property(_IMP_npctransport.ParticleFactory_radius__get, _IMP_npctransport.ParticleFactory_radius__set, doc=r"""radius_ : double""")
    D_factor_ = property(_IMP_npctransport.ParticleFactory_D_factor__get, _IMP_npctransport.ParticleFactory_D_factor__set, doc=r"""D_factor_ : double""")
    angular_D_factor_ = property(_IMP_npctransport.ParticleFactory_angular_D_factor__get, _IMP_npctransport.ParticleFactory_angular_D_factor__set, doc=r"""angular_D_factor_ : double""")
    color_ = property(_IMP_npctransport.ParticleFactory_color__get, _IMP_npctransport.ParticleFactory_color__set, doc=r"""color_ : IMP::display::Color""")
    type_ = property(_IMP_npctransport.ParticleFactory_type__get, _IMP_npctransport.ParticleFactory_type__set, doc=r"""type_ : IMP::core::ParticleType""")

    def __init__(self, *args):
        r"""__init__(ParticleFactory self, SimulationData sd, double radius, double D_factor, double angular_D_factor, Color color, ParticleType type, std::string name="Particle factory %1%") -> ParticleFactory"""
        _IMP_npctransport.ParticleFactory_swiginit(self, _IMP_npctransport.new_ParticleFactory(*args))

    def create(self, *args):
        r"""create(ParticleFactory self, std::string name="") -> Particle"""
        return _IMP_npctransport.ParticleFactory_create(self, *args)

    def get_model(self):
        r"""get_model(ParticleFactory self) -> Model"""
        return _IMP_npctransport.ParticleFactory_get_model(self)

    def get_simulation_data(self):
        r"""get_simulation_data(ParticleFactory self) -> SimulationData"""
        return _IMP_npctransport.ParticleFactory_get_simulation_data(self)

    def get_radius(self):
        r"""get_radius(ParticleFactory self) -> double"""
        return _IMP_npctransport.ParticleFactory_get_radius(self)

    def get_version_info(self):
        r"""get_version_info(ParticleFactory self) -> VersionInfo"""
        return _IMP_npctransport.ParticleFactory_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_ParticleFactory

    def __str__(self):
        r"""__str__(ParticleFactory self) -> std::string"""
        return _IMP_npctransport.ParticleFactory___str__(self)

    def __repr__(self):
        r"""__repr__(ParticleFactory self) -> std::string"""
        return _IMP_npctransport.ParticleFactory___repr__(self)

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


# Register ParticleFactory in _IMP_npctransport:
_IMP_npctransport.ParticleFactory_swigregister(ParticleFactory)
class HierarchyWithSitesLoadLink(IMP.rmf.HierarchyLoadLink):
    r"""Proxy of C++ IMP::npctransport::HierarchyWithSitesLoadLink class."""

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

    def __init__(self, fh):
        r"""__init__(HierarchyWithSitesLoadLink self, FileConstHandle fh) -> HierarchyWithSitesLoadLink"""
        _IMP_npctransport.HierarchyWithSitesLoadLink_swiginit(self, _IMP_npctransport.new_HierarchyWithSitesLoadLink(fh))

    @staticmethod
    def get_name():
        r"""get_name() -> char const *"""
        return _IMP_npctransport.HierarchyWithSitesLoadLink_get_name()

    def __str__(self):
        r"""__str__(HierarchyWithSitesLoadLink self) -> std::string"""
        return _IMP_npctransport.HierarchyWithSitesLoadLink___str__(self)

    def __repr__(self):
        r"""__repr__(HierarchyWithSitesLoadLink self) -> std::string"""
        return _IMP_npctransport.HierarchyWithSitesLoadLink___repr__(self)

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

    __swig_destroy__ = _IMP_npctransport.delete_HierarchyWithSitesLoadLink

# Register HierarchyWithSitesLoadLink in _IMP_npctransport:
_IMP_npctransport.HierarchyWithSitesLoadLink_swigregister(HierarchyWithSitesLoadLink)
class HierarchyWithSitesSaveLink(IMP.rmf.HierarchySaveLink):
    r"""Proxy of C++ IMP::npctransport::HierarchyWithSitesSaveLink class."""

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

    def __init__(self, fh):
        r"""__init__(HierarchyWithSitesSaveLink self, FileHandle fh) -> HierarchyWithSitesSaveLink"""
        _IMP_npctransport.HierarchyWithSitesSaveLink_swiginit(self, _IMP_npctransport.new_HierarchyWithSitesSaveLink(fh))

    @staticmethod
    def get_name():
        r"""get_name() -> char const *"""
        return _IMP_npctransport.HierarchyWithSitesSaveLink_get_name()

    def __str__(self):
        r"""__str__(HierarchyWithSitesSaveLink self) -> std::string"""
        return _IMP_npctransport.HierarchyWithSitesSaveLink___str__(self)

    def __repr__(self):
        r"""__repr__(HierarchyWithSitesSaveLink self) -> std::string"""
        return _IMP_npctransport.HierarchyWithSitesSaveLink___repr__(self)

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

    __swig_destroy__ = _IMP_npctransport.delete_HierarchyWithSitesSaveLink

# Register HierarchyWithSitesSaveLink in _IMP_npctransport:
_IMP_npctransport.HierarchyWithSitesSaveLink_swigregister(HierarchyWithSitesSaveLink)

def add_test_sites(*args):
    r"""
    add_test_sites(FileHandle fh, ParticleType t, double display_radius, IMP::algebra::Vector3Ds sites)
    add_test_sites(FileHandle fh, ParticleType t, IMP::algebra::Sphere3Ds sites)
    """
    return _IMP_npctransport.add_test_sites(*args)

def add_hierarchies_with_sites(*args):
    r"""
    add_hierarchies_with_sites(FileHandle fh, IMP::atom::Hierarchies const & hs)
    add_hierarchies_with_sites(NodeHandle fh, IMP::atom::Hierarchies const & hs)
    """
    return _IMP_npctransport.add_hierarchies_with_sites(*args)

def add_hierarchy_with_sites(fh, hs):
    r"""add_hierarchy_with_sites(FileHandle fh, Hierarchy hs)"""
    return _IMP_npctransport.add_hierarchy_with_sites(fh, hs)

def create_hierarchies_with_sites(fh, m):
    r"""create_hierarchies_with_sites(FileConstHandle fh, Model m) -> IMP::atom::Hierarchies"""
    return _IMP_npctransport.create_hierarchies_with_sites(fh, m)

def link_hierarchies_with_sites(fh, hs):
    r"""link_hierarchies_with_sites(FileConstHandle fh, IMP::atom::Hierarchies const & hs)"""
    return _IMP_npctransport.link_hierarchies_with_sites(fh, hs)
class Transporting(IMP.Decorator):
    r"""Proxy of C++ IMP::npctransport::Transporting 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__(Transporting self) -> Transporting
        __init__(Transporting self, Model m, ParticleIndex id) -> Transporting
        __init__(Transporting self, _ParticleAdaptor d) -> Transporting
        """
        _IMP_npctransport.Transporting_swiginit(self, _IMP_npctransport.new_Transporting(*args))

    def show(self, *args):
        r"""show(Transporting self, _ostream out=std::cout)"""
        return _IMP_npctransport.Transporting_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, bool is_last_entry_from_top=False) -> Transporting
        setup_particle(_ParticleAdaptor pa, bool is_last_entry_from_top=False) -> Transporting
        """
        return _IMP_npctransport.Transporting_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_npctransport.Transporting_get_is_setup(*args)

    def set_is_last_entry_from_top(self, is_last_entry_from_top):
        r"""set_is_last_entry_from_top(Transporting self, bool is_last_entry_from_top)"""
        return _IMP_npctransport.Transporting_set_is_last_entry_from_top(self, is_last_entry_from_top)

    def get_is_last_entry_from_top(self):
        r"""get_is_last_entry_from_top(Transporting self) -> bool"""
        return _IMP_npctransport.Transporting_get_is_last_entry_from_top(self)

    @staticmethod
    def get_is_last_entry_from_top_key():
        r"""get_is_last_entry_from_top_key() -> IntKey"""
        return _IMP_npctransport.Transporting_get_is_last_entry_from_top_key()

    def set_last_tracked_z(self, last_tracked_z):
        r"""set_last_tracked_z(Transporting self, double last_tracked_z)"""
        return _IMP_npctransport.Transporting_set_last_tracked_z(self, last_tracked_z)

    def get_last_tracked_z(self):
        r"""get_last_tracked_z(Transporting self) -> double"""
        return _IMP_npctransport.Transporting_get_last_tracked_z(self)

    @staticmethod
    def get_last_tracked_z_key():
        r"""get_last_tracked_z_key() -> FloatKey"""
        return _IMP_npctransport.Transporting_get_last_tracked_z_key()

    def set_n_entries_bottom(self, n):
        r"""set_n_entries_bottom(Transporting self, int n)"""
        return _IMP_npctransport.Transporting_set_n_entries_bottom(self, n)

    def get_n_entries_bottom(self):
        r"""get_n_entries_bottom(Transporting self) -> int"""
        return _IMP_npctransport.Transporting_get_n_entries_bottom(self)

    @staticmethod
    def get_n_entries_bottom_key():
        r"""get_n_entries_bottom_key() -> IntKey"""
        return _IMP_npctransport.Transporting_get_n_entries_bottom_key()

    def set_n_entries_top(self, n):
        r"""set_n_entries_top(Transporting self, int n)"""
        return _IMP_npctransport.Transporting_set_n_entries_top(self, n)

    def get_n_entries_top(self):
        r"""get_n_entries_top(Transporting self) -> int"""
        return _IMP_npctransport.Transporting_get_n_entries_top(self)

    @staticmethod
    def get_n_entries_top_key():
        r"""get_n_entries_top_key() -> IntKey"""
        return _IMP_npctransport.Transporting_get_n_entries_top_key()

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

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

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

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

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

    def get_derivative(self, a0):
        r"""get_derivative(Transporting self, FloatKey a0) -> double"""
        return _IMP_npctransport.Transporting_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(Transporting self) -> std::string"""
        return _IMP_npctransport.Transporting_get_name(self)

    def clear_caches(self):
        r"""clear_caches(Transporting self)"""
        return _IMP_npctransport.Transporting_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(Transporting self, std::string a0)"""
        return _IMP_npctransport.Transporting_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(Transporting self, IMP::CheckLevel a0)"""
        return _IMP_npctransport.Transporting_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(Transporting self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_npctransport.Transporting_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(Transporting self, FloatKey a0, bool a1)"""
        return _IMP_npctransport.Transporting_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(Transporting self, FloatKey a0) -> bool"""
        return _IMP_npctransport.Transporting_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(Transporting self) -> IMP::CheckLevel"""
        return _IMP_npctransport.Transporting_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(Transporting self, Transporting o) -> bool
        __eq__(Transporting self, Particle d) -> bool
        """
        return _IMP_npctransport.Transporting___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(Transporting self, Transporting o) -> bool
        __ne__(Transporting self, Particle d) -> bool
        """
        return _IMP_npctransport.Transporting___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(Transporting self, Transporting o) -> bool
        __le__(Transporting self, Particle d) -> bool
        """
        return _IMP_npctransport.Transporting___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(Transporting self, Transporting o) -> bool
        __lt__(Transporting self, Particle d) -> bool
        """
        return _IMP_npctransport.Transporting___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(Transporting self, Transporting o) -> bool
        __ge__(Transporting self, Particle d) -> bool
        """
        return _IMP_npctransport.Transporting___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(Transporting self, Transporting o) -> bool
        __gt__(Transporting self, Particle d) -> bool
        """
        return _IMP_npctransport.Transporting___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(Transporting self) -> std::size_t"""
        return _IMP_npctransport.Transporting___hash__(self)

    def __str__(self):
        r"""__str__(Transporting self) -> std::string"""
        return _IMP_npctransport.Transporting___str__(self)

    def __repr__(self):
        r"""__repr__(Transporting self) -> std::string"""
        return _IMP_npctransport.Transporting___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(Transporting self) -> PyObject *"""
        return _IMP_npctransport.Transporting__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Transporting self, PyObject * p)"""
        return _IMP_npctransport.Transporting__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_npctransport.delete_Transporting

# Register Transporting in _IMP_npctransport:
_IMP_npctransport.Transporting_swigregister(Transporting)

def show_ranges(fname):
    r"""show_ranges(std::string fname)"""
    return _IMP_npctransport.show_ranges(fname)

def assign_ranges(input_config_fname, output_assignment_fname, work_unit, show_steps, random_seed):
    r"""assign_ranges(std::string input_config_fname, std::string output_assignment_fname, unsigned int work_unit, bool show_steps, boost::uint64_t random_seed) -> int"""
    return _IMP_npctransport.assign_ranges(input_config_fname, output_assignment_fname, work_unit, show_steps, random_seed)

def get_number_of_work_units(configuration_file):
    r"""get_number_of_work_units(std::string configuration_file) -> int"""
    return _IMP_npctransport.get_number_of_work_units(configuration_file)
class SlabWithPore(IMP.Decorator):
    r"""Proxy of C++ IMP::npctransport::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_npctransport.SlabWithPore_swiginit(self, _IMP_npctransport.new_SlabWithPore(*args))

    def show(self, *args):
        r"""show(SlabWithPore self, _ostream out=std::cout)"""
        return _IMP_npctransport.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_npctransport.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_npctransport.SlabWithPore_get_is_setup(*args)

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

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

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

    def set_pore_radius(self, r):
        r"""set_pore_radius(SlabWithPore self, double r)"""
        return _IMP_npctransport.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_npctransport.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_npctransport.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_npctransport.SlabWithPore_set_pore_radius_is_optimized(self, tf)

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

    @staticmethod
    def get_pore_radius_key():
        r"""get_pore_radius_key() -> FloatKey"""
        return _IMP_npctransport.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_npctransport.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_npctransport.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_npctransport.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_npctransport.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_npctransport.SlabWithPore_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""set_check_level(SlabWithPore self, IMP::CheckLevel a0)"""
        return _IMP_npctransport.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_npctransport.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_npctransport.SlabWithPore_set_is_optimized(self, a0, a1)

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SlabWithPore in _IMP_npctransport:
_IMP_npctransport.SlabWithPore_swigregister(SlabWithPore)
class SlabWithCylindricalPore(SlabWithPore):
    r"""Proxy of C++ IMP::npctransport::SlabWithCylindricalPore 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__(SlabWithCylindricalPore self) -> SlabWithCylindricalPore
        __init__(SlabWithCylindricalPore self, Model m, ParticleIndex id) -> SlabWithCylindricalPore
        __init__(SlabWithCylindricalPore self, _ParticleAdaptor d) -> SlabWithCylindricalPore
        """
        _IMP_npctransport.SlabWithCylindricalPore_swiginit(self, _IMP_npctransport.new_SlabWithCylindricalPore(*args))

    def show(self, *args):
        r"""show(SlabWithCylindricalPore self, _ostream out=std::cout)"""
        return _IMP_npctransport.SlabWithCylindricalPore_show(self, *args)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, double thickness, double radius) -> SlabWithCylindricalPore
        setup_particle(_ParticleAdaptor pa, double thickness, double radius) -> SlabWithCylindricalPore
        """
        return _IMP_npctransport.SlabWithCylindricalPore_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_npctransport.SlabWithCylindricalPore_get_is_setup(*args)

    @staticmethod
    def get_cylindrical_pore_key():
        r"""get_cylindrical_pore_key() -> IntKey"""
        return _IMP_npctransport.SlabWithCylindricalPore_get_cylindrical_pore_key()

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

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

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

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

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

    def get_derivative(self, a0):
        r"""get_derivative(SlabWithCylindricalPore self, FloatKey a0) -> double"""
        return _IMP_npctransport.SlabWithCylindricalPore_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(SlabWithCylindricalPore self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPore_get_name(self)

    def clear_caches(self):
        r"""clear_caches(SlabWithCylindricalPore self)"""
        return _IMP_npctransport.SlabWithCylindricalPore_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(SlabWithCylindricalPore self, std::string a0)"""
        return _IMP_npctransport.SlabWithCylindricalPore_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(SlabWithCylindricalPore self, IMP::CheckLevel a0)"""
        return _IMP_npctransport.SlabWithCylindricalPore_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(SlabWithCylindricalPore self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_npctransport.SlabWithCylindricalPore_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(SlabWithCylindricalPore self, FloatKey a0, bool a1)"""
        return _IMP_npctransport.SlabWithCylindricalPore_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(SlabWithCylindricalPore self, FloatKey a0) -> bool"""
        return _IMP_npctransport.SlabWithCylindricalPore_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(SlabWithCylindricalPore self) -> IMP::CheckLevel"""
        return _IMP_npctransport.SlabWithCylindricalPore_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(SlabWithCylindricalPore self, SlabWithCylindricalPore o) -> bool
        __eq__(SlabWithCylindricalPore self, Particle d) -> bool
        """
        return _IMP_npctransport.SlabWithCylindricalPore___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(SlabWithCylindricalPore self, SlabWithCylindricalPore o) -> bool
        __ne__(SlabWithCylindricalPore self, Particle d) -> bool
        """
        return _IMP_npctransport.SlabWithCylindricalPore___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(SlabWithCylindricalPore self, SlabWithCylindricalPore o) -> bool
        __le__(SlabWithCylindricalPore self, Particle d) -> bool
        """
        return _IMP_npctransport.SlabWithCylindricalPore___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(SlabWithCylindricalPore self, SlabWithCylindricalPore o) -> bool
        __lt__(SlabWithCylindricalPore self, Particle d) -> bool
        """
        return _IMP_npctransport.SlabWithCylindricalPore___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(SlabWithCylindricalPore self, SlabWithCylindricalPore o) -> bool
        __ge__(SlabWithCylindricalPore self, Particle d) -> bool
        """
        return _IMP_npctransport.SlabWithCylindricalPore___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(SlabWithCylindricalPore self, SlabWithCylindricalPore o) -> bool
        __gt__(SlabWithCylindricalPore self, Particle d) -> bool
        """
        return _IMP_npctransport.SlabWithCylindricalPore___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(SlabWithCylindricalPore self) -> std::size_t"""
        return _IMP_npctransport.SlabWithCylindricalPore___hash__(self)

    def __str__(self):
        r"""__str__(SlabWithCylindricalPore self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithCylindricalPore self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPore___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(SlabWithCylindricalPore self) -> PyObject *"""
        return _IMP_npctransport.SlabWithCylindricalPore__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(SlabWithCylindricalPore self, PyObject * p)"""
        return _IMP_npctransport.SlabWithCylindricalPore__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_npctransport.delete_SlabWithCylindricalPore

# Register SlabWithCylindricalPore in _IMP_npctransport:
_IMP_npctransport.SlabWithCylindricalPore_swigregister(SlabWithCylindricalPore)
class SlabWithToroidalPore(SlabWithPore):
    r"""Proxy of C++ IMP::npctransport::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_npctransport.SlabWithToroidalPore_swiginit(self, _IMP_npctransport.new_SlabWithToroidalPore(*args))

    def show(self, *args):
        r"""show(SlabWithToroidalPore self, _ostream out=std::cout)"""
        return _IMP_npctransport.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_npctransport.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_npctransport.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_npctransport.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_npctransport.SlabWithToroidalPore_get_minor_radius_h2v_aspect_ratio(self)

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

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

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

    def set_horizontal_minor_radius(self, rh):
        r"""set_horizontal_minor_radius(SlabWithToroidalPore self, double rh)"""
        return _IMP_npctransport.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_npctransport.SlabWithToroidalPore_get_minor_radius_h2v_aspect_ratio_key()

    @staticmethod
    def get_toroidal_pore_key():
        r"""get_toroidal_pore_key() -> IntKey"""
        return _IMP_npctransport.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_npctransport.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_npctransport.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_npctransport.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_npctransport.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_npctransport.SlabWithToroidalPore_has_attribute(self, *args)

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

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

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

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

    def set_check_level(self, a0):
        r"""set_check_level(SlabWithToroidalPore self, IMP::CheckLevel a0)"""
        return _IMP_npctransport.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_npctransport.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_npctransport.SlabWithToroidalPore_set_is_optimized(self, a0, a1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def __lshift__(*args):
    r"""
    __lshift__(_ostream out, RelaxingSpring n) -> _ostream
    __lshift__(_ostream out, Transporting n) -> _ostream
    __lshift__(_ostream out, SlabWithPore n) -> _ostream
    __lshift__(_ostream out, SlabWithCylindricalPore n) -> _ostream
    __lshift__(_ostream out, SlabWithToroidalPore n) -> _ostream
    """
    return _IMP_npctransport.__lshift__(*args)
class SlabWithCylindricalPorePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npctransport::SlabWithCylindricalPorePairScore 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__(SlabWithCylindricalPorePairScore self, double k) -> SlabWithCylindricalPorePairScore"""
        _IMP_npctransport.SlabWithCylindricalPorePairScore_swiginit(self, _IMP_npctransport.new_SlabWithCylindricalPorePairScore(k))

    def get_displacement_direction(self, slab, v):
        r"""get_displacement_direction(SlabWithCylindricalPorePairScore self, SlabWithCylindricalPore slab, Vector3D v) -> Vector3D"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore_get_displacement_direction(self, slab, v)

    def get_displacement_magnitude(self, slab, v):
        r"""get_displacement_magnitude(SlabWithCylindricalPorePairScore self, SlabWithCylindricalPore slab, Vector3D v) -> double"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore_get_displacement_magnitude(self, slab, v)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(SlabWithCylindricalPorePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SlabWithCylindricalPorePairScore self, Model m, IMP::ParticleIndexPairs const & pips, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore_evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, all_indexes_checked)

    def evaluate_if_good_indexes(self, m, pips, da, max, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_if_good_indexes(SlabWithCylindricalPorePairScore self, Model m, IMP::ParticleIndexPairs const & pips, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore_evaluate_if_good_indexes(self, m, pips, da, max, lower_bound, upper_bound, all_indexes_checked)

    def get_version_info(self):
        r"""get_version_info(SlabWithCylindricalPorePairScore self) -> VersionInfo"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_SlabWithCylindricalPorePairScore

    def __str__(self):
        r"""__str__(SlabWithCylindricalPorePairScore self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithCylindricalPorePairScore self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPorePairScore___repr__(self)

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


# Register SlabWithCylindricalPorePairScore in _IMP_npctransport:
_IMP_npctransport.SlabWithCylindricalPorePairScore_swigregister(SlabWithCylindricalPorePairScore)
class SlabWithToroidalPorePairScore(IMP.PairScore):
    r"""Proxy of C++ IMP::npctransport::SlabWithToroidalPorePairScore 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__(SlabWithToroidalPorePairScore self, double k) -> SlabWithToroidalPorePairScore"""
        _IMP_npctransport.SlabWithToroidalPorePairScore_swiginit(self, _IMP_npctransport.new_SlabWithToroidalPorePairScore(k))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(SlabWithToroidalPorePairScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.SlabWithToroidalPorePairScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(SlabWithToroidalPorePairScore self, Model m, IMP::ParticleIndexPairs const & pips, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.SlabWithToroidalPorePairScore_evaluate_indexes(self, m, pips, da, lower_bound, upper_bound, 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(SlabWithToroidalPorePairScore 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_npctransport.SlabWithToroidalPorePairScore_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(SlabWithToroidalPorePairScore self) -> VersionInfo"""
        return _IMP_npctransport.SlabWithToroidalPorePairScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_SlabWithToroidalPorePairScore

    def __str__(self):
        r"""__str__(SlabWithToroidalPorePairScore self) -> std::string"""
        return _IMP_npctransport.SlabWithToroidalPorePairScore___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithToroidalPorePairScore self) -> std::string"""
        return _IMP_npctransport.SlabWithToroidalPorePairScore___repr__(self)

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


# Register SlabWithToroidalPorePairScore in _IMP_npctransport:
_IMP_npctransport.SlabWithToroidalPorePairScore_swigregister(SlabWithToroidalPorePairScore)
class SlabWithCylindricalPoreWireGeometry(IMP.display.Geometry):
    r"""Proxy of C++ IMP::npctransport::SlabWithCylindricalPoreWireGeometry class."""

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

    def __init__(self, height, radius, length):
        r"""__init__(SlabWithCylindricalPoreWireGeometry self, double height, double radius, double length) -> SlabWithCylindricalPoreWireGeometry"""
        _IMP_npctransport.SlabWithCylindricalPoreWireGeometry_swiginit(self, _IMP_npctransport.new_SlabWithCylindricalPoreWireGeometry(height, radius, length))

    def get_version_info(self):
        r"""get_version_info(SlabWithCylindricalPoreWireGeometry self) -> VersionInfo"""
        return _IMP_npctransport.SlabWithCylindricalPoreWireGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_SlabWithCylindricalPoreWireGeometry

    def __str__(self):
        r"""__str__(SlabWithCylindricalPoreWireGeometry self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPoreWireGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithCylindricalPoreWireGeometry self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPoreWireGeometry___repr__(self)

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


# Register SlabWithCylindricalPoreWireGeometry in _IMP_npctransport:
_IMP_npctransport.SlabWithCylindricalPoreWireGeometry_swigregister(SlabWithCylindricalPoreWireGeometry)
class SlabWithCylindricalPoreSurfaceGeometry(IMP.display.SurfaceMeshGeometry):
    r"""Proxy of C++ IMP::npctransport::SlabWithCylindricalPoreSurfaceGeometry class."""

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

    def __init__(self, height, radius, length):
        r"""__init__(SlabWithCylindricalPoreSurfaceGeometry self, double height, double radius, double length) -> SlabWithCylindricalPoreSurfaceGeometry"""
        _IMP_npctransport.SlabWithCylindricalPoreSurfaceGeometry_swiginit(self, _IMP_npctransport.new_SlabWithCylindricalPoreSurfaceGeometry(height, radius, length))

    def __str__(self):
        r"""__str__(SlabWithCylindricalPoreSurfaceGeometry self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPoreSurfaceGeometry___str__(self)

    def __repr__(self):
        r"""__repr__(SlabWithCylindricalPoreSurfaceGeometry self) -> std::string"""
        return _IMP_npctransport.SlabWithCylindricalPoreSurfaceGeometry___repr__(self)

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

    __swig_destroy__ = _IMP_npctransport.delete_SlabWithCylindricalPoreSurfaceGeometry

# Register SlabWithCylindricalPoreSurfaceGeometry in _IMP_npctransport:
_IMP_npctransport.SlabWithCylindricalPoreSurfaceGeometry_swigregister(SlabWithCylindricalPoreSurfaceGeometry)
class SlabWithToroidalPoreWireGeometry(IMP.display.Geometry):
    r"""Proxy of C++ IMP::npctransport::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_npctransport.SlabWithToroidalPoreWireGeometry_swiginit(self, _IMP_npctransport.new_SlabWithToroidalPoreWireGeometry(*args))

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

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

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

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


# Register SlabWithToroidalPoreWireGeometry in _IMP_npctransport:
_IMP_npctransport.SlabWithToroidalPoreWireGeometry_swigregister(SlabWithToroidalPoreWireGeometry)
class _GenericAttributeSingletonScoreForPoreRadus(IMP.SingletonScore):
    r"""Proxy of C++ IMP::core::GenericAttributeSingletonScore< IMP::core::Harmonic > class."""

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

    def __init__(self, f, k):
        r"""__init__(_GenericAttributeSingletonScoreForPoreRadus self, Harmonic f, FloatKey k) -> _GenericAttributeSingletonScoreForPoreRadus"""
        _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_swiginit(self, _IMP_npctransport.new__GenericAttributeSingletonScoreForPoreRadus(f, k))

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(_GenericAttributeSingletonScoreForPoreRadus self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_do_get_inputs(self, m, pis)

    def get_unary_function(self):
        r"""get_unary_function(_GenericAttributeSingletonScoreForPoreRadus self) -> Harmonic"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_get_unary_function(self)

    def get_key(self):
        r"""get_key(_GenericAttributeSingletonScoreForPoreRadus self) -> FloatKey"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_get_key(self)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(_GenericAttributeSingletonScoreForPoreRadus self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_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(_GenericAttributeSingletonScoreForPoreRadus self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_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(_GenericAttributeSingletonScoreForPoreRadus self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_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(_GenericAttributeSingletonScoreForPoreRadus self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_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(_GenericAttributeSingletonScoreForPoreRadus self) -> VersionInfo"""
        return _IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete__GenericAttributeSingletonScoreForPoreRadus

# Register _GenericAttributeSingletonScoreForPoreRadus in _IMP_npctransport:
_IMP_npctransport._GenericAttributeSingletonScoreForPoreRadus_swigregister(_GenericAttributeSingletonScoreForPoreRadus)
class PoreRadiusSingletonScore(_GenericAttributeSingletonScoreForPoreRadus):
    r"""Proxy of C++ IMP::npctransport::PoreRadiusSingletonScore class."""

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

    def __init__(self, mean, k):
        r"""__init__(PoreRadiusSingletonScore self, IMP::Float mean, IMP::Float k) -> PoreRadiusSingletonScore"""
        _IMP_npctransport.PoreRadiusSingletonScore_swiginit(self, _IMP_npctransport.new_PoreRadiusSingletonScore(mean, k))

    def set_k(self, k):
        r"""set_k(PoreRadiusSingletonScore self, double k)"""
        return _IMP_npctransport.PoreRadiusSingletonScore_set_k(self, k)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(PoreRadiusSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.PoreRadiusSingletonScore_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(PoreRadiusSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.PoreRadiusSingletonScore_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(PoreRadiusSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.PoreRadiusSingletonScore_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(PoreRadiusSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.PoreRadiusSingletonScore_evaluate_if_good_indexes(self, m, p, da, max, lower_bound, upper_bound, all_indexes_checked)
    __swig_destroy__ = _IMP_npctransport.delete_PoreRadiusSingletonScore

    def __str__(self):
        r"""__str__(PoreRadiusSingletonScore self) -> std::string"""
        return _IMP_npctransport.PoreRadiusSingletonScore___str__(self)

    def __repr__(self):
        r"""__repr__(PoreRadiusSingletonScore self) -> std::string"""
        return _IMP_npctransport.PoreRadiusSingletonScore___repr__(self)

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


# Register PoreRadiusSingletonScore in _IMP_npctransport:
_IMP_npctransport.PoreRadiusSingletonScore_swigregister(PoreRadiusSingletonScore)
class ExcludeZRangeSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::npctransport::ExcludeZRangeSingletonScore class."""

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

    def __init__(self, bottom, top, k):
        r"""__init__(ExcludeZRangeSingletonScore self, double bottom, double top, double k) -> ExcludeZRangeSingletonScore"""
        _IMP_npctransport.ExcludeZRangeSingletonScore_swiginit(self, _IMP_npctransport.new_ExcludeZRangeSingletonScore(bottom, top, k))

    def get_bottom_z(self):
        r"""get_bottom_z(ExcludeZRangeSingletonScore self) -> double"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_get_bottom_z(self)

    def get_top_z(self):
        r"""get_top_z(ExcludeZRangeSingletonScore self) -> double"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_get_top_z(self)

    def get_k(self):
        r"""get_k(ExcludeZRangeSingletonScore self) -> double"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_get_k(self)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(ExcludeZRangeSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(ExcludeZRangeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_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(ExcludeZRangeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_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(ExcludeZRangeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_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(ExcludeZRangeSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_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(ExcludeZRangeSingletonScore self) -> VersionInfo"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_ExcludeZRangeSingletonScore

    def __str__(self):
        r"""__str__(ExcludeZRangeSingletonScore self) -> std::string"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore___str__(self)

    def __repr__(self):
        r"""__repr__(ExcludeZRangeSingletonScore self) -> std::string"""
        return _IMP_npctransport.ExcludeZRangeSingletonScore___repr__(self)

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


# Register ExcludeZRangeSingletonScore in _IMP_npctransport:
_IMP_npctransport.ExcludeZRangeSingletonScore_swigregister(ExcludeZRangeSingletonScore)
class ZBiasSingletonScore(IMP.SingletonScore):
    r"""Proxy of C++ IMP::npctransport::ZBiasSingletonScore 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__(ZBiasSingletonScore self, double k, double max_r=HALF_SQRT_MAX_DOUBLE, double z=std::numeric_limits< double >::min()) -> ZBiasSingletonScore"""
        _IMP_npctransport.ZBiasSingletonScore_swiginit(self, _IMP_npctransport.new_ZBiasSingletonScore(*args))

    def get_k(self):
        r"""get_k(ZBiasSingletonScore self) -> double"""
        return _IMP_npctransport.ZBiasSingletonScore_get_k(self)

    def evaluate_deriv(self, d):
        r"""evaluate_deriv(ZBiasSingletonScore self, XYZR d) -> std::pair< double,IMP::algebra::Vector3D >"""
        return _IMP_npctransport.ZBiasSingletonScore_evaluate_deriv(self, d)

    def do_get_inputs(self, m, pis):
        r"""do_get_inputs(ZBiasSingletonScore self, Model m, IMP::ParticleIndexes const & pis) -> IMP::ModelObjectsTemp"""
        return _IMP_npctransport.ZBiasSingletonScore_do_get_inputs(self, m, pis)

    def evaluate_indexes(self, m, p, da, lower_bound, upper_bound, all_indexes_checked=False):
        r"""evaluate_indexes(ZBiasSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ZBiasSingletonScore_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(ZBiasSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, unsigned int lower_bound, unsigned int upper_bound, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ZBiasSingletonScore_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(ZBiasSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, std::vector< unsigned int,std::allocator< unsigned int > > const & indexes, DistBase score, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ZBiasSingletonScore_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(ZBiasSingletonScore self, Model m, IMP::ParticleIndexes const & p, DerivativeAccumulator da, double max, unsigned int lower_bound, unsigned int upper_bound, bool all_indexes_checked=False) -> double"""
        return _IMP_npctransport.ZBiasSingletonScore_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(ZBiasSingletonScore self) -> VersionInfo"""
        return _IMP_npctransport.ZBiasSingletonScore_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_ZBiasSingletonScore

    def __str__(self):
        r"""__str__(ZBiasSingletonScore self) -> std::string"""
        return _IMP_npctransport.ZBiasSingletonScore___str__(self)

    def __repr__(self):
        r"""__repr__(ZBiasSingletonScore self) -> std::string"""
        return _IMP_npctransport.ZBiasSingletonScore___repr__(self)

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


# Register ZBiasSingletonScore in _IMP_npctransport:
_IMP_npctransport.ZBiasSingletonScore_swigregister(ZBiasSingletonScore)
class BodyStatisticsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::npctransport::BodyStatisticsOptimizerState class."""

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

    def __init__(self, p, statistics_manager=None, periodicity=1):
        r"""__init__(BodyStatisticsOptimizerState self, Particle p, Statistics statistics_manager=None, unsigned int periodicity=1) -> BodyStatisticsOptimizerState"""
        _IMP_npctransport.BodyStatisticsOptimizerState_swiginit(self, _IMP_npctransport.new_BodyStatisticsOptimizerState(p, statistics_manager, periodicity))

    def get_correlation_time(self):
        r"""get_correlation_time(BodyStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BodyStatisticsOptimizerState_get_correlation_time(self)

    def get_diffusion_coefficient(self):
        r"""get_diffusion_coefficient(BodyStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BodyStatisticsOptimizerState_get_diffusion_coefficient(self)

    def update_particle_type_zr_distribution_map(self):
        r"""update_particle_type_zr_distribution_map(BodyStatisticsOptimizerState self)"""
        return _IMP_npctransport.BodyStatisticsOptimizerState_update_particle_type_zr_distribution_map(self)

    def do_update(self, call_num):
        r"""do_update(BodyStatisticsOptimizerState self, unsigned int call_num)"""
        return _IMP_npctransport.BodyStatisticsOptimizerState_do_update(self, call_num)

    def get_version_info(self):
        r"""get_version_info(BodyStatisticsOptimizerState self) -> VersionInfo"""
        return _IMP_npctransport.BodyStatisticsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_BodyStatisticsOptimizerState

    def __str__(self):
        r"""__str__(BodyStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.BodyStatisticsOptimizerState___str__(self)

    def __repr__(self):
        r"""__repr__(BodyStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.BodyStatisticsOptimizerState___repr__(self)

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


# Register BodyStatisticsOptimizerState in _IMP_npctransport:
_IMP_npctransport.BodyStatisticsOptimizerState_swigregister(BodyStatisticsOptimizerState)
class ParticleTransportStatisticsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::npctransport::ParticleTransportStatisticsOptimizerState class."""

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

    def __init__(self, p, bottom_z, top_z, statistics_manager=None, owner=None):
        r"""__init__(ParticleTransportStatisticsOptimizerState self, Particle p, IMP::Float bottom_z, IMP::Float top_z, WeakPointer< IMP::npctransport::Statistics > statistics_manager=None, WeakPointer< IMP::atom::Simulator > owner=None) -> ParticleTransportStatisticsOptimizerState"""
        _IMP_npctransport.ParticleTransportStatisticsOptimizerState_swiginit(self, _IMP_npctransport.new_ParticleTransportStatisticsOptimizerState(p, bottom_z, top_z, statistics_manager, owner))

    def set_owner(self, owner):
        r"""set_owner(ParticleTransportStatisticsOptimizerState self, WeakPointer< IMP::atom::Simulator > owner)"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_set_owner(self, owner)

    def get_owner(self):
        r"""get_owner(ParticleTransportStatisticsOptimizerState self) -> Simulator"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_get_owner(self)

    def get_n_transports_up(self):
        r"""get_n_transports_up(ParticleTransportStatisticsOptimizerState self) -> unsigned int"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_get_n_transports_up(self)

    def get_n_transports_down(self):
        r"""get_n_transports_down(ParticleTransportStatisticsOptimizerState self) -> unsigned int"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_get_n_transports_down(self)

    def get_total_n_transports(self):
        r"""get_total_n_transports(ParticleTransportStatisticsOptimizerState self) -> unsigned int"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_get_total_n_transports(self)

    def get_transport_time_points_in_ns(self):
        r"""get_transport_time_points_in_ns(ParticleTransportStatisticsOptimizerState self) -> IMP::Floats const &"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_get_transport_time_points_in_ns(self)

    def do_update(self, call_num):
        r"""do_update(ParticleTransportStatisticsOptimizerState self, unsigned int call_num)"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_do_update(self, call_num)

    def get_version_info(self):
        r"""get_version_info(ParticleTransportStatisticsOptimizerState self) -> VersionInfo"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_ParticleTransportStatisticsOptimizerState

    def __str__(self):
        r"""__str__(ParticleTransportStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState___str__(self)

    def __repr__(self):
        r"""__repr__(ParticleTransportStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.ParticleTransportStatisticsOptimizerState___repr__(self)

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


# Register ParticleTransportStatisticsOptimizerState in _IMP_npctransport:
_IMP_npctransport.ParticleTransportStatisticsOptimizerState_swigregister(ParticleTransportStatisticsOptimizerState)
class ChainStatisticsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::npctransport::ChainStatisticsOptimizerState class."""

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

    def __init__(self, ps, periodicity=1):
        r"""__init__(ChainStatisticsOptimizerState self, IMP::ParticlesTemp const & ps, unsigned int periodicity=1) -> ChainStatisticsOptimizerState"""
        _IMP_npctransport.ChainStatisticsOptimizerState_swiginit(self, _IMP_npctransport.new_ChainStatisticsOptimizerState(ps, periodicity))

    def get_correlation_time(self):
        r"""get_correlation_time(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_correlation_time(self)

    def get_local_diffusion_coefficients(self):
        r"""get_local_diffusion_coefficients(ChainStatisticsOptimizerState self) -> IMP::Floats"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_local_diffusion_coefficients(self)

    def get_diffusion_coefficient(self):
        r"""get_diffusion_coefficient(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_diffusion_coefficient(self)

    def get_mean_radius_of_gyration(self):
        r"""get_mean_radius_of_gyration(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_mean_radius_of_gyration(self)

    def get_mean_square_radius_of_gyration(self):
        r"""get_mean_square_radius_of_gyration(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_mean_square_radius_of_gyration(self)

    def get_mean_end_to_end_distance(self):
        r"""get_mean_end_to_end_distance(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_mean_end_to_end_distance(self)

    def get_mean_square_end_to_end_distance(self):
        r"""get_mean_square_end_to_end_distance(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_mean_square_end_to_end_distance(self)

    def get_mean_bond_distance(self):
        r"""get_mean_bond_distance(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_mean_bond_distance(self)

    def get_mean_square_bond_distance(self):
        r"""get_mean_square_bond_distance(ChainStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_mean_square_bond_distance(self)

    def do_update(self, call_num):
        r"""do_update(ChainStatisticsOptimizerState self, unsigned int call_num)"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_do_update(self, call_num)

    def get_version_info(self):
        r"""get_version_info(ChainStatisticsOptimizerState self) -> VersionInfo"""
        return _IMP_npctransport.ChainStatisticsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_ChainStatisticsOptimizerState

    def __str__(self):
        r"""__str__(ChainStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.ChainStatisticsOptimizerState___str__(self)

    def __repr__(self):
        r"""__repr__(ChainStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.ChainStatisticsOptimizerState___repr__(self)

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


# Register ChainStatisticsOptimizerState in _IMP_npctransport:
_IMP_npctransport.ChainStatisticsOptimizerState_swigregister(ChainStatisticsOptimizerState)
class BipartitePairsStatisticsOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::npctransport::BipartitePairsStatisticsOptimizerState class."""

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

    def __init__(self, statistics_manager, interaction_type, particlesI, particlesII, contact_range=1.0, slack=1.0):
        r"""__init__(BipartitePairsStatisticsOptimizerState self, Statistics statistics_manager, IMP::npctransport::InteractionType interaction_type, IMP::ParticlesTemp const & particlesI, IMP::ParticlesTemp const & particlesII, double contact_range=1.0, double slack=1.0) -> BipartitePairsStatisticsOptimizerState"""
        _IMP_npctransport.BipartitePairsStatisticsOptimizerState_swiginit(self, _IMP_npctransport.new_BipartitePairsStatisticsOptimizerState(statistics_manager, interaction_type, particlesI, particlesII, contact_range, slack))

    def get_interaction_type(self):
        r"""get_interaction_type(BipartitePairsStatisticsOptimizerState self) -> IMP::npctransport::InteractionType"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_interaction_type(self)

    def get_average_number_of_contacts(self):
        r"""get_average_number_of_contacts(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_number_of_contacts(self)

    def get_average_off_per_contact_per_ns(self):
        r"""get_average_off_per_contact_per_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_off_per_contact_per_ns(self)

    def get_average_off_per_bound_I_per_ns(self):
        r"""get_average_off_per_bound_I_per_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_off_per_bound_I_per_ns(self)

    def get_average_off_per_bound_II_per_ns(self):
        r"""get_average_off_per_bound_II_per_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_off_per_bound_II_per_ns(self)

    def get_average_on_per_missing_contact_per_ns(self):
        r"""get_average_on_per_missing_contact_per_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_on_per_missing_contact_per_ns(self)

    def get_average_on_per_unbound_I_per_ns(self):
        r"""get_average_on_per_unbound_I_per_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_on_per_unbound_I_per_ns(self)

    def get_average_on_per_unbound_II_per_ns(self):
        r"""get_average_on_per_unbound_II_per_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_on_per_unbound_II_per_ns(self)

    def get_average_fraction_bound_particles_I(self):
        r"""get_average_fraction_bound_particles_I(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_fraction_bound_particles_I(self)

    def get_average_fraction_bound_particles_II(self):
        r"""get_average_fraction_bound_particles_II(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_fraction_bound_particles_II(self)

    def get_average_fraction_bound_particle_sites_I(self):
        r"""get_average_fraction_bound_particle_sites_I(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_fraction_bound_particle_sites_I(self)

    def get_average_fraction_bound_particle_sites_II(self):
        r"""get_average_fraction_bound_particle_sites_II(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_fraction_bound_particle_sites_II(self)

    def get_average_fraction_nonspecific_interactions_I(self):
        r"""get_average_fraction_nonspecific_interactions_I(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_fraction_nonspecific_interactions_I(self)

    def get_average_fraction_nonspecific_interactions_II(self):
        r"""get_average_fraction_nonspecific_interactions_II(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_average_fraction_nonspecific_interactions_II(self)

    def get_number_of_particles_1(self):
        r"""get_number_of_particles_1(BipartitePairsStatisticsOptimizerState self) -> IMP::Int"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_number_of_particles_1(self)

    def get_number_of_particles_2(self):
        r"""get_number_of_particles_2(BipartitePairsStatisticsOptimizerState self) -> IMP::Int"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_number_of_particles_2(self)

    def get_misc_stats_period_ns(self):
        r"""get_misc_stats_period_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_misc_stats_period_ns(self)

    def get_off_stats_period_ns(self):
        r"""get_off_stats_period_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_off_stats_period_ns(self)

    def get_off_I_stats_period_ns(self):
        r"""get_off_I_stats_period_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_off_I_stats_period_ns(self)

    def get_off_II_stats_period_ns(self):
        r"""get_off_II_stats_period_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_off_II_stats_period_ns(self)

    def get_on_stats_period_ns(self):
        r"""get_on_stats_period_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_on_stats_period_ns(self)

    def get_on_I_stats_period_ns(self):
        r"""get_on_I_stats_period_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_on_I_stats_period_ns(self)

    def get_on_II_stats_period_ns(self):
        r"""get_on_II_stats_period_ns(BipartitePairsStatisticsOptimizerState self) -> double"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_on_II_stats_period_ns(self)

    def get_version_info(self):
        r"""get_version_info(BipartitePairsStatisticsOptimizerState self) -> VersionInfo"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_npctransport.delete_BipartitePairsStatisticsOptimizerState

    def __str__(self):
        r"""__str__(BipartitePairsStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState___str__(self)

    def __repr__(self):
        r"""__repr__(BipartitePairsStatisticsOptimizerState self) -> std::string"""
        return _IMP_npctransport.BipartitePairsStatisticsOptimizerState___repr__(self)

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


# Register BipartitePairsStatisticsOptimizerState in _IMP_npctransport:
_IMP_npctransport.BipartitePairsStatisticsOptimizerState_swigregister(BipartitePairsStatisticsOptimizerState)

def get_close_pairs_range(*args):
    r"""
    get_close_pairs_range(double max_range, double max_range_factor) -> double
    get_close_pairs_range(::npctransport_proto::Assignment const & config) -> double
    """
    return _IMP_npctransport.get_close_pairs_range(*args)

def get_time_step(*args):
    r"""
    get_time_step(double max_d_factor, double max_k, double min_radius, double min_range, double max_trans_relative_to_radius=0.1, double time_step_factor=1.0) -> double
    get_time_step(::npctransport_proto::Assignment const & config, double max_trans_relative_to_radius=0.1) -> double
    """
    return _IMP_npctransport.get_time_step(*args)

def get_frames_from_ns(ns, time_step):
    r"""get_frames_from_ns(double ns, double time_step) -> int"""
    return _IMP_npctransport.get_frames_from_ns(ns, time_step)

def get_number_of_frames(config, time_step):
    r"""get_number_of_frames(::npctransport_proto::Assignment const & config, double time_step) -> int"""
    return _IMP_npctransport.get_number_of_frames(config, time_step)

def get_dump_interval_in_frames(config, time_step):
    r"""get_dump_interval_in_frames(::npctransport_proto::Assignment const & config, double time_step) -> int"""
    return _IMP_npctransport.get_dump_interval_in_frames(config, time_step)

def get_statistics_interval_in_frames(assign, time_step, default_value_ns=0.1):
    r"""get_statistics_interval_in_frames(::npctransport_proto::Assignment const & assign, double time_step, double default_value_ns=0.1) -> int"""
    return _IMP_npctransport.get_statistics_interval_in_frames(assign, time_step, default_value_ns)

def get_output_statistics_interval_in_frames(assign, time_step, default_value_ns=1.0):
    r"""get_output_statistics_interval_in_frames(::npctransport_proto::Assignment const & assign, double time_step, double default_value_ns=1.0) -> int"""
    return _IMP_npctransport.get_output_statistics_interval_in_frames(assign, time_step, default_value_ns)

def initialize_positions(*args):
    r"""initialize_positions(SimulationData sd, IMP::RestraintsTemp const & extra_restraints=IMP::RestraintsTemp(), bool debug=False, double short_init_factor=1.0, bool is_disable_randomize=False, bool are_fgs_pre_initialized=False)"""
    return _IMP_npctransport.initialize_positions(*args)

def get_optimizable_particles(particles):
    r"""get_optimizable_particles(IMP::ParticlesTemp const & particles) -> IMP::ParticlesTemp"""
    return _IMP_npctransport.get_optimizable_particles(particles)

def get_non_optimizable_particles(particles):
    r"""get_non_optimizable_particles(IMP::ParticlesTemp const & particles) -> IMP::ParticlesTemp"""
    return _IMP_npctransport.get_non_optimizable_particles(particles)

def get_particle_indexes(particles):
    r"""get_particle_indexes(IMP::ParticlesTemp const & particles) -> IMP::ParticleIndexes"""
    return _IMP_npctransport.get_particle_indexes(particles)

def get_protobuf_configuration_from_text(config_txt, config_pb):
    r"""get_protobuf_configuration_from_text(std::string config_txt, std::string config_pb)"""
    return _IMP_npctransport.get_protobuf_configuration_from_text(config_txt, config_pb)

def get_spheres_from_vectors(vs, radius):
    r"""get_spheres_from_vectors(IMP::algebra::Vector3Ds const & vs, double radius) -> IMP::algebra::Sphere3Ds"""
    return _IMP_npctransport.get_spheres_from_vectors(vs, radius)

def get_spheres_centers(spheres):
    r"""get_spheres_centers(IMP::algebra::Sphere3Ds const & spheres) -> IMP::algebra::Vector3Ds"""
    return _IMP_npctransport.get_spheres_centers(spheres)

def copy_particle_reference_frame_if_applicable(src_p, trg_p):
    r"""copy_particle_reference_frame_if_applicable(Particle src_p, Particle trg_p)"""
    return _IMP_npctransport.copy_particle_reference_frame_if_applicable(src_p, trg_p)

def copy_hierarchy_reference_frame_recursive(src_p, trg_p):
    r"""copy_hierarchy_reference_frame_recursive(Particle src_p, Particle trg_p)"""
    return _IMP_npctransport.copy_hierarchy_reference_frame_recursive(src_p, trg_p)

def copy_FGs_coordinates(src_sd, trg_sd):
    r"""copy_FGs_coordinates(SimulationData src_sd, SimulationData trg_sd)"""
    return _IMP_npctransport.copy_FGs_coordinates(src_sd, trg_sd)
class Avro2PBReader(object):
    r"""Proxy of C++ IMP::npctransport::Avro2PBReader 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__(Avro2PBReader self, IMP::Strings const & avro_filenames) -> Avro2PBReader
        __init__(Avro2PBReader self, std::string avro_filename) -> Avro2PBReader
        """
        _IMP_npctransport.Avro2PBReader_swiginit(self, _IMP_npctransport.new_Avro2PBReader(*args))
    __swig_destroy__ = _IMP_npctransport.delete_Avro2PBReader

    def read_next(self):
        r"""read_next(Avro2PBReader self) -> IMP::npctransport::Avro2PBReader::ByteBuffer"""
        return _IMP_npctransport.Avro2PBReader_read_next(self)

    def get_is_valid(self):
        r"""get_is_valid(Avro2PBReader self) -> bool"""
        return _IMP_npctransport.Avro2PBReader_get_is_valid(self)

    def get_cur_file_name(self):
        r"""get_cur_file_name(Avro2PBReader self) -> std::string"""
        return _IMP_npctransport.Avro2PBReader_get_cur_file_name(self)

    def show(self, *args):
        r"""show(Avro2PBReader self, _ostream out=std::cout)"""
        return _IMP_npctransport.Avro2PBReader_show(self, *args)

    def __str__(self):
        r"""__str__(Avro2PBReader self) -> std::string"""
        return _IMP_npctransport.Avro2PBReader___str__(self)

    def __repr__(self):
        r"""__repr__(Avro2PBReader self) -> std::string"""
        return _IMP_npctransport.Avro2PBReader___repr__(self)

# Register Avro2PBReader in _IMP_npctransport:
_IMP_npctransport.Avro2PBReader_swigregister(Avro2PBReader)

def startup(argc):
    r"""startup(int argc) -> SimulationData"""
    return _IMP_npctransport.startup(argc)

def remove_Nup42(sd):
    r"""remove_Nup42(SimulationData sd)"""
    return _IMP_npctransport.remove_Nup42(sd)

def inflate_floater(sd, floater_name, new_radius):
    r"""inflate_floater(SimulationData sd, std::string const floater_name, float const new_radius)"""
    return _IMP_npctransport.inflate_floater(sd, floater_name, new_radius)

def reset_box_size(sd, box_size):
    r"""reset_box_size(SimulationData sd, double box_size)"""
    return _IMP_npctransport.reset_box_size(sd, box_size)

def do_main_loop(sd, init_restraints):
    r"""do_main_loop(SimulationData sd, IMP::RestraintsTemp const & init_restraints)"""
    return _IMP_npctransport.do_main_loop(sd, init_restraints)

try:
  from .npctransport_pb2 import *
  import google.protobuf
except ImportError:
  print("no protobuf support in python")
from ._configuration import *

timer = SimpleTimer


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

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

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

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

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