bff/__init__.py

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


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




from sys import version_info as _swig_python_version_info
import _IMP_bff

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


import weakref

class IMP_BFF_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_BFF_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_bff.delete_IMP_BFF_SwigPyIterator

    def value(self):
        r"""value(IMP_BFF_SwigPyIterator self) -> PyObject *"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(IMP_BFF_SwigPyIterator self, size_t n=1) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(IMP_BFF_SwigPyIterator self, size_t n=1) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(IMP_BFF_SwigPyIterator self, IMP_BFF_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(IMP_BFF_SwigPyIterator self, IMP_BFF_SwigPyIterator x) -> bool"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(IMP_BFF_SwigPyIterator self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_copy(self)

    def next(self):
        r"""next(IMP_BFF_SwigPyIterator self) -> PyObject *"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(IMP_BFF_SwigPyIterator self) -> PyObject *"""
        return _IMP_bff.IMP_BFF_SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(IMP_BFF_SwigPyIterator self) -> PyObject *"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(IMP_BFF_SwigPyIterator self, ptrdiff_t n) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.IMP_BFF_SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(IMP_BFF_SwigPyIterator self, IMP_BFF_SwigPyIterator x) -> bool"""
        return _IMP_bff.IMP_BFF_SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(IMP_BFF_SwigPyIterator self, IMP_BFF_SwigPyIterator x) -> bool"""
        return _IMP_bff.IMP_BFF_SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(IMP_BFF_SwigPyIterator self, ptrdiff_t n) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.IMP_BFF_SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(IMP_BFF_SwigPyIterator self, ptrdiff_t n) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.IMP_BFF_SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(IMP_BFF_SwigPyIterator self, ptrdiff_t n) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.IMP_BFF_SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(IMP_BFF_SwigPyIterator self, ptrdiff_t n) -> IMP_BFF_SwigPyIterator
        __sub__(IMP_BFF_SwigPyIterator self, IMP_BFF_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_bff.IMP_BFF_SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register IMP_BFF_SwigPyIterator in _IMP_bff:
_IMP_bff.IMP_BFF_SwigPyIterator_swigregister(IMP_BFF_SwigPyIterator)

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

IMP_DEBUG = _IMP_bff.IMP_DEBUG

IMP_RELEASE = _IMP_bff.IMP_RELEASE

IMP_SILENT = _IMP_bff.IMP_SILENT

IMP_PROGRESS = _IMP_bff.IMP_PROGRESS

IMP_TERSE = _IMP_bff.IMP_TERSE

IMP_VERBOSE = _IMP_bff.IMP_VERBOSE

IMP_MEMORY = _IMP_bff.IMP_MEMORY

IMP_NONE = _IMP_bff.IMP_NONE

IMP_USAGE = _IMP_bff.IMP_USAGE

IMP_INTERNAL = _IMP_bff.IMP_INTERNAL

IMP_KERNEL_HAS_LOG4CXX = _IMP_bff.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_bff.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_bff.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_bff.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_bff.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_bff.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_bff.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_bff.IMP_KERNEL_HAS_BOOST_SYSTEM

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_bff.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_bff.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_bff.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

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

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

import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_CGAL_HAS_BOOST_FILESYSTEM

IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

IMP_CGAL_HAS_BOOST_RANDOM = _IMP_bff.IMP_CGAL_HAS_BOOST_RANDOM

IMP_CGAL_HAS_NUMPY = _IMP_bff.IMP_CGAL_HAS_NUMPY

IMPCGAL_SHOW_WARNINGS = _IMP_bff.IMPCGAL_SHOW_WARNINGS

import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_bff.IMP_ALGEBRA_HAS_IMP_CGAL

IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_bff.IMP_ALGEBRA_HAS_BOOST_RANDOM

IMP_ALGEBRA_HAS_CGAL = _IMP_bff.IMP_ALGEBRA_HAS_CGAL

IMP_ALGEBRA_HAS_NUMPY = _IMP_bff.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_bff.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_bff.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_bff.IMP_DISPLAY_HAS_IMP_CGAL

IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_bff.IMP_DISPLAY_HAS_BOOST_RANDOM

IMP_DISPLAY_HAS_CGAL = _IMP_bff.IMP_DISPLAY_HAS_CGAL

IMP_DISPLAY_HAS_NUMPY = _IMP_bff.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_bff.IMPDISPLAY_SHOW_WARNINGS

import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_bff.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL

IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM

IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS

IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_bff.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM

IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_bff.IMP_SCORE_FUNCTOR_HAS_CGAL

IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_bff.IMP_SCORE_FUNCTOR_HAS_HDF5

IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_bff.IMP_SCORE_FUNCTOR_HAS_NUMPY

IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_bff.IMPSCOREFUNCTOR_SHOW_WARNINGS

import IMP.score_functor
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_bff.IMP_STATISTICS_HAS_IMP_CGAL

IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_STATISTICS_HAS_BOOST_FILESYSTEM

IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS

IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_bff.IMP_STATISTICS_HAS_BOOST_RANDOM

IMP_STATISTICS_HAS_CGAL = _IMP_bff.IMP_STATISTICS_HAS_CGAL

IMP_STATISTICS_HAS_NUMPY = _IMP_bff.IMP_STATISTICS_HAS_NUMPY

IMPSTATISTICS_SHOW_WARNINGS = _IMP_bff.IMPSTATISTICS_SHOW_WARNINGS

import IMP.statistics
IMP_CORE_HAS_IMP_CGAL = _IMP_bff.IMP_CORE_HAS_IMP_CGAL

IMP_CORE_HAS_IMP_KERNEL = _IMP_bff.IMP_CORE_HAS_IMP_KERNEL

IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_CORE_HAS_BOOST_FILESYSTEM

IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS

IMP_CORE_HAS_BOOST_RANDOM = _IMP_bff.IMP_CORE_HAS_BOOST_RANDOM

IMP_CORE_HAS_CGAL = _IMP_bff.IMP_CORE_HAS_CGAL

IMP_CORE_HAS_HDF5 = _IMP_bff.IMP_CORE_HAS_HDF5

IMP_CORE_HAS_NUMPY = _IMP_bff.IMP_CORE_HAS_NUMPY

IMPCORE_SHOW_WARNINGS = _IMP_bff.IMPCORE_SHOW_WARNINGS

import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_bff.IMP_CONTAINER_HAS_IMP_ALGEBRA

IMP_CONTAINER_HAS_IMP_CGAL = _IMP_bff.IMP_CONTAINER_HAS_IMP_CGAL

IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_bff.IMP_CONTAINER_HAS_IMP_DISPLAY

IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_bff.IMP_CONTAINER_HAS_IMP_KERNEL

IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_bff.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR

IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_CONTAINER_HAS_BOOST_FILESYSTEM

IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS

IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_bff.IMP_CONTAINER_HAS_BOOST_RANDOM

IMP_CONTAINER_HAS_CGAL = _IMP_bff.IMP_CONTAINER_HAS_CGAL

IMP_CONTAINER_HAS_HDF5 = _IMP_bff.IMP_CONTAINER_HAS_HDF5

IMP_CONTAINER_HAS_NUMPY = _IMP_bff.IMP_CONTAINER_HAS_NUMPY

IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_bff.IMP_CONTAINER_HAS_PYTHON_IHM

IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_bff.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP

IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_bff.IMP_CONTAINER_HAS_ROBIN_MAP

IMPCONTAINER_SHOW_WARNINGS = _IMP_bff.IMPCONTAINER_SHOW_WARNINGS

import IMP.container
IMP_ATOM_HAS_IMP_CGAL = _IMP_bff.IMP_ATOM_HAS_IMP_CGAL

IMP_ATOM_HAS_IMP_KERNEL = _IMP_bff.IMP_ATOM_HAS_IMP_KERNEL

IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_bff.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR

IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS

IMP_ATOM_HAS_BOOST_RANDOM = _IMP_bff.IMP_ATOM_HAS_BOOST_RANDOM

IMP_ATOM_HAS_BOOST_REGEX = _IMP_bff.IMP_ATOM_HAS_BOOST_REGEX

IMP_ATOM_HAS_CGAL = _IMP_bff.IMP_ATOM_HAS_CGAL

IMP_ATOM_HAS_HDF5 = _IMP_bff.IMP_ATOM_HAS_HDF5

IMP_ATOM_HAS_NUMPY = _IMP_bff.IMP_ATOM_HAS_NUMPY

IMP_ATOM_HAS_PYTHON_IHM = _IMP_bff.IMP_ATOM_HAS_PYTHON_IHM

IMPATOM_SHOW_WARNINGS = _IMP_bff.IMPATOM_SHOW_WARNINGS

IMP_ATOM_TYPE_INDEX = _IMP_bff.IMP_ATOM_TYPE_INDEX

IMP_RESIDUE_TYPE_INDEX = _IMP_bff.IMP_RESIDUE_TYPE_INDEX

IMP_HIERARCHY_TYPE_INDEX = _IMP_bff.IMP_HIERARCHY_TYPE_INDEX

IMP_CHAIN_TYPE_INDEX = _IMP_bff.IMP_CHAIN_TYPE_INDEX

import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_bff.IMP_EM_HAS_IMP_CGAL

IMP_EM_HAS_IMP_CONTAINER = _IMP_bff.IMP_EM_HAS_IMP_CONTAINER

IMP_EM_HAS_IMP_DISPLAY = _IMP_bff.IMP_EM_HAS_IMP_DISPLAY

IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_bff.IMP_EM_HAS_IMP_SCORE_FUNCTOR

IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_EM_HAS_BOOST_FILESYSTEM

IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_EM_HAS_BOOST_PROGRAMOPTIONS

IMP_EM_HAS_BOOST_RANDOM = _IMP_bff.IMP_EM_HAS_BOOST_RANDOM

IMP_EM_HAS_BOOST_REGEX = _IMP_bff.IMP_EM_HAS_BOOST_REGEX

IMP_EM_HAS_CGAL = _IMP_bff.IMP_EM_HAS_CGAL

IMP_EM_HAS_HDF5 = _IMP_bff.IMP_EM_HAS_HDF5

IMP_EM_HAS_NUMPY = _IMP_bff.IMP_EM_HAS_NUMPY

IMP_EM_HAS_PYTHON_IHM = _IMP_bff.IMP_EM_HAS_PYTHON_IHM

IMPEM_SHOW_WARNINGS = _IMP_bff.IMPEM_SHOW_WARNINGS

import IMP.em
IMP_BFF_HAS_IMP_ALGEBRA = _IMP_bff.IMP_BFF_HAS_IMP_ALGEBRA

IMP_BFF_HAS_IMP_CGAL = _IMP_bff.IMP_BFF_HAS_IMP_CGAL

IMP_BFF_HAS_IMP_DISPLAY = _IMP_bff.IMP_BFF_HAS_IMP_DISPLAY

IMP_BFF_HAS_IMP_KERNEL = _IMP_bff.IMP_BFF_HAS_IMP_KERNEL

IMP_BFF_HAS_IMP_SCORE_FUNCTOR = _IMP_bff.IMP_BFF_HAS_IMP_SCORE_FUNCTOR

IMP_BFF_HAS_IMP_STATISTICS = _IMP_bff.IMP_BFF_HAS_IMP_STATISTICS

IMP_BFF_HAS_BOOST_FILESYSTEM = _IMP_bff.IMP_BFF_HAS_BOOST_FILESYSTEM

IMP_BFF_HAS_BOOST_PROGRAMOPTIONS = _IMP_bff.IMP_BFF_HAS_BOOST_PROGRAMOPTIONS

IMP_BFF_HAS_BOOST_RANDOM = _IMP_bff.IMP_BFF_HAS_BOOST_RANDOM

IMP_BFF_HAS_BOOST_REGEX = _IMP_bff.IMP_BFF_HAS_BOOST_REGEX

IMP_BFF_HAS_CGAL = _IMP_bff.IMP_BFF_HAS_CGAL

IMP_BFF_HAS_HDF5 = _IMP_bff.IMP_BFF_HAS_HDF5

IMP_BFF_HAS_PYTHON_IHM = _IMP_bff.IMP_BFF_HAS_PYTHON_IHM

IMP_BFF_HAS_AVX = _IMP_bff.IMP_BFF_HAS_AVX

IMPBFF_SHOW_WARNINGS = _IMP_bff.IMPBFF_SHOW_WARNINGS


import numpy as np

SHARED_PTR_DISOWN = _IMP_bff.SHARED_PTR_DISOWN

class PairFloatFloat(object):
    r"""Proxy of C++ std::pair< float,float > 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__(PairFloatFloat self) -> PairFloatFloat
        __init__(PairFloatFloat self, float first, float second) -> PairFloatFloat
        __init__(PairFloatFloat self, PairFloatFloat other) -> PairFloatFloat
        """
        _IMP_bff.PairFloatFloat_swiginit(self, _IMP_bff.new_PairFloatFloat(*args))
    first = property(_IMP_bff.PairFloatFloat_first_get, _IMP_bff.PairFloatFloat_first_set, doc=r"""first : float""")
    second = property(_IMP_bff.PairFloatFloat_second_get, _IMP_bff.PairFloatFloat_second_set, doc=r"""second : float""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _IMP_bff.delete_PairFloatFloat

# Register PairFloatFloat in _IMP_bff:
_IMP_bff.PairFloatFloat_swigregister(PairFloatFloat)
class VectorString(object):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self):
        r"""iterator(VectorString self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.VectorString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorString self) -> bool"""
        return _IMP_bff.VectorString___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorString self) -> bool"""
        return _IMP_bff.VectorString___bool__(self)

    def __len__(self):
        r"""__len__(VectorString self) -> std::vector< std::string >::size_type"""
        return _IMP_bff.VectorString___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> VectorString"""
        return _IMP_bff.VectorString___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, VectorString v)
        """
        return _IMP_bff.VectorString___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _IMP_bff.VectorString___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorString self, std::vector< std::string >::difference_type i)
        __delitem__(VectorString self, SWIGPY_SLICEOBJECT * slice)
        """
        return _IMP_bff.VectorString___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorString self, SWIGPY_SLICEOBJECT * slice) -> VectorString
        __getitem__(VectorString self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _IMP_bff.VectorString___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorString self, SWIGPY_SLICEOBJECT * slice, VectorString v)
        __setitem__(VectorString self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorString self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _IMP_bff.VectorString___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorString self) -> std::vector< std::string >::value_type"""
        return _IMP_bff.VectorString_pop(self)

    def append(self, x):
        r"""append(VectorString self, std::vector< std::string >::value_type const & x)"""
        return _IMP_bff.VectorString_append(self, x)

    def empty(self):
        r"""empty(VectorString self) -> bool"""
        return _IMP_bff.VectorString_empty(self)

    def size(self):
        r"""size(VectorString self) -> std::vector< std::string >::size_type"""
        return _IMP_bff.VectorString_size(self)

    def swap(self, v):
        r"""swap(VectorString self, VectorString v)"""
        return _IMP_bff.VectorString_swap(self, v)

    def begin(self):
        r"""begin(VectorString self) -> std::vector< std::string >::iterator"""
        return _IMP_bff.VectorString_begin(self)

    def end(self):
        r"""end(VectorString self) -> std::vector< std::string >::iterator"""
        return _IMP_bff.VectorString_end(self)

    def rbegin(self):
        r"""rbegin(VectorString self) -> std::vector< std::string >::reverse_iterator"""
        return _IMP_bff.VectorString_rbegin(self)

    def rend(self):
        r"""rend(VectorString self) -> std::vector< std::string >::reverse_iterator"""
        return _IMP_bff.VectorString_rend(self)

    def clear(self):
        r"""clear(VectorString self)"""
        return _IMP_bff.VectorString_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorString self) -> std::vector< std::string >::allocator_type"""
        return _IMP_bff.VectorString_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorString self)"""
        return _IMP_bff.VectorString_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorString self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(VectorString self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _IMP_bff.VectorString_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorString self) -> VectorString
        __init__(VectorString self, VectorString other) -> VectorString
        __init__(VectorString self, std::vector< std::string >::size_type size) -> VectorString
        __init__(VectorString self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> VectorString
        """
        _IMP_bff.VectorString_swiginit(self, _IMP_bff.new_VectorString(*args))

    def push_back(self, x):
        r"""push_back(VectorString self, std::vector< std::string >::value_type const & x)"""
        return _IMP_bff.VectorString_push_back(self, x)

    def front(self):
        r"""front(VectorString self) -> std::vector< std::string >::value_type const &"""
        return _IMP_bff.VectorString_front(self)

    def back(self):
        r"""back(VectorString self) -> std::vector< std::string >::value_type const &"""
        return _IMP_bff.VectorString_back(self)

    def assign(self, n, x):
        r"""assign(VectorString self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _IMP_bff.VectorString_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorString self, std::vector< std::string >::size_type new_size)
        resize(VectorString self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _IMP_bff.VectorString_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorString self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(VectorString self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _IMP_bff.VectorString_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorString self, std::vector< std::string >::size_type n)"""
        return _IMP_bff.VectorString_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorString self) -> std::vector< std::string >::size_type"""
        return _IMP_bff.VectorString_capacity(self)
    __swig_destroy__ = _IMP_bff.delete_VectorString

# Register VectorString in _IMP_bff:
_IMP_bff.VectorString_swigregister(VectorString)
class VectorDouble(object):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(VectorDouble self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.VectorDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorDouble self) -> bool"""
        return _IMP_bff.VectorDouble___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorDouble self) -> bool"""
        return _IMP_bff.VectorDouble___bool__(self)

    def __len__(self):
        r"""__len__(VectorDouble self) -> std::vector< double >::size_type"""
        return _IMP_bff.VectorDouble___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> VectorDouble"""
        return _IMP_bff.VectorDouble___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, VectorDouble v)
        """
        return _IMP_bff.VectorDouble___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _IMP_bff.VectorDouble___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorDouble self, std::vector< double >::difference_type i)
        __delitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice)
        """
        return _IMP_bff.VectorDouble___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice) -> VectorDouble
        __getitem__(VectorDouble self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _IMP_bff.VectorDouble___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice, VectorDouble v)
        __setitem__(VectorDouble self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorDouble self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _IMP_bff.VectorDouble___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorDouble self) -> std::vector< double >::value_type"""
        return _IMP_bff.VectorDouble_pop(self)

    def append(self, x):
        r"""append(VectorDouble self, std::vector< double >::value_type const & x)"""
        return _IMP_bff.VectorDouble_append(self, x)

    def empty(self):
        r"""empty(VectorDouble self) -> bool"""
        return _IMP_bff.VectorDouble_empty(self)

    def size(self):
        r"""size(VectorDouble self) -> std::vector< double >::size_type"""
        return _IMP_bff.VectorDouble_size(self)

    def swap(self, v):
        r"""swap(VectorDouble self, VectorDouble v)"""
        return _IMP_bff.VectorDouble_swap(self, v)

    def begin(self):
        r"""begin(VectorDouble self) -> std::vector< double >::iterator"""
        return _IMP_bff.VectorDouble_begin(self)

    def end(self):
        r"""end(VectorDouble self) -> std::vector< double >::iterator"""
        return _IMP_bff.VectorDouble_end(self)

    def rbegin(self):
        r"""rbegin(VectorDouble self) -> std::vector< double >::reverse_iterator"""
        return _IMP_bff.VectorDouble_rbegin(self)

    def rend(self):
        r"""rend(VectorDouble self) -> std::vector< double >::reverse_iterator"""
        return _IMP_bff.VectorDouble_rend(self)

    def clear(self):
        r"""clear(VectorDouble self)"""
        return _IMP_bff.VectorDouble_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorDouble self) -> std::vector< double >::allocator_type"""
        return _IMP_bff.VectorDouble_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorDouble self)"""
        return _IMP_bff.VectorDouble_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorDouble self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(VectorDouble self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _IMP_bff.VectorDouble_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorDouble self) -> VectorDouble
        __init__(VectorDouble self, VectorDouble other) -> VectorDouble
        __init__(VectorDouble self, std::vector< double >::size_type size) -> VectorDouble
        __init__(VectorDouble self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> VectorDouble
        """
        _IMP_bff.VectorDouble_swiginit(self, _IMP_bff.new_VectorDouble(*args))

    def push_back(self, x):
        r"""push_back(VectorDouble self, std::vector< double >::value_type const & x)"""
        return _IMP_bff.VectorDouble_push_back(self, x)

    def front(self):
        r"""front(VectorDouble self) -> std::vector< double >::value_type const &"""
        return _IMP_bff.VectorDouble_front(self)

    def back(self):
        r"""back(VectorDouble self) -> std::vector< double >::value_type const &"""
        return _IMP_bff.VectorDouble_back(self)

    def assign(self, n, x):
        r"""assign(VectorDouble self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _IMP_bff.VectorDouble_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorDouble self, std::vector< double >::size_type new_size)
        resize(VectorDouble self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _IMP_bff.VectorDouble_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorDouble self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(VectorDouble self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _IMP_bff.VectorDouble_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorDouble self, std::vector< double >::size_type n)"""
        return _IMP_bff.VectorDouble_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorDouble self) -> std::vector< double >::size_type"""
        return _IMP_bff.VectorDouble_capacity(self)
    __swig_destroy__ = _IMP_bff.delete_VectorDouble

# Register VectorDouble in _IMP_bff:
_IMP_bff.VectorDouble_swigregister(VectorDouble)
class VectorFloat(object):
    r"""Proxy of C++ std::vector< float > class."""

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

    def iterator(self):
        r"""iterator(VectorFloat self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.VectorFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorFloat self) -> bool"""
        return _IMP_bff.VectorFloat___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorFloat self) -> bool"""
        return _IMP_bff.VectorFloat___bool__(self)

    def __len__(self):
        r"""__len__(VectorFloat self) -> std::vector< float >::size_type"""
        return _IMP_bff.VectorFloat___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> VectorFloat"""
        return _IMP_bff.VectorFloat___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)
        __setslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, VectorFloat v)
        """
        return _IMP_bff.VectorFloat___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _IMP_bff.VectorFloat___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorFloat self, std::vector< float >::difference_type i)
        __delitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice)
        """
        return _IMP_bff.VectorFloat___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice) -> VectorFloat
        __getitem__(VectorFloat self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _IMP_bff.VectorFloat___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice, VectorFloat v)
        __setitem__(VectorFloat self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorFloat self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _IMP_bff.VectorFloat___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorFloat self) -> std::vector< float >::value_type"""
        return _IMP_bff.VectorFloat_pop(self)

    def append(self, x):
        r"""append(VectorFloat self, std::vector< float >::value_type const & x)"""
        return _IMP_bff.VectorFloat_append(self, x)

    def empty(self):
        r"""empty(VectorFloat self) -> bool"""
        return _IMP_bff.VectorFloat_empty(self)

    def size(self):
        r"""size(VectorFloat self) -> std::vector< float >::size_type"""
        return _IMP_bff.VectorFloat_size(self)

    def swap(self, v):
        r"""swap(VectorFloat self, VectorFloat v)"""
        return _IMP_bff.VectorFloat_swap(self, v)

    def begin(self):
        r"""begin(VectorFloat self) -> std::vector< float >::iterator"""
        return _IMP_bff.VectorFloat_begin(self)

    def end(self):
        r"""end(VectorFloat self) -> std::vector< float >::iterator"""
        return _IMP_bff.VectorFloat_end(self)

    def rbegin(self):
        r"""rbegin(VectorFloat self) -> std::vector< float >::reverse_iterator"""
        return _IMP_bff.VectorFloat_rbegin(self)

    def rend(self):
        r"""rend(VectorFloat self) -> std::vector< float >::reverse_iterator"""
        return _IMP_bff.VectorFloat_rend(self)

    def clear(self):
        r"""clear(VectorFloat self)"""
        return _IMP_bff.VectorFloat_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorFloat self) -> std::vector< float >::allocator_type"""
        return _IMP_bff.VectorFloat_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorFloat self)"""
        return _IMP_bff.VectorFloat_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorFloat self, std::vector< float >::iterator pos) -> std::vector< float >::iterator
        erase(VectorFloat self, std::vector< float >::iterator first, std::vector< float >::iterator last) -> std::vector< float >::iterator
        """
        return _IMP_bff.VectorFloat_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorFloat self) -> VectorFloat
        __init__(VectorFloat self, VectorFloat other) -> VectorFloat
        __init__(VectorFloat self, std::vector< float >::size_type size) -> VectorFloat
        __init__(VectorFloat self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> VectorFloat
        """
        _IMP_bff.VectorFloat_swiginit(self, _IMP_bff.new_VectorFloat(*args))

    def push_back(self, x):
        r"""push_back(VectorFloat self, std::vector< float >::value_type const & x)"""
        return _IMP_bff.VectorFloat_push_back(self, x)

    def front(self):
        r"""front(VectorFloat self) -> std::vector< float >::value_type const &"""
        return _IMP_bff.VectorFloat_front(self)

    def back(self):
        r"""back(VectorFloat self) -> std::vector< float >::value_type const &"""
        return _IMP_bff.VectorFloat_back(self)

    def assign(self, n, x):
        r"""assign(VectorFloat self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _IMP_bff.VectorFloat_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorFloat self, std::vector< float >::size_type new_size)
        resize(VectorFloat self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _IMP_bff.VectorFloat_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorFloat self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(VectorFloat self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _IMP_bff.VectorFloat_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorFloat self, std::vector< float >::size_type n)"""
        return _IMP_bff.VectorFloat_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorFloat self) -> std::vector< float >::size_type"""
        return _IMP_bff.VectorFloat_capacity(self)
    __swig_destroy__ = _IMP_bff.delete_VectorFloat

# Register VectorFloat in _IMP_bff:
_IMP_bff.VectorFloat_swigregister(VectorFloat)
class VectorInt(object):
    r"""Proxy of C++ std::vector< int > class."""

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

    def iterator(self):
        r"""iterator(VectorInt self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.VectorInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorInt self) -> bool"""
        return _IMP_bff.VectorInt___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorInt self) -> bool"""
        return _IMP_bff.VectorInt___bool__(self)

    def __len__(self):
        r"""__len__(VectorInt self) -> std::vector< int >::size_type"""
        return _IMP_bff.VectorInt___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorInt self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> VectorInt"""
        return _IMP_bff.VectorInt___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorInt self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(VectorInt self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, VectorInt v)
        """
        return _IMP_bff.VectorInt___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorInt self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _IMP_bff.VectorInt___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorInt self, std::vector< int >::difference_type i)
        __delitem__(VectorInt self, SWIGPY_SLICEOBJECT * slice)
        """
        return _IMP_bff.VectorInt___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorInt self, SWIGPY_SLICEOBJECT * slice) -> VectorInt
        __getitem__(VectorInt self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _IMP_bff.VectorInt___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorInt self, SWIGPY_SLICEOBJECT * slice, VectorInt v)
        __setitem__(VectorInt self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorInt self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _IMP_bff.VectorInt___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorInt self) -> std::vector< int >::value_type"""
        return _IMP_bff.VectorInt_pop(self)

    def append(self, x):
        r"""append(VectorInt self, std::vector< int >::value_type const & x)"""
        return _IMP_bff.VectorInt_append(self, x)

    def empty(self):
        r"""empty(VectorInt self) -> bool"""
        return _IMP_bff.VectorInt_empty(self)

    def size(self):
        r"""size(VectorInt self) -> std::vector< int >::size_type"""
        return _IMP_bff.VectorInt_size(self)

    def swap(self, v):
        r"""swap(VectorInt self, VectorInt v)"""
        return _IMP_bff.VectorInt_swap(self, v)

    def begin(self):
        r"""begin(VectorInt self) -> std::vector< int >::iterator"""
        return _IMP_bff.VectorInt_begin(self)

    def end(self):
        r"""end(VectorInt self) -> std::vector< int >::iterator"""
        return _IMP_bff.VectorInt_end(self)

    def rbegin(self):
        r"""rbegin(VectorInt self) -> std::vector< int >::reverse_iterator"""
        return _IMP_bff.VectorInt_rbegin(self)

    def rend(self):
        r"""rend(VectorInt self) -> std::vector< int >::reverse_iterator"""
        return _IMP_bff.VectorInt_rend(self)

    def clear(self):
        r"""clear(VectorInt self)"""
        return _IMP_bff.VectorInt_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorInt self) -> std::vector< int >::allocator_type"""
        return _IMP_bff.VectorInt_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorInt self)"""
        return _IMP_bff.VectorInt_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorInt self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(VectorInt self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _IMP_bff.VectorInt_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorInt self) -> VectorInt
        __init__(VectorInt self, VectorInt other) -> VectorInt
        __init__(VectorInt self, std::vector< int >::size_type size) -> VectorInt
        __init__(VectorInt self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> VectorInt
        """
        _IMP_bff.VectorInt_swiginit(self, _IMP_bff.new_VectorInt(*args))

    def push_back(self, x):
        r"""push_back(VectorInt self, std::vector< int >::value_type const & x)"""
        return _IMP_bff.VectorInt_push_back(self, x)

    def front(self):
        r"""front(VectorInt self) -> std::vector< int >::value_type const &"""
        return _IMP_bff.VectorInt_front(self)

    def back(self):
        r"""back(VectorInt self) -> std::vector< int >::value_type const &"""
        return _IMP_bff.VectorInt_back(self)

    def assign(self, n, x):
        r"""assign(VectorInt self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _IMP_bff.VectorInt_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorInt self, std::vector< int >::size_type new_size)
        resize(VectorInt self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _IMP_bff.VectorInt_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorInt self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(VectorInt self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _IMP_bff.VectorInt_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorInt self, std::vector< int >::size_type n)"""
        return _IMP_bff.VectorInt_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorInt self) -> std::vector< int >::size_type"""
        return _IMP_bff.VectorInt_capacity(self)
    __swig_destroy__ = _IMP_bff.delete_VectorInt

# Register VectorInt in _IMP_bff:
_IMP_bff.VectorInt_swigregister(VectorInt)
class VectorLong(object):
    r"""Proxy of C++ std::vector< long > class."""

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

    def iterator(self):
        r"""iterator(VectorLong self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.VectorLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorLong self) -> bool"""
        return _IMP_bff.VectorLong___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorLong self) -> bool"""
        return _IMP_bff.VectorLong___bool__(self)

    def __len__(self):
        r"""__len__(VectorLong self) -> std::vector< long >::size_type"""
        return _IMP_bff.VectorLong___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorLong self, std::vector< long >::difference_type i, std::vector< long >::difference_type j) -> VectorLong"""
        return _IMP_bff.VectorLong___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorLong self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)
        __setslice__(VectorLong self, std::vector< long >::difference_type i, std::vector< long >::difference_type j, VectorLong v)
        """
        return _IMP_bff.VectorLong___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorLong self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)"""
        return _IMP_bff.VectorLong___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorLong self, std::vector< long >::difference_type i)
        __delitem__(VectorLong self, SWIGPY_SLICEOBJECT * slice)
        """
        return _IMP_bff.VectorLong___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorLong self, SWIGPY_SLICEOBJECT * slice) -> VectorLong
        __getitem__(VectorLong self, std::vector< long >::difference_type i) -> std::vector< long >::value_type const &
        """
        return _IMP_bff.VectorLong___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorLong self, SWIGPY_SLICEOBJECT * slice, VectorLong v)
        __setitem__(VectorLong self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorLong self, std::vector< long >::difference_type i, std::vector< long >::value_type const & x)
        """
        return _IMP_bff.VectorLong___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorLong self) -> std::vector< long >::value_type"""
        return _IMP_bff.VectorLong_pop(self)

    def append(self, x):
        r"""append(VectorLong self, std::vector< long >::value_type const & x)"""
        return _IMP_bff.VectorLong_append(self, x)

    def empty(self):
        r"""empty(VectorLong self) -> bool"""
        return _IMP_bff.VectorLong_empty(self)

    def size(self):
        r"""size(VectorLong self) -> std::vector< long >::size_type"""
        return _IMP_bff.VectorLong_size(self)

    def swap(self, v):
        r"""swap(VectorLong self, VectorLong v)"""
        return _IMP_bff.VectorLong_swap(self, v)

    def begin(self):
        r"""begin(VectorLong self) -> std::vector< long >::iterator"""
        return _IMP_bff.VectorLong_begin(self)

    def end(self):
        r"""end(VectorLong self) -> std::vector< long >::iterator"""
        return _IMP_bff.VectorLong_end(self)

    def rbegin(self):
        r"""rbegin(VectorLong self) -> std::vector< long >::reverse_iterator"""
        return _IMP_bff.VectorLong_rbegin(self)

    def rend(self):
        r"""rend(VectorLong self) -> std::vector< long >::reverse_iterator"""
        return _IMP_bff.VectorLong_rend(self)

    def clear(self):
        r"""clear(VectorLong self)"""
        return _IMP_bff.VectorLong_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorLong self) -> std::vector< long >::allocator_type"""
        return _IMP_bff.VectorLong_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorLong self)"""
        return _IMP_bff.VectorLong_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorLong self, std::vector< long >::iterator pos) -> std::vector< long >::iterator
        erase(VectorLong self, std::vector< long >::iterator first, std::vector< long >::iterator last) -> std::vector< long >::iterator
        """
        return _IMP_bff.VectorLong_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorLong self) -> VectorLong
        __init__(VectorLong self, VectorLong other) -> VectorLong
        __init__(VectorLong self, std::vector< long >::size_type size) -> VectorLong
        __init__(VectorLong self, std::vector< long >::size_type size, std::vector< long >::value_type const & value) -> VectorLong
        """
        _IMP_bff.VectorLong_swiginit(self, _IMP_bff.new_VectorLong(*args))

    def push_back(self, x):
        r"""push_back(VectorLong self, std::vector< long >::value_type const & x)"""
        return _IMP_bff.VectorLong_push_back(self, x)

    def front(self):
        r"""front(VectorLong self) -> std::vector< long >::value_type const &"""
        return _IMP_bff.VectorLong_front(self)

    def back(self):
        r"""back(VectorLong self) -> std::vector< long >::value_type const &"""
        return _IMP_bff.VectorLong_back(self)

    def assign(self, n, x):
        r"""assign(VectorLong self, std::vector< long >::size_type n, std::vector< long >::value_type const & x)"""
        return _IMP_bff.VectorLong_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorLong self, std::vector< long >::size_type new_size)
        resize(VectorLong self, std::vector< long >::size_type new_size, std::vector< long >::value_type const & x)
        """
        return _IMP_bff.VectorLong_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorLong self, std::vector< long >::iterator pos, std::vector< long >::value_type const & x) -> std::vector< long >::iterator
        insert(VectorLong self, std::vector< long >::iterator pos, std::vector< long >::size_type n, std::vector< long >::value_type const & x)
        """
        return _IMP_bff.VectorLong_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorLong self, std::vector< long >::size_type n)"""
        return _IMP_bff.VectorLong_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorLong self) -> std::vector< long >::size_type"""
        return _IMP_bff.VectorLong_capacity(self)
    __swig_destroy__ = _IMP_bff.delete_VectorLong

# Register VectorLong in _IMP_bff:
_IMP_bff.VectorLong_swigregister(VectorLong)

PathMapTileEdges=list
_plural_types.append("PathMapTileEdges")
_value_types.append("PathMapTileEdge")


_object_types.append("PathMap")


def _object_cast_to_PathMap(o):
    r"""_object_cast_to_PathMap(Object o) -> PathMap"""
    return _IMP_bff._object_cast_to_PathMap(o)
class PathMapHeader(object):
    r"""Proxy of C++ IMP::bff::PathMapHeader class."""

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

    def __init__(self, *args, **kwargs):
        r"""__init__(PathMapHeader self, double max_path_length=10.0, double grid_spacing=1.0, double neighbor_radius=2, double obstacle_threshold=std::numeric_limits< double >::epsilon()) -> PathMapHeader"""
        _IMP_bff.PathMapHeader_swiginit(self, _IMP_bff.new_PathMapHeader(*args, **kwargs))

    def update_map_dimensions(self, nx=-1, ny=-1, nz=-1):
        r"""update_map_dimensions(PathMapHeader self, int nx=-1, int ny=-1, int nz=-1)"""
        return _IMP_bff.PathMapHeader_update_map_dimensions(self, nx, ny, nz)

    def set_path_origin(self, v):
        r"""set_path_origin(PathMapHeader self, Vector3D v)"""
        return _IMP_bff.PathMapHeader_set_path_origin(self, v)

    def get_path_origin(self):
        r"""get_path_origin(PathMapHeader self) -> Vector3D"""
        return _IMP_bff.PathMapHeader_get_path_origin(self)

    def get_max_path_length(self):
        r"""get_max_path_length(PathMapHeader self) -> double"""
        return _IMP_bff.PathMapHeader_get_max_path_length(self)

    def get_simulation_grid_resolution(self):
        r"""get_simulation_grid_resolution(PathMapHeader self) -> double"""
        return _IMP_bff.PathMapHeader_get_simulation_grid_resolution(self)

    def set_obstacle_threshold(self, obstacle_threshold):
        r"""set_obstacle_threshold(PathMapHeader self, double obstacle_threshold)"""
        return _IMP_bff.PathMapHeader_set_obstacle_threshold(self, obstacle_threshold)

    def get_obstacle_threshold(self):
        r"""get_obstacle_threshold(PathMapHeader self) -> double"""
        return _IMP_bff.PathMapHeader_get_obstacle_threshold(self)

    def set_neighbor_radius(self, neighbor_radius):
        r"""set_neighbor_radius(PathMapHeader self, double neighbor_radius)"""
        return _IMP_bff.PathMapHeader_set_neighbor_radius(self, neighbor_radius)

    def get_neighbor_radius(self):
        r"""get_neighbor_radius(PathMapHeader self) -> double"""
        return _IMP_bff.PathMapHeader_get_neighbor_radius(self)

    def get_neighbor_box_size(self):
        r"""get_neighbor_box_size(PathMapHeader self) -> int"""
        return _IMP_bff.PathMapHeader_get_neighbor_box_size(self)

    def get_density_header(self):
        r"""get_density_header(PathMapHeader self) -> DensityHeader"""
        return _IMP_bff.PathMapHeader_get_density_header(self)

    def get_density_header_writable(self):
        r"""get_density_header_writable(PathMapHeader self) -> DensityHeader"""
        return _IMP_bff.PathMapHeader_get_density_header_writable(self)

    def get_origin(self):
        r"""get_origin(PathMapHeader self) -> Vector3D"""
        return _IMP_bff.PathMapHeader_get_origin(self)

    def get_grid_edge_length(self):
        r"""get_grid_edge_length(PathMapHeader self) -> double"""
        return _IMP_bff.PathMapHeader_get_grid_edge_length(self)

    def set_origin(self, x, y, z):
        r"""set_origin(PathMapHeader self, float x, float y, float z)"""
        return _IMP_bff.PathMapHeader_set_origin(self, x, y, z)

    def show(self, *args, **kwargs):
        r"""show(PathMapHeader self, _ostream out=std::cout)"""
        return _IMP_bff.PathMapHeader_show(self, *args, **kwargs)

# Register PathMapHeader in _IMP_bff:
_IMP_bff.PathMapHeader_swigregister(PathMapHeader)
class PathMap(IMP.em.SampledDensityMap):
    r"""Proxy of C++ IMP::bff::PathMap class."""

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

    def update_tiles(self, *args, **kwargs):
        r"""update_tiles(PathMap self, float obstacle_threshold=-1.0, bool binarize=True, float obstacle_penalty=TILE_PENALTY_DEFAULT, bool reset_tile_edges=True)"""
        return _IMP_bff.PathMap_update_tiles(self, *args, **kwargs)

    def resize(self, nvox):
        r"""resize(PathMap self, unsigned int nvox)"""
        return _IMP_bff.PathMap_resize(self, nvox)

    def set_data(self, *args, **kwargs):
        r"""set_data(PathMap self, double * input, float obstacle_threshold=-1, bool binarize=True, float obstacle_penalty=TILE_PENALTY_DEFAULT)"""
        return _IMP_bff.PathMap_set_data(self, *args, **kwargs)

    def get_neighbor_idx_offsets(self, neighbor_radius=-1):
        r"""get_neighbor_idx_offsets(PathMap self, double neighbor_radius=-1) -> VectorInt"""
        return _IMP_bff.PathMap_get_neighbor_idx_offsets(self, neighbor_radius)

    def get_dim_index_by_voxel(self, index, dim):
        r"""get_dim_index_by_voxel(PathMap self, long index, int dim) -> int"""
        return _IMP_bff.PathMap_get_dim_index_by_voxel(self, index, dim)

    def get_path_map_header(self):
        h = _IMP_bff.DensityMap_get_path_map_header(self)
        h._owner = self
        return h



    def get_path_map_header_writable(self):
        h = _IMP_bff.PathMap_get_path_map_header_writable(self)
        h._owner = self
        return h



    def set_path_map_header(self, path_map_header, resolution=-1.0):
        r"""set_path_map_header(PathMap self, PathMapHeader path_map_header, float resolution=-1.0)"""
        return _IMP_bff.PathMap_set_path_map_header(self, path_map_header, resolution)

    def get_tile_values(self, *args, **kwargs):
        r"""get_tile_values(PathMap self, int value_type=PM_TILE_COST, PairFloatFloat bounds=std::pair< float,float >(                     {std::numeric_limits<float>::min(),                      std::numeric_limits<float>::max()}), std::string const & feature_name="")"""
        return _IMP_bff.PathMap_get_tile_values(self, *args, **kwargs)

    def get_tiles(self):
        r"""get_tiles(PathMap self) -> VectorPathMapTile"""
        return _IMP_bff.PathMap_get_tiles(self)

    def fill_sphere(self, r0, radius, value, inverse=True):
        r"""fill_sphere(PathMap self, Vector3D r0, double radius, double value, bool inverse=True)"""
        return _IMP_bff.PathMap_fill_sphere(self, r0, radius, value, inverse)

    def find_path(self, path_begin_idx, path_end_idx=-1, heuristic_mode=0):
        r"""find_path(PathMap self, long path_begin_idx, long path_end_idx=-1, int heuristic_mode=0)"""
        return _IMP_bff.PathMap_find_path(self, path_begin_idx, path_end_idx, heuristic_mode)

    def find_path_dijkstra(self, path_begin_idx, path_end_idx=-1):
        r"""find_path_dijkstra(PathMap self, long path_begin_idx, long path_end_idx=-1)"""
        return _IMP_bff.PathMap_find_path_dijkstra(self, path_begin_idx, path_end_idx)

    def find_path_astar(self, path_begin_idx, path_end_idx=-1):
        r"""find_path_astar(PathMap self, long path_begin_idx, long path_end_idx=-1)"""
        return _IMP_bff.PathMap_find_path_astar(self, path_begin_idx, path_end_idx)

    def get_xyz_density(self):
        r"""get_xyz_density(PathMap self)"""
        return _IMP_bff.PathMap_get_xyz_density(self)

    def sample_obstacles(self, extra_radius=0.0):
        r"""sample_obstacles(PathMap self, double extra_radius=0.0)"""
        return _IMP_bff.PathMap_sample_obstacles(self, extra_radius)

    def __init__(self, *args, **kwargs):
        r"""__init__(PathMap self, PathMapHeader header, std::string name="PathMap%1%", IMP::em::KernelType kt=BINARIZED_SPHERE, float resolution=-1.0) -> PathMap"""
        _IMP_bff.PathMap_swiginit(self, _IMP_bff.new_PathMap(*args, **kwargs))

    def __str__(self):
        r"""__str__(PathMap self) -> std::string"""
        return _IMP_bff.PathMap___str__(self)

    def __repr__(self):
        r"""__repr__(PathMap self) -> std::string"""
        return _IMP_bff.PathMap___repr__(self)

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

    __swig_destroy__ = _IMP_bff.delete_PathMap

# Register PathMap in _IMP_bff:
_IMP_bff.PathMap_swigregister(PathMap)

def write_path_map(*args, **kwargs):
    r"""write_path_map(PathMap m, std::string filename, int value_type, PairFloatFloat bounds=std::pair< float,float >(                 std::numeric_limits<float>::min(),                 std::numeric_limits<float>::max()         ), std::string const & feature_name="")"""
    return _IMP_bff.write_path_map(*args, **kwargs)
PM_TILE_PENALTY = _IMP_bff.PM_TILE_PENALTY

PM_TILE_COST = _IMP_bff.PM_TILE_COST

PM_TILE_DENSITY = _IMP_bff.PM_TILE_DENSITY

PM_TILE_COST_DENSITY = _IMP_bff.PM_TILE_COST_DENSITY

PM_TILE_PATH_LENGTH = _IMP_bff.PM_TILE_PATH_LENGTH

PM_TILE_PATH_LENGTH_DENSITY = _IMP_bff.PM_TILE_PATH_LENGTH_DENSITY

PM_TILE_FEATURE = _IMP_bff.PM_TILE_FEATURE

PM_TILE_ACCESSIBLE_DENSITY = _IMP_bff.PM_TILE_ACCESSIBLE_DENSITY

PM_TILE_ACCESSIBLE_FEATURE = _IMP_bff.PM_TILE_ACCESSIBLE_FEATURE

class PathMapTile(object):
    r"""Proxy of C++ IMP::bff::PathMapTile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    density = property(_IMP_bff.PathMapTile_density_get, _IMP_bff.PathMapTile_density_set, doc=r"""density : float""")

    def __init__(self, index=-1, visit_penalty=0.0, tile_density=1.0):
        r"""__init__(PathMapTile self, long index=-1, float visit_penalty=0.0, float tile_density=1.0) -> PathMapTile"""
        _IMP_bff.PathMapTile_swiginit(self, _IMP_bff.new_PathMapTile(index, visit_penalty, tile_density))

    def backtrack_to_path(self):
        r"""backtrack_to_path(PathMapTile self) -> VectorLong"""
        return _IMP_bff.PathMapTile_backtrack_to_path(self)

    def get_value(self, *args, **kwargs):
        r"""get_value(PathMapTile self, int value_type, PairFloatFloat bounds=std::pair< float,float >(                             {std::numeric_limits<float>::min(),                              std::numeric_limits<float>::max()}), std::string const & feature_name="", float grid_spacing=1.0) -> float"""
        return _IMP_bff.PathMapTile_get_value(self, *args, **kwargs)

    def set_value(self, *args, **kwargs):
        r"""set_value(PathMapTile self, int value_type, float value, std::string const & name="")"""
        return _IMP_bff.PathMapTile_set_value(self, *args, **kwargs)
    __swig_destroy__ = _IMP_bff.delete_PathMapTile

# Register PathMapTile in _IMP_bff:
_IMP_bff.PathMapTile_swigregister(PathMapTile)
cvar = _IMP_bff.cvar
TILE_VISITED_DEFAULT = cvar.TILE_VISITED_DEFAULT
TILE_PENALTY_DEFAULT = cvar.TILE_PENALTY_DEFAULT
TILE_COST_DEFAULT = cvar.TILE_COST_DEFAULT
TILE_EDGE_COST_DEFAULT = cvar.TILE_EDGE_COST_DEFAULT
TILE_PENALTY_THRESHOLD = cvar.TILE_PENALTY_THRESHOLD
TILE_OBSTACLE_THRESHOLD = cvar.TILE_OBSTACLE_THRESHOLD
TILE_OBSTACLE_PENALTY = cvar.TILE_OBSTACLE_PENALTY

class PathMapTileEdge(IMP._Value):
    r"""Proxy of C++ IMP::bff::PathMapTileEdge class."""

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

    def get_length(self):
        r"""get_length(PathMapTileEdge self) -> float"""
        return _IMP_bff.PathMapTileEdge_get_length(self)

    def __init__(self, *args, **kwargs):
        r"""__init__(PathMapTileEdge self, int edge_target=-1, float edge_cost=std::numeric_limits< float >::max()) -> PathMapTileEdge"""
        _IMP_bff.PathMapTileEdge_swiginit(self, _IMP_bff.new_PathMapTileEdge(*args, **kwargs))

    def show(self, *args, **kwargs):
        r"""show(PathMapTileEdge self, _ostream out=std::cout)"""
        return _IMP_bff.PathMapTileEdge_show(self, *args, **kwargs)

    def __str__(self):
        r"""__str__(PathMapTileEdge self) -> std::string"""
        return _IMP_bff.PathMapTileEdge___str__(self)

    def __repr__(self):
        r"""__repr__(PathMapTileEdge self) -> std::string"""
        return _IMP_bff.PathMapTileEdge___repr__(self)
    __swig_destroy__ = _IMP_bff.delete_PathMapTileEdge

# Register PathMapTileEdge in _IMP_bff:
_IMP_bff.PathMapTileEdge_swigregister(PathMapTileEdge)
class VectorPathMapTile(object):
    r"""Proxy of C++ std::vector< IMP::bff::PathMapTile > class."""

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

    def iterator(self):
        r"""iterator(VectorPathMapTile self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.VectorPathMapTile_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorPathMapTile self) -> bool"""
        return _IMP_bff.VectorPathMapTile___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorPathMapTile self) -> bool"""
        return _IMP_bff.VectorPathMapTile___bool__(self)

    def __len__(self):
        r"""__len__(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::size_type"""
        return _IMP_bff.VectorPathMapTile___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::difference_type i, std::vector< IMP::bff::PathMapTile >::difference_type j) -> VectorPathMapTile"""
        return _IMP_bff.VectorPathMapTile___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::difference_type i, std::vector< IMP::bff::PathMapTile >::difference_type j)
        __setslice__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::difference_type i, std::vector< IMP::bff::PathMapTile >::difference_type j, VectorPathMapTile v)
        """
        return _IMP_bff.VectorPathMapTile___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::difference_type i, std::vector< IMP::bff::PathMapTile >::difference_type j)"""
        return _IMP_bff.VectorPathMapTile___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::difference_type i)
        __delitem__(VectorPathMapTile self, SWIGPY_SLICEOBJECT * slice)
        """
        return _IMP_bff.VectorPathMapTile___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorPathMapTile self, SWIGPY_SLICEOBJECT * slice) -> VectorPathMapTile
        __getitem__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::difference_type i) -> PathMapTile
        """
        return _IMP_bff.VectorPathMapTile___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorPathMapTile self, SWIGPY_SLICEOBJECT * slice, VectorPathMapTile v)
        __setitem__(VectorPathMapTile self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::difference_type i, PathMapTile x)
        """
        return _IMP_bff.VectorPathMapTile___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorPathMapTile self) -> PathMapTile"""
        return _IMP_bff.VectorPathMapTile_pop(self)

    def append(self, x):
        r"""append(VectorPathMapTile self, PathMapTile x)"""
        return _IMP_bff.VectorPathMapTile_append(self, x)

    def empty(self):
        r"""empty(VectorPathMapTile self) -> bool"""
        return _IMP_bff.VectorPathMapTile_empty(self)

    def size(self):
        r"""size(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::size_type"""
        return _IMP_bff.VectorPathMapTile_size(self)

    def swap(self, v):
        r"""swap(VectorPathMapTile self, VectorPathMapTile v)"""
        return _IMP_bff.VectorPathMapTile_swap(self, v)

    def begin(self):
        r"""begin(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::iterator"""
        return _IMP_bff.VectorPathMapTile_begin(self)

    def end(self):
        r"""end(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::iterator"""
        return _IMP_bff.VectorPathMapTile_end(self)

    def rbegin(self):
        r"""rbegin(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::reverse_iterator"""
        return _IMP_bff.VectorPathMapTile_rbegin(self)

    def rend(self):
        r"""rend(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::reverse_iterator"""
        return _IMP_bff.VectorPathMapTile_rend(self)

    def clear(self):
        r"""clear(VectorPathMapTile self)"""
        return _IMP_bff.VectorPathMapTile_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::allocator_type"""
        return _IMP_bff.VectorPathMapTile_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorPathMapTile self)"""
        return _IMP_bff.VectorPathMapTile_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::iterator pos) -> std::vector< IMP::bff::PathMapTile >::iterator
        erase(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::iterator first, std::vector< IMP::bff::PathMapTile >::iterator last) -> std::vector< IMP::bff::PathMapTile >::iterator
        """
        return _IMP_bff.VectorPathMapTile_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorPathMapTile self) -> VectorPathMapTile
        __init__(VectorPathMapTile self, VectorPathMapTile other) -> VectorPathMapTile
        __init__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::size_type size) -> VectorPathMapTile
        __init__(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::size_type size, PathMapTile value) -> VectorPathMapTile
        """
        _IMP_bff.VectorPathMapTile_swiginit(self, _IMP_bff.new_VectorPathMapTile(*args))

    def push_back(self, x):
        r"""push_back(VectorPathMapTile self, PathMapTile x)"""
        return _IMP_bff.VectorPathMapTile_push_back(self, x)

    def front(self):
        r"""front(VectorPathMapTile self) -> PathMapTile"""
        return _IMP_bff.VectorPathMapTile_front(self)

    def back(self):
        r"""back(VectorPathMapTile self) -> PathMapTile"""
        return _IMP_bff.VectorPathMapTile_back(self)

    def assign(self, n, x):
        r"""assign(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::size_type n, PathMapTile x)"""
        return _IMP_bff.VectorPathMapTile_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::size_type new_size)
        resize(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::size_type new_size, PathMapTile x)
        """
        return _IMP_bff.VectorPathMapTile_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::iterator pos, PathMapTile x) -> std::vector< IMP::bff::PathMapTile >::iterator
        insert(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::iterator pos, std::vector< IMP::bff::PathMapTile >::size_type n, PathMapTile x)
        """
        return _IMP_bff.VectorPathMapTile_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorPathMapTile self, std::vector< IMP::bff::PathMapTile >::size_type n)"""
        return _IMP_bff.VectorPathMapTile_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorPathMapTile self) -> std::vector< IMP::bff::PathMapTile >::size_type"""
        return _IMP_bff.VectorPathMapTile_capacity(self)
    __swig_destroy__ = _IMP_bff.delete_VectorPathMapTile

# Register VectorPathMapTile in _IMP_bff:
_IMP_bff.VectorPathMapTile_swigregister(VectorPathMapTile)
class VectorPathMapTileEdge(object):
    r"""Proxy of C++ std::vector< IMP::bff::PathMapTileEdge > class."""

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

    def iterator(self):
        r"""iterator(VectorPathMapTileEdge self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.VectorPathMapTileEdge_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorPathMapTileEdge self) -> bool"""
        return _IMP_bff.VectorPathMapTileEdge___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorPathMapTileEdge self) -> bool"""
        return _IMP_bff.VectorPathMapTileEdge___bool__(self)

    def __len__(self):
        r"""__len__(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::size_type"""
        return _IMP_bff.VectorPathMapTileEdge___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::difference_type i, std::vector< IMP::bff::PathMapTileEdge >::difference_type j) -> VectorPathMapTileEdge"""
        return _IMP_bff.VectorPathMapTileEdge___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::difference_type i, std::vector< IMP::bff::PathMapTileEdge >::difference_type j)
        __setslice__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::difference_type i, std::vector< IMP::bff::PathMapTileEdge >::difference_type j, VectorPathMapTileEdge v)
        """
        return _IMP_bff.VectorPathMapTileEdge___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::difference_type i, std::vector< IMP::bff::PathMapTileEdge >::difference_type j)"""
        return _IMP_bff.VectorPathMapTileEdge___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::difference_type i)
        __delitem__(VectorPathMapTileEdge self, SWIGPY_SLICEOBJECT * slice)
        """
        return _IMP_bff.VectorPathMapTileEdge___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorPathMapTileEdge self, SWIGPY_SLICEOBJECT * slice) -> VectorPathMapTileEdge
        __getitem__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::difference_type i) -> PathMapTileEdge
        """
        return _IMP_bff.VectorPathMapTileEdge___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorPathMapTileEdge self, SWIGPY_SLICEOBJECT * slice, VectorPathMapTileEdge v)
        __setitem__(VectorPathMapTileEdge self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::difference_type i, PathMapTileEdge x)
        """
        return _IMP_bff.VectorPathMapTileEdge___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorPathMapTileEdge self) -> PathMapTileEdge"""
        return _IMP_bff.VectorPathMapTileEdge_pop(self)

    def append(self, x):
        r"""append(VectorPathMapTileEdge self, PathMapTileEdge x)"""
        return _IMP_bff.VectorPathMapTileEdge_append(self, x)

    def empty(self):
        r"""empty(VectorPathMapTileEdge self) -> bool"""
        return _IMP_bff.VectorPathMapTileEdge_empty(self)

    def size(self):
        r"""size(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::size_type"""
        return _IMP_bff.VectorPathMapTileEdge_size(self)

    def swap(self, v):
        r"""swap(VectorPathMapTileEdge self, VectorPathMapTileEdge v)"""
        return _IMP_bff.VectorPathMapTileEdge_swap(self, v)

    def begin(self):
        r"""begin(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::iterator"""
        return _IMP_bff.VectorPathMapTileEdge_begin(self)

    def end(self):
        r"""end(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::iterator"""
        return _IMP_bff.VectorPathMapTileEdge_end(self)

    def rbegin(self):
        r"""rbegin(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::reverse_iterator"""
        return _IMP_bff.VectorPathMapTileEdge_rbegin(self)

    def rend(self):
        r"""rend(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::reverse_iterator"""
        return _IMP_bff.VectorPathMapTileEdge_rend(self)

    def clear(self):
        r"""clear(VectorPathMapTileEdge self)"""
        return _IMP_bff.VectorPathMapTileEdge_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::allocator_type"""
        return _IMP_bff.VectorPathMapTileEdge_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorPathMapTileEdge self)"""
        return _IMP_bff.VectorPathMapTileEdge_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::iterator pos) -> std::vector< IMP::bff::PathMapTileEdge >::iterator
        erase(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::iterator first, std::vector< IMP::bff::PathMapTileEdge >::iterator last) -> std::vector< IMP::bff::PathMapTileEdge >::iterator
        """
        return _IMP_bff.VectorPathMapTileEdge_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorPathMapTileEdge self) -> VectorPathMapTileEdge
        __init__(VectorPathMapTileEdge self, VectorPathMapTileEdge other) -> VectorPathMapTileEdge
        __init__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::size_type size) -> VectorPathMapTileEdge
        __init__(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::size_type size, PathMapTileEdge value) -> VectorPathMapTileEdge
        """
        _IMP_bff.VectorPathMapTileEdge_swiginit(self, _IMP_bff.new_VectorPathMapTileEdge(*args))

    def push_back(self, x):
        r"""push_back(VectorPathMapTileEdge self, PathMapTileEdge x)"""
        return _IMP_bff.VectorPathMapTileEdge_push_back(self, x)

    def front(self):
        r"""front(VectorPathMapTileEdge self) -> PathMapTileEdge"""
        return _IMP_bff.VectorPathMapTileEdge_front(self)

    def back(self):
        r"""back(VectorPathMapTileEdge self) -> PathMapTileEdge"""
        return _IMP_bff.VectorPathMapTileEdge_back(self)

    def assign(self, n, x):
        r"""assign(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::size_type n, PathMapTileEdge x)"""
        return _IMP_bff.VectorPathMapTileEdge_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::size_type new_size)
        resize(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::size_type new_size, PathMapTileEdge x)
        """
        return _IMP_bff.VectorPathMapTileEdge_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::iterator pos, PathMapTileEdge x) -> std::vector< IMP::bff::PathMapTileEdge >::iterator
        insert(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::iterator pos, std::vector< IMP::bff::PathMapTileEdge >::size_type n, PathMapTileEdge x)
        """
        return _IMP_bff.VectorPathMapTileEdge_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VectorPathMapTileEdge self, std::vector< IMP::bff::PathMapTileEdge >::size_type n)"""
        return _IMP_bff.VectorPathMapTileEdge_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorPathMapTileEdge self) -> std::vector< IMP::bff::PathMapTileEdge >::size_type"""
        return _IMP_bff.VectorPathMapTileEdge_capacity(self)
    __swig_destroy__ = _IMP_bff.delete_VectorPathMapTileEdge

# Register VectorPathMapTileEdge in _IMP_bff:
_IMP_bff.VectorPathMapTileEdge_swigregister(VectorPathMapTileEdge)

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


_value_types.append("AV")


AVPairDistanceMeasurements=list
_plural_types.append("AVPairDistanceMeasurements")
_value_types.append("AVPairDistanceMeasurement")


_object_types.append("AVNetworkRestraint")


def _object_cast_to_AVNetworkRestraint(o):
    r"""_object_cast_to_AVNetworkRestraint(Object o) -> AVNetworkRestraint"""
    return _IMP_bff._object_cast_to_AVNetworkRestraint(o)
class MapStringAVPairDistanceMeasurement(object):
    r"""Proxy of C++ std::map< std::string,IMP::bff::AVPairDistanceMeasurement > class."""

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

    def iterator(self):
        r"""iterator(MapStringAVPairDistanceMeasurement self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(MapStringAVPairDistanceMeasurement self) -> bool"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement___nonzero__(self)

    def __bool__(self):
        r"""__bool__(MapStringAVPairDistanceMeasurement self) -> bool"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement___bool__(self)

    def __len__(self):
        r"""__len__(MapStringAVPairDistanceMeasurement self) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::size_type"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""__getitem__(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & key) -> AVPairDistanceMeasurement"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement___getitem__(self, key)

    def __delitem__(self, key):
        r"""__delitem__(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & key)"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & key) -> bool"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_has_key(self, key)

    def keys(self):
        r"""keys(MapStringAVPairDistanceMeasurement self) -> PyObject *"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_keys(self)

    def values(self):
        r"""values(MapStringAVPairDistanceMeasurement self) -> PyObject *"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_values(self)

    def items(self):
        r"""items(MapStringAVPairDistanceMeasurement self) -> PyObject *"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_items(self)

    def __contains__(self, key):
        r"""__contains__(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & key) -> bool"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(MapStringAVPairDistanceMeasurement self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(MapStringAVPairDistanceMeasurement self) -> IMP_BFF_SwigPyIterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & key)
        __setitem__(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & key, AVPairDistanceMeasurement x)
        """
        return _IMP_bff.MapStringAVPairDistanceMeasurement___setitem__(self, *args)

    def asdict(self):
        r"""asdict(MapStringAVPairDistanceMeasurement self) -> PyObject *"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(MapStringAVPairDistanceMeasurement self, std::less< std::string > const & other) -> MapStringAVPairDistanceMeasurement
        __init__(MapStringAVPairDistanceMeasurement self) -> MapStringAVPairDistanceMeasurement
        __init__(MapStringAVPairDistanceMeasurement self, MapStringAVPairDistanceMeasurement other) -> MapStringAVPairDistanceMeasurement
        """
        _IMP_bff.MapStringAVPairDistanceMeasurement_swiginit(self, _IMP_bff.new_MapStringAVPairDistanceMeasurement(*args))

    def empty(self):
        r"""empty(MapStringAVPairDistanceMeasurement self) -> bool"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_empty(self)

    def size(self):
        r"""size(MapStringAVPairDistanceMeasurement self) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::size_type"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_size(self)

    def swap(self, v):
        r"""swap(MapStringAVPairDistanceMeasurement self, MapStringAVPairDistanceMeasurement v)"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_swap(self, v)

    def begin(self):
        r"""begin(MapStringAVPairDistanceMeasurement self) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_begin(self)

    def end(self):
        r"""end(MapStringAVPairDistanceMeasurement self) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_end(self)

    def rbegin(self):
        r"""rbegin(MapStringAVPairDistanceMeasurement self) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::reverse_iterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_rbegin(self)

    def rend(self):
        r"""rend(MapStringAVPairDistanceMeasurement self) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::reverse_iterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_rend(self)

    def clear(self):
        r"""clear(MapStringAVPairDistanceMeasurement self)"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_clear(self)

    def get_allocator(self):
        r"""get_allocator(MapStringAVPairDistanceMeasurement self) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::allocator_type"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_get_allocator(self)

    def count(self, x):
        r"""count(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & x) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::size_type"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_count(self, x)

    def erase(self, *args):
        r"""
        erase(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & x) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::size_type
        erase(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator position)
        erase(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator first, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator last)
        """
        return _IMP_bff.MapStringAVPairDistanceMeasurement_erase(self, *args)

    def find(self, x):
        r"""find(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & x) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & x) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(MapStringAVPairDistanceMeasurement self, std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::key_type const & x) -> std::map< std::string,IMP::bff::AVPairDistanceMeasurement >::iterator"""
        return _IMP_bff.MapStringAVPairDistanceMeasurement_upper_bound(self, x)
    __swig_destroy__ = _IMP_bff.delete_MapStringAVPairDistanceMeasurement

# Register MapStringAVPairDistanceMeasurement in _IMP_bff:
_IMP_bff.MapStringAVPairDistanceMeasurement_swigregister(MapStringAVPairDistanceMeasurement)
DYE_PAIR_DISTANCE_E = _IMP_bff.DYE_PAIR_DISTANCE_E

DYE_PAIR_DISTANCE_MEAN = _IMP_bff.DYE_PAIR_DISTANCE_MEAN

DYE_PAIR_DISTANCE_MP = _IMP_bff.DYE_PAIR_DISTANCE_MP

DYE_PAIR_EFFICIENCY = _IMP_bff.DYE_PAIR_EFFICIENCY

DYE_PAIR_DISTANCE_DISTRIBUTION = _IMP_bff.DYE_PAIR_DISTANCE_DISTRIBUTION

DYE_PAIR_XYZ_DISTANCE = _IMP_bff.DYE_PAIR_XYZ_DISTANCE

class AVPairDistanceMeasurement(IMP._Value):
    r"""Proxy of C++ IMP::bff::AVPairDistanceMeasurement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    distance = property(_IMP_bff.AVPairDistanceMeasurement_distance_get, _IMP_bff.AVPairDistanceMeasurement_distance_set, doc=r"""distance : double""")
    error_neg = property(_IMP_bff.AVPairDistanceMeasurement_error_neg_get, _IMP_bff.AVPairDistanceMeasurement_error_neg_set, doc=r"""error_neg : double""")
    error_pos = property(_IMP_bff.AVPairDistanceMeasurement_error_pos_get, _IMP_bff.AVPairDistanceMeasurement_error_pos_set, doc=r"""error_pos : double""")
    forster_radius = property(_IMP_bff.AVPairDistanceMeasurement_forster_radius_get, _IMP_bff.AVPairDistanceMeasurement_forster_radius_set, doc=r"""forster_radius : double""")
    distance_type = property(_IMP_bff.AVPairDistanceMeasurement_distance_type_get, _IMP_bff.AVPairDistanceMeasurement_distance_type_set, doc=r"""distance_type : int""")
    position_1 = property(_IMP_bff.AVPairDistanceMeasurement_position_1_get, _IMP_bff.AVPairDistanceMeasurement_position_1_set, doc=r"""position_1 : std::string""")
    position_2 = property(_IMP_bff.AVPairDistanceMeasurement_position_2_get, _IMP_bff.AVPairDistanceMeasurement_position_2_set, doc=r"""position_2 : std::string""")

    def get_json(self):
        r"""get_json(AVPairDistanceMeasurement self) -> std::string"""
        return _IMP_bff.AVPairDistanceMeasurement_get_json(self)

    def score_model(self, model):
        r"""score_model(AVPairDistanceMeasurement self, double model) -> double"""
        return _IMP_bff.AVPairDistanceMeasurement_score_model(self, model)

    def show(self, *args, **kwargs):
        r"""show(AVPairDistanceMeasurement self, _ostream out=std::cout)"""
        return _IMP_bff.AVPairDistanceMeasurement_show(self, *args, **kwargs)

    def __str__(self):
        r"""__str__(AVPairDistanceMeasurement self) -> std::string"""
        return _IMP_bff.AVPairDistanceMeasurement___str__(self)

    def __repr__(self):
        r"""__repr__(AVPairDistanceMeasurement self) -> std::string"""
        return _IMP_bff.AVPairDistanceMeasurement___repr__(self)

    def __init__(self):
        r"""__init__(AVPairDistanceMeasurement self) -> AVPairDistanceMeasurement"""
        _IMP_bff.AVPairDistanceMeasurement_swiginit(self, _IMP_bff.new_AVPairDistanceMeasurement())
    __swig_destroy__ = _IMP_bff.delete_AVPairDistanceMeasurement

# Register AVPairDistanceMeasurement in _IMP_bff:
_IMP_bff.AVPairDistanceMeasurement_swigregister(AVPairDistanceMeasurement)
class AV(IMP.core.Gaussian):
    r"""Proxy of C++ IMP::bff::AV class."""

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

    def create_path_map_header(self):
        r"""create_path_map_header(AV self) -> PathMapHeader"""
        return _IMP_bff.AV_create_path_map_header(self)

    def init_path_map(self):
        r"""init_path_map(AV self)"""
        return _IMP_bff.AV_init_path_map(self)

    @staticmethod
    def get_av_key(i):
        r"""get_av_key(unsigned int i) -> FloatKey"""
        return _IMP_bff.AV_get_av_key(i)

    @staticmethod
    def do_setup_particle(*args, **kwargs):
        r"""do_setup_particle(Model m, ParticleIndex pi, ParticleIndex pi_source, double linker_length=20.0, Vector3D radii=IMP::algebra::Vector3D(3.5, 0, 0), double linker_width=0.5, double allowed_sphere_radius=1.5, double contact_volume_thickness=0.0, double contact_volume_trapped_fraction=-1, double simulation_grid_resolution=1.5)"""
        return _IMP_bff.AV_do_setup_particle(*args, **kwargs)

    @staticmethod
    def get_particle_key(i):
        r"""get_particle_key(unsigned int i) -> ParticleIndexKey"""
        return _IMP_bff.AV_get_particle_key(i)

    def get_particle_index(self, *args):
        r"""
        get_particle_index(AV self) -> ParticleIndex
        get_particle_index(AV self, unsigned int i) -> ParticleIndex
        """
        return _IMP_bff.AV_get_particle_index(self, *args)

    def get_particle(self, *args):
        r"""
        get_particle(AV self) -> Particle
        get_particle(AV self, unsigned int i) -> Particle
        """
        return _IMP_bff.AV_get_particle(self, *args)

    def __init__(self, *args):
        r"""
        __init__(AV self) -> AV
        __init__(AV self, Model m, ParticleIndex id) -> AV
        __init__(AV self, _ParticleAdaptor d) -> AV
        """
        _IMP_bff.AV_swiginit(self, _IMP_bff.new_AV(*args))

    def show(self, *args, **kwargs):
        r"""show(AV self, _ostream out=std::cout)"""
        return _IMP_bff.AV_show(self, *args, **kwargs)

    @staticmethod
    def setup_particle(*args):
        r"""
        setup_particle(Model m, ParticleIndex pi, ParticleIndex pi_source) -> AV
        setup_particle(_ParticleAdaptor pa, ParticleIndex pi_source) -> AV
        """
        return _IMP_bff.AV_setup_particle(*args)

    def get_linker_length(self):
        r"""get_linker_length(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_linker_length(self)

    def set_linker_length(self, t):
        r"""set_linker_length(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_linker_length(self, t)

    def get_radius1(self):
        r"""get_radius1(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_radius1(self)

    def set_radius1(self, t):
        r"""set_radius1(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_radius1(self, t)

    def get_radius2(self):
        r"""get_radius2(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_radius2(self)

    def set_radius2(self, t):
        r"""set_radius2(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_radius2(self, t)

    def get_radius3(self):
        r"""get_radius3(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_radius3(self)

    def set_radius3(self, t):
        r"""set_radius3(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_radius3(self, t)

    def get_linker_width(self):
        r"""get_linker_width(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_linker_width(self)

    def set_linker_width(self, t):
        r"""set_linker_width(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_linker_width(self, t)

    def get_allowed_sphere_radius(self):
        r"""get_allowed_sphere_radius(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_allowed_sphere_radius(self)

    def set_allowed_sphere_radius(self, t):
        r"""set_allowed_sphere_radius(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_allowed_sphere_radius(self, t)

    def get_contact_volume_thickness(self):
        r"""get_contact_volume_thickness(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_contact_volume_thickness(self)

    def set_contact_volume_thickness(self, t):
        r"""set_contact_volume_thickness(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_contact_volume_thickness(self, t)

    def get_contact_volume_trapped_fraction(self):
        r"""get_contact_volume_trapped_fraction(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_contact_volume_trapped_fraction(self)

    def set_contact_volume_trapped_fraction(self, t):
        r"""set_contact_volume_trapped_fraction(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_contact_volume_trapped_fraction(self, t)

    def get_simulation_grid_resolution(self):
        r"""get_simulation_grid_resolution(AV self) -> IMP::Float"""
        return _IMP_bff.AV_get_simulation_grid_resolution(self)

    def set_simulation_grid_resolution(self, t):
        r"""set_simulation_grid_resolution(AV self, IMP::Float t)"""
        return _IMP_bff.AV_set_simulation_grid_resolution(self, t)

    def get_radii(self):
        r"""get_radii(AV self) -> Vector3D"""
        return _IMP_bff.AV_get_radii(self)

    def get_parameters_are_optimized(self):
        r"""get_parameters_are_optimized(AV self) -> bool"""
        return _IMP_bff.AV_get_parameters_are_optimized(self)

    def set_av_parameters_are_optimized(self, tf):
        r"""set_av_parameters_are_optimized(AV self, bool tf)"""
        return _IMP_bff.AV_set_av_parameters_are_optimized(self, tf)

    def set_av_parameter(self, j):
        r"""set_av_parameter(AV self, nlohmann::json const & j)"""
        return _IMP_bff.AV_set_av_parameter(self, j)

    def get_derivatives(self):
        r"""get_derivatives(AV self) -> Vector3D"""
        return _IMP_bff.AV_get_derivatives(self)

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

    def get_map(self):
        r"""get_map(AV self) -> PathMap"""
        return _IMP_bff.AV_get_map(self)

    def resample(self, shift_xyz=True):
        r"""resample(AV self, bool shift_xyz=True)"""
        return _IMP_bff.AV_resample(self, shift_xyz)

    def get_mean_position(self, include_source=True):
        r"""get_mean_position(AV self, bool include_source=True) -> Vector3D"""
        return _IMP_bff.AV_get_mean_position(self, include_source)

    def get_source_coordinates(self):
        r"""get_source_coordinates(AV self) -> Vector3D"""
        return _IMP_bff.AV_get_source_coordinates(self)

    def get_source(self):
        r"""get_source(AV self) -> Particle"""
        return _IMP_bff.AV_get_source(self)

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

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

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

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

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

    def get_derivative(self, a0):
        r"""get_derivative(AV self, FloatKey a0) -> double"""
        return _IMP_bff.AV_get_derivative(self, a0)

    def get_name(self):
        r"""get_name(AV self) -> std::string"""
        return _IMP_bff.AV_get_name(self)

    def clear_caches(self):
        r"""clear_caches(AV self)"""
        return _IMP_bff.AV_clear_caches(self)

    def set_name(self, a0):
        r"""set_name(AV self, std::string a0)"""
        return _IMP_bff.AV_set_name(self, a0)

    def set_check_level(self, a0):
        r"""set_check_level(AV self, IMP::CheckLevel a0)"""
        return _IMP_bff.AV_set_check_level(self, a0)

    def add_to_derivative(self, a0, a1, a2):
        r"""add_to_derivative(AV self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_bff.AV_add_to_derivative(self, a0, a1, a2)

    def set_is_optimized(self, a0, a1):
        r"""set_is_optimized(AV self, FloatKey a0, bool a1)"""
        return _IMP_bff.AV_set_is_optimized(self, a0, a1)

    def get_is_optimized(self, a0):
        r"""get_is_optimized(AV self, FloatKey a0) -> bool"""
        return _IMP_bff.AV_get_is_optimized(self, a0)

    def get_check_level(self):
        r"""get_check_level(AV self) -> IMP::CheckLevel"""
        return _IMP_bff.AV_get_check_level(self)

    def __eq__(self, *args):
        r"""
        __eq__(AV self, AV o) -> bool
        __eq__(AV self, Particle d) -> bool
        """
        return _IMP_bff.AV___eq__(self, *args)

    def __ne__(self, *args):
        r"""
        __ne__(AV self, AV o) -> bool
        __ne__(AV self, Particle d) -> bool
        """
        return _IMP_bff.AV___ne__(self, *args)

    def __le__(self, *args):
        r"""
        __le__(AV self, AV o) -> bool
        __le__(AV self, Particle d) -> bool
        """
        return _IMP_bff.AV___le__(self, *args)

    def __lt__(self, *args):
        r"""
        __lt__(AV self, AV o) -> bool
        __lt__(AV self, Particle d) -> bool
        """
        return _IMP_bff.AV___lt__(self, *args)

    def __ge__(self, *args):
        r"""
        __ge__(AV self, AV o) -> bool
        __ge__(AV self, Particle d) -> bool
        """
        return _IMP_bff.AV___ge__(self, *args)

    def __gt__(self, *args):
        r"""
        __gt__(AV self, AV o) -> bool
        __gt__(AV self, Particle d) -> bool
        """
        return _IMP_bff.AV___gt__(self, *args)

    def __hash__(self):
        r"""__hash__(AV self) -> std::size_t"""
        return _IMP_bff.AV___hash__(self)

    def __str__(self):
        r"""__str__(AV self) -> std::string"""
        return _IMP_bff.AV___str__(self)

    def __repr__(self):
        r"""__repr__(AV self) -> std::string"""
        return _IMP_bff.AV___repr__(self)

    def _get_as_binary(self):
        r"""_get_as_binary(AV self) -> PyObject *"""
        return _IMP_bff.AV__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(AV self, PyObject * p)"""
        return _IMP_bff.AV__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)


    map = property(get_map)

    __swig_destroy__ = _IMP_bff.delete_AV

# Register AV in _IMP_bff:
_IMP_bff.AV_swigregister(AV)

def __lshift__(out, n):
    r"""__lshift__(_ostream out, AV n) -> _ostream"""
    return _IMP_bff.__lshift__(out, n)

def av_distance(*args, **kwargs):
    r"""av_distance(AV a, AV b, double forster_radius=52.0, int distance_type=DYE_PAIR_DISTANCE_MEAN, int n_samples=10000) -> double"""
    return _IMP_bff.av_distance(*args, **kwargs)

def av_random_points(av1, n_samples=10000):
    r"""av_random_points(AV av1, int n_samples=10000) -> VectorDouble"""
    return _IMP_bff.av_random_points(av1, n_samples)

def av_random_distances(av1, av2, n_samples=10000):
    r"""av_random_distances(AV av1, AV av2, int n_samples=10000) -> VectorDouble"""
    return _IMP_bff.av_random_distances(av1, av2, n_samples)

def av_distance_distribution(av1, av2, axis, n_samples=10000):
    r"""av_distance_distribution(AV av1, AV av2, VectorDouble axis, int n_samples=10000) -> VectorDouble"""
    return _IMP_bff.av_distance_distribution(av1, av2, axis, n_samples)

def search_labeling_site(*args, **kwargs):
    r"""search_labeling_site(Hierarchy hier, std::string json_str="", nlohmann::json const & json_data=nlohmann::json()) -> ParticleIndex"""
    return _IMP_bff.search_labeling_site(*args, **kwargs)
class AVNetworkRestraint(IMP.Restraint):
    r"""Proxy of C++ IMP::bff::AVNetworkRestraint class."""

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

    def __init__(self, *args, **kwargs):
        r"""__init__(AVNetworkRestraint self, Hierarchy hier, std::string fps_json_fn, std::string name="AVNetworkRestraint%1%", std::string score_set="", int n_samples=50000) -> AVNetworkRestraint"""
        _IMP_bff.AVNetworkRestraint_swiginit(self, _IMP_bff.new_AVNetworkRestraint(*args, **kwargs))

    def get_probability(self):
        r"""get_probability(AVNetworkRestraint self) -> double"""
        return _IMP_bff.AVNetworkRestraint_get_probability(self)

    def get_used_avs(self):
        r"""get_used_avs(AVNetworkRestraint self) -> IMP::bff::AVs const"""
        return _IMP_bff.AVNetworkRestraint_get_used_avs(self)

    def get_used_distances(self):
        r"""get_used_distances(AVNetworkRestraint self) -> MapStringAVPairDistanceMeasurement"""
        return _IMP_bff.AVNetworkRestraint_get_used_distances(self)

    def get_model_distance(self, position1_name, position2_name, forster_radius, distance_type):
        r"""get_model_distance(AVNetworkRestraint self, std::string position1_name, std::string position2_name, double forster_radius, int distance_type) -> double"""
        return _IMP_bff.AVNetworkRestraint_get_model_distance(self, position1_name, position2_name, forster_radius, distance_type)

    def get_indexes(self):
        r"""get_indexes(AVNetworkRestraint self) -> IMP::ParticleIndexes const"""
        return _IMP_bff.AVNetworkRestraint_get_indexes(self)

    def do_get_inputs(self):
        r"""do_get_inputs(AVNetworkRestraint self) -> IMP::ModelObjectsTemp"""
        return _IMP_bff.AVNetworkRestraint_do_get_inputs(self)

    def show(self, out):
        r"""show(AVNetworkRestraint self, _ostream out)"""
        return _IMP_bff.AVNetworkRestraint_show(self, out)

    def get_version_info(self):
        r"""get_version_info(AVNetworkRestraint self) -> VersionInfo"""
        return _IMP_bff.AVNetworkRestraint_get_version_info(self)
    __swig_destroy__ = _IMP_bff.delete_AVNetworkRestraint

    def __str__(self):
        r"""__str__(AVNetworkRestraint self) -> std::string"""
        return _IMP_bff.AVNetworkRestraint___str__(self)

    def __repr__(self):
        r"""__repr__(AVNetworkRestraint self) -> std::string"""
        return _IMP_bff.AVNetworkRestraint___repr__(self)

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


# Register AVNetworkRestraint in _IMP_bff:
_IMP_bff.AVNetworkRestraint_swigregister(AVNetworkRestraint)

def decay_rescale(fit, decay, start=0, stop=-1):
    r"""decay_rescale(double * fit, double * decay, int start=0, int stop=-1) -> double"""
    return _IMP_bff.decay_rescale(fit, decay, start, stop)

def decay_rescale_w(fit, decay, w_sq, start=0, stop=-1):
    r"""decay_rescale_w(double * fit, double * decay, double * w_sq, int start=0, int stop=-1) -> double"""
    return _IMP_bff.decay_rescale_w(fit, decay, w_sq, start, stop)

def decay_rescale_w_bg(fit, decay, w_sq, bg=0.0, start=0, stop=-1):
    r"""decay_rescale_w_bg(double * fit, double * decay, double * w_sq, double bg=0.0, int start=0, int stop=-1) -> double"""
    return _IMP_bff.decay_rescale_w_bg(fit, decay, w_sq, bg, start, stop)

def decay_fconv(fit, irf, x, start=0, stop=-1, dt=1.0):
    r"""decay_fconv(double * fit, double * irf, double * x, int start=0, int stop=-1, double dt=1.0)"""
    return _IMP_bff.decay_fconv(fit, irf, x, start, stop, dt)

def decay_fconv_avx(fit, irf, x, start=0, stop=-1, dt=1.0):
    r"""decay_fconv_avx(double * fit, double * irf, double * x, int start=0, int stop=-1, double dt=1.0)"""
    return _IMP_bff.decay_fconv_avx(fit, irf, x, start, stop, dt)

def decay_fconv_per(fit, irf, x, period, start=0, stop=-1, dt=1.0):
    r"""decay_fconv_per(double * fit, double * irf, double * x, double period, int start=0, int stop=-1, double dt=1.0)"""
    return _IMP_bff.decay_fconv_per(fit, irf, x, period, start, stop, dt)

def decay_fconv_per_avx(fit, irf, x, period, start=0, stop=-1, dt=1.0):
    r"""decay_fconv_per_avx(double * fit, double * irf, double * x, double period, int start=0, int stop=-1, double dt=1.0)"""
    return _IMP_bff.decay_fconv_per_avx(fit, irf, x, period, start, stop, dt)

def decay_fconv_per_cs(fit, irf, x, period, conv_stop=-1, stop=-1, dt=1.0):
    r"""decay_fconv_per_cs(double * fit, double * irf, double * x, double period, int conv_stop=-1, int stop=-1, double dt=1.0)"""
    return _IMP_bff.decay_fconv_per_cs(fit, irf, x, period, conv_stop, stop, dt)

def decay_fconv_ref(fit, irf, x, tauref, start=0, stop=-1, dt=1.0):
    r"""decay_fconv_ref(double * fit, double * irf, double * x, double tauref, int start=0, int stop=-1, double dt=1.0)"""
    return _IMP_bff.decay_fconv_ref(fit, irf, x, tauref, start, stop, dt)

def decay_sconv(fit, irf, model, start=0, stop=-1):
    r"""decay_sconv(double * fit, double * irf, double * model, int start=0, int stop=-1)"""
    return _IMP_bff.decay_sconv(fit, irf, model, start, stop)

def decay_shift_lamp(irf, irf_shift, ts):
    r"""decay_shift_lamp(double * irf, double * irf_shift, double ts)"""
    return _IMP_bff.decay_shift_lamp(irf, irf_shift, ts)

def mod_p(a, n):
    r"""mod_p(int a, int n) -> int"""
    return _IMP_bff.mod_p(a, n)

def decay_add_pile_up_to_model(*args, **kwargs):
    r"""decay_add_pile_up_to_model(double * model, double * data, double repetition_rate, double instrument_dead_time, double measurement_time, std::string pile_up_model="coates", int start=0, int stop=-1)"""
    return _IMP_bff.decay_add_pile_up_to_model(*args, **kwargs)

def discriminate_small_amplitudes(lifetime_spectrum, amplitude_threshold):
    r"""discriminate_small_amplitudes(double * lifetime_spectrum, double amplitude_threshold)"""
    return _IMP_bff.discriminate_small_amplitudes(lifetime_spectrum, amplitude_threshold)

def decay_fconv_per_cs_time_axis(model, time_axis, irf, lifetime_spectrum, convolution_start=0, convolution_stop=-1, period=100.0):
    r"""decay_fconv_per_cs_time_axis(double * model, double * time_axis, double * irf, double * lifetime_spectrum, int convolution_start=0, int convolution_stop=-1, double period=100.0)"""
    return _IMP_bff.decay_fconv_per_cs_time_axis(model, time_axis, irf, lifetime_spectrum, convolution_start, convolution_stop, period)

def decay_fconv_cs_time_axis(inplace_output, time_axis, irf, lifetime_spectrum, convolution_start=0, convolution_stop=-1):
    r"""decay_fconv_cs_time_axis(double * inplace_output, double * time_axis, double * irf, double * lifetime_spectrum, int convolution_start=0, int convolution_stop=-1)"""
    return _IMP_bff.decay_fconv_cs_time_axis(inplace_output, time_axis, irf, lifetime_spectrum, convolution_start, convolution_stop)
NOISE_NA = _IMP_bff.NOISE_NA

NOISE_POISSON = _IMP_bff.NOISE_POISSON

class DecayCurve(object):
    r"""Proxy of C++ IMP::bff::DecayCurve class."""

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

    @staticmethod
    def shift_array(input, shift):
        r"""shift_array(double * input, double shift) -> VectorDouble"""
        return _IMP_bff.DecayCurve_shift_array(input, shift)

    def size(self):
        r"""size(DecayCurve self) -> size_t"""
        return _IMP_bff.DecayCurve_size(self)

    def empty(self):
        r"""empty(DecayCurve self) -> bool"""
        return _IMP_bff.DecayCurve_empty(self)

    def get_dx(self):
        r"""get_dx(DecayCurve self) -> VectorDouble"""
        return _IMP_bff.DecayCurve_get_dx(self)

    def resize(self, n, v=0.0, dx=1.0):
        r"""resize(DecayCurve self, size_t n, double v=0.0, double dx=1.0)"""
        return _IMP_bff.DecayCurve_resize(self, n, v, dx)

    def get_average_dx(self):
        r"""get_average_dx(DecayCurve self) -> double"""
        return _IMP_bff.DecayCurve_get_average_dx(self)

    def get_x(self):
        r"""get_x(DecayCurve self) -> VectorDouble"""
        return _IMP_bff.DecayCurve_get_x(self)

    def set_x(self, *args):
        r"""
        set_x(DecayCurve self, VectorDouble v)
        set_x(DecayCurve self, double * input)
        """
        return _IMP_bff.DecayCurve_set_x(self, *args)

    def get_y(self):
        r"""get_y(DecayCurve self) -> VectorDouble"""
        return _IMP_bff.DecayCurve_get_y(self)

    def set_y(self, *args):
        r"""
        set_y(DecayCurve self, VectorDouble v)
        set_y(DecayCurve self, double * input)
        """
        return _IMP_bff.DecayCurve_set_y(self, *args)

    def get_ey(self):
        r"""get_ey(DecayCurve self) -> VectorDouble"""
        return _IMP_bff.DecayCurve_get_ey(self)

    def set_ey(self, *args):
        r"""
        set_ey(DecayCurve self, VectorDouble v)
        set_ey(DecayCurve self, double * input)
        """
        return _IMP_bff.DecayCurve_set_ey(self, *args)

    def set_acquisition_time(self, v):
        r"""set_acquisition_time(DecayCurve self, double v)"""
        return _IMP_bff.DecayCurve_set_acquisition_time(self, v)

    def get_acquisition_time(self):
        r"""get_acquisition_time(DecayCurve self) -> double"""
        return _IMP_bff.DecayCurve_get_acquisition_time(self)

    def set_shift(self, v):
        r"""set_shift(DecayCurve self, double v)"""
        return _IMP_bff.DecayCurve_set_shift(self, v)

    def get_shift(self):
        r"""get_shift(DecayCurve self) -> double"""
        return _IMP_bff.DecayCurve_get_shift(self)

    def get_json(self):
        r"""get_json(DecayCurve self) -> std::string"""
        return _IMP_bff.DecayCurve_get_json(self)

    def read_json(self, json_string):
        r"""read_json(DecayCurve self, std::string json_string) -> int"""
        return _IMP_bff.DecayCurve_read_json(self, json_string)

    def __init__(self, *args, **kwargs):
        r"""__init__(DecayCurve self, VectorDouble x=std::vector< double >(), VectorDouble y=std::vector< double >(), VectorDouble ey=std::vector< double >(), double acquisition_time=std::numeric_limits< double >::max(), int noise_model=NOISE_POISSON, int size=-1) -> DecayCurve"""
        _IMP_bff.DecayCurve_swiginit(self, _IMP_bff.new_DecayCurve(*args, **kwargs))

    def sum(self, start=0, stop=-1):
        r"""sum(DecayCurve self, int start=0, int stop=-1) -> double"""
        return _IMP_bff.DecayCurve_sum(self, start, stop)

    def apply_simple_moving_average(self, start, stop, n_window=5, normalize=False):
        r"""apply_simple_moving_average(DecayCurve self, int start, int stop, int n_window=5, bool normalize=False)"""
        return _IMP_bff.DecayCurve_apply_simple_moving_average(self, start, stop, n_window, normalize)

    def __iadd__(self, v):
        r"""__iadd__(DecayCurve self, double v) -> DecayCurve"""
        return _IMP_bff.DecayCurve___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(DecayCurve self, double v) -> DecayCurve"""
        return _IMP_bff.DecayCurve___isub__(self, v)

    def __imul__(self, v):
        r"""__imul__(DecayCurve self, double v) -> DecayCurve"""
        return _IMP_bff.DecayCurve___imul__(self, v)

    def __itruediv__(self, *args):
        return _IMP_bff.DecayCurve___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __add__(self, *args):
        r"""
        __add__(DecayCurve self, double v) -> DecayCurve
        __add__(DecayCurve self, DecayCurve other) -> DecayCurve
        """
        return _IMP_bff.DecayCurve___add__(self, *args)

    def __sub__(self, *args):
        r"""
        __sub__(DecayCurve self, double v) -> DecayCurve
        __sub__(DecayCurve self, DecayCurve other) -> DecayCurve
        """
        return _IMP_bff.DecayCurve___sub__(self, *args)

    def __mul__(self, *args):
        r"""
        __mul__(DecayCurve self, double v) -> DecayCurve
        __mul__(DecayCurve self, DecayCurve other) -> DecayCurve
        """
        return _IMP_bff.DecayCurve___mul__(self, *args)

    def __truediv__(self, *args):
        return _IMP_bff.DecayCurve___truediv__(self, *args)
    __div__ = __truediv__



    def __lshift__(self, v):
        r"""__lshift__(DecayCurve self, double v) -> DecayCurve"""
        return _IMP_bff.DecayCurve___lshift__(self, v)

    acquisition_time = property(get_acquisition_time, set_acquisition_time)


    shift = property(get_shift, set_shift)


    x = property(
        lambda x: np.array(x.get_x()),
        set_x
    )


    y = property(
        lambda x: np.array(x.get_y()),
        set_y
    )


    ey = property(
        lambda x: np.array(x.get_ey()),
        set_ey
    )

    __swig_destroy__ = _IMP_bff.delete_DecayCurve

# Register DecayCurve in _IMP_bff:
_IMP_bff.DecayCurve_swigregister(DecayCurve)

DecayRanges=list
_plural_types.append("DecayRanges")
_value_types.append("DecayRange")

class DecayRange(IMP._Value):
    r"""Proxy of C++ IMP::bff::DecayRange class."""

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

    def get_start(self, d=None):
        r"""get_start(DecayRange self, DecayCurve d=None) -> size_t"""
        return _IMP_bff.DecayRange_get_start(self, d)

    def get_stop(self, d=None):
        r"""get_stop(DecayRange self, DecayCurve d=None) -> size_t"""
        return _IMP_bff.DecayRange_get_stop(self, d)

    def set_range(self, v):
        r"""set_range(DecayRange self, VectorInt v)"""
        return _IMP_bff.DecayRange_set_range(self, v)

    def get_range(self, d=None):
        r"""get_range(DecayRange self, DecayCurve d=None) -> VectorInt"""
        return _IMP_bff.DecayRange_get_range(self, d)

    def set(self, start=0, stop=-1):
        r"""set(DecayRange self, int start=0, int stop=-1)"""
        return _IMP_bff.DecayRange_set(self, start, stop)

    def __init__(self, start, stop):
        r"""__init__(DecayRange self, int start, int stop) -> DecayRange"""
        _IMP_bff.DecayRange_swiginit(self, _IMP_bff.new_DecayRange(start, stop))
    __swig_destroy__ = _IMP_bff.delete_DecayRange

    def show(self, *args, **kwargs):
        r"""show(DecayRange self, _ostream out=std::cout)"""
        return _IMP_bff.DecayRange_show(self, *args, **kwargs)

    def __str__(self):
        r"""__str__(DecayRange self) -> std::string"""
        return _IMP_bff.DecayRange___str__(self)

    def __repr__(self):
        r"""__repr__(DecayRange self) -> std::string"""
        return _IMP_bff.DecayRange___repr__(self)
    start = property(_IMP_bff.DecayRange_start_get, _IMP_bff.DecayRange_start_set, doc=r"""start : int""")
    stop = property(_IMP_bff.DecayRange_stop_get, _IMP_bff.DecayRange_stop_set, doc=r"""stop : int""")

# Register DecayRange in _IMP_bff:
_IMP_bff.DecayRange_swigregister(DecayRange)

_object_types.append("DecayLifetimeHandler")


def _object_cast_to_DecayLifetimeHandler(o):
    r"""_object_cast_to_DecayLifetimeHandler(Object o) -> DecayLifetimeHandler"""
    return _IMP_bff._object_cast_to_DecayLifetimeHandler(o)
class DecayLifetimeHandler(IMP.Object):
    r"""Proxy of C++ IMP::bff::DecayLifetimeHandler class."""

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

    def add_lifetime(self, amplitude, lifetime):
        r"""add_lifetime(DecayLifetimeHandler self, double amplitude, double lifetime)"""
        return _IMP_bff.DecayLifetimeHandler_add_lifetime(self, amplitude, lifetime)

    def get_lifetime_spectrum(self):
        r"""get_lifetime_spectrum(DecayLifetimeHandler self)"""
        return _IMP_bff.DecayLifetimeHandler_get_lifetime_spectrum(self)

    def __init__(self, *args, **kwargs):
        r"""__init__(DecayLifetimeHandler self, VectorDouble lifetime_spectrum=std::vector< double >(), bool use_amplitude_threshold=False, bool abs_lifetime_spectrum=False, double amplitude_threshold=std::numeric_limits< double >::epsilon()) -> DecayLifetimeHandler"""
        _IMP_bff.DecayLifetimeHandler_swiginit(self, _IMP_bff.new_DecayLifetimeHandler(*args, **kwargs))

    def get_version_info(self):
        r"""get_version_info(DecayLifetimeHandler self) -> VersionInfo"""
        return _IMP_bff.DecayLifetimeHandler_get_version_info(self)
    __swig_destroy__ = _IMP_bff.delete_DecayLifetimeHandler

    def __str__(self):
        r"""__str__(DecayLifetimeHandler self) -> std::string"""
        return _IMP_bff.DecayLifetimeHandler___str__(self)

    def __repr__(self):
        r"""__repr__(DecayLifetimeHandler self) -> std::string"""
        return _IMP_bff.DecayLifetimeHandler___repr__(self)

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

    abs_lifetime_spectrum = property(_IMP_bff.DecayLifetimeHandler_abs_lifetime_spectrum_get, _IMP_bff.DecayLifetimeHandler_abs_lifetime_spectrum_set, doc=r"""abs_lifetime_spectrum : bool""")
    use_amplitude_threshold = property(_IMP_bff.DecayLifetimeHandler_use_amplitude_threshold_get, _IMP_bff.DecayLifetimeHandler_use_amplitude_threshold_set, doc=r"""use_amplitude_threshold : bool""")
    amplitude_threshold = property(_IMP_bff.DecayLifetimeHandler_amplitude_threshold_get, _IMP_bff.DecayLifetimeHandler_amplitude_threshold_set, doc=r"""amplitude_threshold : double""")
    lifetime_spectrum = property(_IMP_bff.DecayLifetimeHandler_lifetime_spectrum_get, _IMP_bff.DecayLifetimeHandler_lifetime_spectrum_set, doc=r"""lifetime_spectrum : std::vector<(double,std::allocator<(double)>)>""")

# Register DecayLifetimeHandler in _IMP_bff:
_IMP_bff.DecayLifetimeHandler_swigregister(DecayLifetimeHandler)

DecayModifiers=list
_plural_types.append("DecayModifiers")
_value_types.append("DecayModifier")

class DecayModifier(DecayRange):
    r"""Proxy of C++ IMP::bff::DecayModifier class."""

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

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

    def set_data(self, v):
        r"""set_data(DecayModifier self, DecayCurve v)"""
        return _IMP_bff.DecayModifier_set_data(self, v)

    def get_data(self):
        r"""get_data(DecayModifier self) -> DecayCurve"""
        return _IMP_bff.DecayModifier_get_data(self)

    def set(self, data, start=0, stop=-1, active=True):
        r"""set(DecayModifier self, DecayCurve data, int start=0, int stop=-1, bool active=True)"""
        return _IMP_bff.DecayModifier_set(self, data, start, stop, active)

    def resize(self, n, v=0.0):
        r"""resize(DecayModifier self, size_t n, double v=0.0)"""
        return _IMP_bff.DecayModifier_resize(self, n, v)

    def add(self, out):
        r"""add(DecayModifier self, DecayCurve out)"""
        return _IMP_bff.DecayModifier_add(self, out)
    __swig_destroy__ = _IMP_bff.delete_DecayModifier

    def __str__(self):
        r"""__str__(DecayModifier self) -> std::string"""
        return _IMP_bff.DecayModifier___str__(self)

    def __repr__(self):
        r"""__repr__(DecayModifier self) -> std::string"""
        return _IMP_bff.DecayModifier___repr__(self)
    active = property(_IMP_bff.DecayModifier_active_get, _IMP_bff.DecayModifier_active_set, doc=r"""active : bool""")

    data = property(get_data, set_data)


    def __call__(self, *args, **kwargs):
        self.add(*args, **kwargs)


# Register DecayModifier in _IMP_bff:
_IMP_bff.DecayModifier_swigregister(DecayModifier)

DecayConvolutions=list
_plural_types.append("DecayConvolutions")
_value_types.append("DecayConvolution")

class DecayConvolution(DecayModifier):
    r"""Proxy of C++ IMP::bff::DecayConvolution class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    FAST_PERIODIC_TIME = _IMP_bff.DecayConvolution_FAST_PERIODIC_TIME
    
    FAST_TIME = _IMP_bff.DecayConvolution_FAST_TIME
    
    FAST_PERIODIC = _IMP_bff.DecayConvolution_FAST_PERIODIC
    
    FAST = _IMP_bff.DecayConvolution_FAST
    
    FAST_AVX = _IMP_bff.DecayConvolution_FAST_AVX
    
    FAST_PERIODIC_AVX = _IMP_bff.DecayConvolution_FAST_PERIODIC_AVX
    

    @staticmethod
    def compute_corrected_irf(irf, corrected_irf, irf_shift_channels, irf_background_counts):
        r"""compute_corrected_irf(DecayCurve irf, DecayCurve corrected_irf, double irf_shift_channels, double irf_background_counts)"""
        return _IMP_bff.DecayConvolution_compute_corrected_irf(irf, corrected_irf, irf_shift_channels, irf_background_counts)

    @staticmethod
    def compute_mean_lifetime(irf_histogram, decay_histogram, micro_time_resolution):
        r"""compute_mean_lifetime(VectorDouble irf_histogram, VectorDouble decay_histogram, double micro_time_resolution) -> double"""
        return _IMP_bff.DecayConvolution_compute_mean_lifetime(irf_histogram, decay_histogram, micro_time_resolution)

    def set_irf(self, v):
        r"""set_irf(DecayConvolution self, DecayCurve v)"""
        return _IMP_bff.DecayConvolution_set_irf(self, v)

    def get_irf(self):
        r"""get_irf(DecayConvolution self) -> DecayCurve"""
        return _IMP_bff.DecayConvolution_get_irf(self)

    def get_mean_lifetime(self, decay):
        r"""get_mean_lifetime(DecayConvolution self, DecayCurve decay) -> double"""
        return _IMP_bff.DecayConvolution_get_mean_lifetime(self, decay)

    def set(self, *args, **kwargs):
        r"""set(DecayConvolution self, int convolution_method=FAST_PERIODIC_TIME, double excitation_period=100, double irf_shift_channels=0.0, double irf_background_counts=0)"""
        return _IMP_bff.DecayConvolution_set(self, *args, **kwargs)

    def __init__(self, *args, **kwargs):
        r"""__init__(DecayConvolution self, DecayLifetimeHandler lifetime_handler=None, DecayCurve instrument_response_function=None, int convolution_method=FAST, double excitation_period=100, double irf_shift_channels=0.0, double irf_background_counts=0, int start=0, int stop=-1, bool active=True) -> DecayConvolution"""
        _IMP_bff.DecayConvolution_swiginit(self, _IMP_bff.new_DecayConvolution(*args, **kwargs))
    __swig_destroy__ = _IMP_bff.delete_DecayConvolution

    def __str__(self):
        r"""__str__(DecayConvolution self) -> std::string"""
        return _IMP_bff.DecayConvolution___str__(self)

    def __repr__(self):
        r"""__repr__(DecayConvolution self) -> std::string"""
        return _IMP_bff.DecayConvolution___repr__(self)
    corrected_irf = property(_IMP_bff.DecayConvolution_corrected_irf_get, doc=r"""corrected_irf : r.IMP::bff::DecayCurve""")
    convolution_method = property(_IMP_bff.DecayConvolution_convolution_method_get, _IMP_bff.DecayConvolution_convolution_method_set, doc=r"""convolution_method : int""")
    excitation_period = property(_IMP_bff.DecayConvolution_excitation_period_get, _IMP_bff.DecayConvolution_excitation_period_set, doc=r"""excitation_period : double""")
    irf_shift_channels = property(_IMP_bff.DecayConvolution_irf_shift_channels_get, _IMP_bff.DecayConvolution_irf_shift_channels_set, doc=r"""irf_shift_channels : double""")
    irf_background_counts = property(_IMP_bff.DecayConvolution_irf_background_counts_get, _IMP_bff.DecayConvolution_irf_background_counts_set, doc=r"""irf_background_counts : double""")

    irf = property(get_irf, set_irf)


# Register DecayConvolution in _IMP_bff:
_IMP_bff.DecayConvolution_swigregister(DecayConvolution)

DecayPatterns=list
_plural_types.append("DecayPatterns")
_value_types.append("DecayPattern")

class DecayPattern(DecayModifier):
    r"""Proxy of C++ IMP::bff::DecayPattern class."""

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

    def __init__(self, constant_offset=0.0, pattern=None, pattern_fraction=0.0, start=0, stop=-1, active=True):
        r"""__init__(DecayPattern self, double constant_offset=0.0, DecayCurve pattern=None, double pattern_fraction=0.0, int start=0, int stop=-1, bool active=True) -> DecayPattern"""
        _IMP_bff.DecayPattern_swiginit(self, _IMP_bff.new_DecayPattern(constant_offset, pattern, pattern_fraction, start, stop, active))

    def __str__(self):
        r"""__str__(DecayPattern self) -> std::string"""
        return _IMP_bff.DecayPattern___str__(self)

    def __repr__(self):
        r"""__repr__(DecayPattern self) -> std::string"""
        return _IMP_bff.DecayPattern___repr__(self)
    pattern = property(_IMP_bff.DecayPattern_pattern_get, _IMP_bff.DecayPattern_pattern_set, doc=r"""pattern : p.IMP::bff::DecayCurve""")
    pattern_fraction = property(_IMP_bff.DecayPattern_pattern_fraction_get, _IMP_bff.DecayPattern_pattern_fraction_set, doc=r"""pattern_fraction : double""")
    constant_offset = property(_IMP_bff.DecayPattern_constant_offset_get, _IMP_bff.DecayPattern_constant_offset_set, doc=r"""constant_offset : double""")
    __swig_destroy__ = _IMP_bff.delete_DecayPattern

# Register DecayPattern in _IMP_bff:
_IMP_bff.DecayPattern_swigregister(DecayPattern)

DecayPileups=list
_plural_types.append("DecayPileups")
_value_types.append("DecayPileup")

class DecayPileup(DecayModifier):
    r"""Proxy of C++ IMP::bff::DecayPileup class."""

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

    def __init__(self, *args, **kwargs):
        r"""__init__(DecayPileup self, DecayCurve data, char const * pile_up_model="coates", double repetition_rate=100, double instrument_dead_time=120, int start=0, int stop=-1, bool active=True) -> DecayPileup"""
        _IMP_bff.DecayPileup_swiginit(self, _IMP_bff.new_DecayPileup(*args, **kwargs))

    def __str__(self):
        r"""__str__(DecayPileup self) -> std::string"""
        return _IMP_bff.DecayPileup___str__(self)

    def __repr__(self):
        r"""__repr__(DecayPileup self) -> std::string"""
        return _IMP_bff.DecayPileup___repr__(self)
    instrument_dead_time = property(_IMP_bff.DecayPileup_instrument_dead_time_get, _IMP_bff.DecayPileup_instrument_dead_time_set, doc=r"""instrument_dead_time : double""")
    repetition_rate = property(_IMP_bff.DecayPileup_repetition_rate_get, _IMP_bff.DecayPileup_repetition_rate_set, doc=r"""repetition_rate : double""")
    pile_up_model = property(_IMP_bff.DecayPileup_pile_up_model_get, _IMP_bff.DecayPileup_pile_up_model_set, doc=r"""pile_up_model : std::string""")
    __swig_destroy__ = _IMP_bff.delete_DecayPileup

# Register DecayPileup in _IMP_bff:
_IMP_bff.DecayPileup_swigregister(DecayPileup)

DecayLinearizations=list
_plural_types.append("DecayLinearizations")
_value_types.append("DecayLinearization")

class DecayLinearization(DecayModifier):
    r"""Proxy of C++ IMP::bff::DecayLinearization class."""

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

    def set_linearization_table(self, v):
        r"""set_linearization_table(DecayLinearization self, DecayCurve v)"""
        return _IMP_bff.DecayLinearization_set_linearization_table(self, v)

    def get_linearization_table(self):
        r"""get_linearization_table(DecayLinearization self) -> DecayCurve"""
        return _IMP_bff.DecayLinearization_get_linearization_table(self)

    def __init__(self, linearization_table, start, stop, active=True, n_window=5):
        r"""__init__(DecayLinearization self, DecayCurve linearization_table, int start, int stop, bool active=True, int n_window=5) -> DecayLinearization"""
        _IMP_bff.DecayLinearization_swiginit(self, _IMP_bff.new_DecayLinearization(linearization_table, start, stop, active, n_window))

    def __str__(self):
        r"""__str__(DecayLinearization self) -> std::string"""
        return _IMP_bff.DecayLinearization___str__(self)

    def __repr__(self):
        r"""__repr__(DecayLinearization self) -> std::string"""
        return _IMP_bff.DecayLinearization___repr__(self)
    __swig_destroy__ = _IMP_bff.delete_DecayLinearization

# Register DecayLinearization in _IMP_bff:
_IMP_bff.DecayLinearization_swigregister(DecayLinearization)

DecayScales=list
_plural_types.append("DecayScales")
_value_types.append("DecayScale")

class DecayScale(DecayModifier):
    r"""Proxy of C++ IMP::bff::DecayScale class."""

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

    def set_blank_outside(self, v):
        r"""set_blank_outside(DecayScale self, double v)"""
        return _IMP_bff.DecayScale_set_blank_outside(self, v)

    def get_blank_outside(self):
        r"""get_blank_outside(DecayScale self) -> bool"""
        return _IMP_bff.DecayScale_get_blank_outside(self)

    def set(self, data=None, constant_background=0.0, start=0, stop=-1, active=True, blank_outside=True):
        r"""set(DecayScale self, DecayCurve data=None, double constant_background=0.0, int start=0, int stop=-1, bool active=True, bool blank_outside=True)"""
        return _IMP_bff.DecayScale_set(self, data, constant_background, start, stop, active, blank_outside)

    def __init__(self, data=None, constant_background=0.0, start=0, stop=-1, active=True, blank_outside=True):
        r"""__init__(DecayScale self, DecayCurve data=None, double constant_background=0.0, int start=0, int stop=-1, bool active=True, bool blank_outside=True) -> DecayScale"""
        _IMP_bff.DecayScale_swiginit(self, _IMP_bff.new_DecayScale(data, constant_background, start, stop, active, blank_outside))

    def __str__(self):
        r"""__str__(DecayScale self) -> std::string"""
        return _IMP_bff.DecayScale___str__(self)

    def __repr__(self):
        r"""__repr__(DecayScale self) -> std::string"""
        return _IMP_bff.DecayScale___repr__(self)
    number_of_photons = property(_IMP_bff.DecayScale_number_of_photons_get, doc=r"""number_of_photons : double""")
    constant_background = property(_IMP_bff.DecayScale_constant_background_get, _IMP_bff.DecayScale_constant_background_set, doc=r"""constant_background : double""")
    __swig_destroy__ = _IMP_bff.delete_DecayScale

# Register DecayScale in _IMP_bff:
_IMP_bff.DecayScale_swigregister(DecayScale)

DecayScores=list
_plural_types.append("DecayScores")
_value_types.append("DecayScore")

class DecayScore(DecayRange):
    r"""Proxy of C++ IMP::bff::DecayScore class."""

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

    def get_model(self):
        r"""get_model(DecayScore self) -> DecayCurve"""
        return _IMP_bff.DecayScore_get_model(self)

    def set_model(self, v):
        r"""set_model(DecayScore self, DecayCurve v)"""
        return _IMP_bff.DecayScore_set_model(self, v)

    def get_data(self):
        r"""get_data(DecayScore self) -> DecayCurve"""
        return _IMP_bff.DecayScore_get_data(self)

    def set_data(self, v):
        r"""set_data(DecayScore self, DecayCurve v)"""
        return _IMP_bff.DecayScore_set_data(self, v)

    def get_weighted_residuals(self):
        r"""get_weighted_residuals(DecayScore self) -> VectorDouble"""
        return _IMP_bff.DecayScore_get_weighted_residuals(self)

    def get_score(self, start=0, stop=-1, score_type=None):
        r"""get_score(DecayScore self, int start=0, int stop=-1, char const * score_type=None) -> double"""
        return _IMP_bff.DecayScore_get_score(self, start, stop, score_type)

    def set(self, *args, **kwargs):
        r"""set(DecayScore self, DecayCurve model, DecayCurve data, std::string score_type="poisson", int start=0, int stop=-1)"""
        return _IMP_bff.DecayScore_set(self, *args, **kwargs)

    def __init__(self, *args, **kwargs):
        r"""__init__(DecayScore self, DecayCurve model=None, DecayCurve data=None, std::string score_type="poisson", int start=0, int stop=-1) -> DecayScore"""
        _IMP_bff.DecayScore_swiginit(self, _IMP_bff.new_DecayScore(*args, **kwargs))
    __swig_destroy__ = _IMP_bff.delete_DecayScore

    def __str__(self):
        r"""__str__(DecayScore self) -> std::string"""
        return _IMP_bff.DecayScore___str__(self)

    def __repr__(self):
        r"""__repr__(DecayScore self) -> std::string"""
        return _IMP_bff.DecayScore___repr__(self)
    score_type = property(_IMP_bff.DecayScore_score_type_get, _IMP_bff.DecayScore_score_type_set, doc=r"""score_type : std::string""")
    score = property(_IMP_bff.DecayScore_score_get, doc=r"""score : double""")

    model = property(get_model, set_model)


    data = property(get_data, set_data)


    weighted_residuals = property(
            lambda x: np.array(x.get_weighted_residuals())
    )


# Register DecayScore in _IMP_bff:
_IMP_bff.DecayScore_swigregister(DecayScore)

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

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

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

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

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