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

from sys import version_info as _swig_python_version_info
import _libBornAgainDevice

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 SwigPyIterator(object):
    r"""Proxy of C++ swig::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__ = _libBornAgainDevice.delete_SwigPyIterator

    def value(self):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainDevice.SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _libBornAgainDevice.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _libBornAgainDevice.SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _libBornAgainDevice.SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _libBornAgainDevice.SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _libBornAgainDevice.SwigPyIterator_copy(self)

    def next(self):
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainDevice.SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainDevice.SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _libBornAgainDevice.SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainDevice.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _libBornAgainDevice.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _libBornAgainDevice.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainDevice.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainDevice.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _libBornAgainDevice.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _libBornAgainDevice.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _libBornAgainDevice:
_libBornAgainDevice.SwigPyIterator_swigregister(SwigPyIterator)
SHARED_PTR_DISOWN = _libBornAgainDevice.SHARED_PTR_DISOWN


import warnings
def deprecated(message):
  def deprecated_decorator(func):
      def deprecated_func(*args, **kwargs):
          warnings.simplefilter('always', DeprecationWarning)  # turn off filter
          warnings.warn("{} is a deprecated function. {}".format(func.__name__, message),
                        category=DeprecationWarning,
                        stacklevel=2)
          warnings.simplefilter('default', DeprecationWarning)  # reset filter
          return func(*args, **kwargs)
      return deprecated_func
  return deprecated_decorator

class vdouble1d_t(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(vdouble1d_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vdouble1d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vdouble1d_t self) -> bool"""
        return _libBornAgainDevice.vdouble1d_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vdouble1d_t self) -> bool"""
        return _libBornAgainDevice.vdouble1d_t___bool__(self)

    def __len__(self):
        r"""__len__(vdouble1d_t self) -> std::vector< double >::size_type"""
        return _libBornAgainDevice.vdouble1d_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"""
        return _libBornAgainDevice.vdouble1d_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)
        """
        return _libBornAgainDevice.vdouble1d_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _libBornAgainDevice.vdouble1d_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
        __delitem__(vdouble1d_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vdouble1d_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
        __getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _libBornAgainDevice.vdouble1d_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
        __setitem__(vdouble1d_t self, PySliceObject * slice)
        __setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _libBornAgainDevice.vdouble1d_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vdouble1d_t self) -> std::vector< double >::value_type"""
        return _libBornAgainDevice.vdouble1d_t_pop(self)

    def append(self, x):
        r"""append(vdouble1d_t self, std::vector< double >::value_type const & x)"""
        return _libBornAgainDevice.vdouble1d_t_append(self, x)

    def empty(self):
        r"""empty(vdouble1d_t self) -> bool"""
        return _libBornAgainDevice.vdouble1d_t_empty(self)

    def size(self):
        r"""size(vdouble1d_t self) -> std::vector< double >::size_type"""
        return _libBornAgainDevice.vdouble1d_t_size(self)

    def swap(self, v):
        r"""swap(vdouble1d_t self, vdouble1d_t v)"""
        return _libBornAgainDevice.vdouble1d_t_swap(self, v)

    def begin(self):
        r"""begin(vdouble1d_t self) -> std::vector< double >::iterator"""
        return _libBornAgainDevice.vdouble1d_t_begin(self)

    def end(self):
        r"""end(vdouble1d_t self) -> std::vector< double >::iterator"""
        return _libBornAgainDevice.vdouble1d_t_end(self)

    def rbegin(self):
        r"""rbegin(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
        return _libBornAgainDevice.vdouble1d_t_rbegin(self)

    def rend(self):
        r"""rend(vdouble1d_t self) -> std::vector< double >::reverse_iterator"""
        return _libBornAgainDevice.vdouble1d_t_rend(self)

    def clear(self):
        r"""clear(vdouble1d_t self)"""
        return _libBornAgainDevice.vdouble1d_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
        return _libBornAgainDevice.vdouble1d_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vdouble1d_t self)"""
        return _libBornAgainDevice.vdouble1d_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vdouble1d_t self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(vdouble1d_t self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _libBornAgainDevice.vdouble1d_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vdouble1d_t self) -> vdouble1d_t
        __init__(vdouble1d_t self, vdouble1d_t other) -> vdouble1d_t
        __init__(vdouble1d_t self, std::vector< double >::size_type size) -> vdouble1d_t
        __init__(vdouble1d_t self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vdouble1d_t
        """
        _libBornAgainDevice.vdouble1d_t_swiginit(self, _libBornAgainDevice.new_vdouble1d_t(*args))

    def push_back(self, x):
        r"""push_back(vdouble1d_t self, std::vector< double >::value_type const & x)"""
        return _libBornAgainDevice.vdouble1d_t_push_back(self, x)

    def front(self):
        r"""front(vdouble1d_t self) -> std::vector< double >::value_type const &"""
        return _libBornAgainDevice.vdouble1d_t_front(self)

    def back(self):
        r"""back(vdouble1d_t self) -> std::vector< double >::value_type const &"""
        return _libBornAgainDevice.vdouble1d_t_back(self)

    def assign(self, n, x):
        r"""assign(vdouble1d_t self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _libBornAgainDevice.vdouble1d_t_assign(self, n, x)

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

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

    def reserve(self, n):
        r"""reserve(vdouble1d_t self, std::vector< double >::size_type n)"""
        return _libBornAgainDevice.vdouble1d_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vdouble1d_t self) -> std::vector< double >::size_type"""
        return _libBornAgainDevice.vdouble1d_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vdouble1d_t

# Register vdouble1d_t in _libBornAgainDevice:
_libBornAgainDevice.vdouble1d_t_swigregister(vdouble1d_t)
class vdouble2d_t(object):
    r"""Proxy of C++ std::vector< 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(vdouble2d_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vdouble2d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vdouble2d_t self) -> bool"""
        return _libBornAgainDevice.vdouble2d_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vdouble2d_t self) -> bool"""
        return _libBornAgainDevice.vdouble2d_t___bool__(self)

    def __len__(self):
        r"""__len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainDevice.vdouble2d_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"""
        return _libBornAgainDevice.vdouble2d_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)
        """
        return _libBornAgainDevice.vdouble2d_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"""
        return _libBornAgainDevice.vdouble2d_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
        __delitem__(vdouble2d_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vdouble2d_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
        __getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
        """
        return _libBornAgainDevice.vdouble2d_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
        __setitem__(vdouble2d_t self, PySliceObject * slice)
        __setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
        """
        return _libBornAgainDevice.vdouble2d_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vdouble2d_t self) -> vdouble1d_t"""
        return _libBornAgainDevice.vdouble2d_t_pop(self)

    def append(self, x):
        r"""append(vdouble2d_t self, vdouble1d_t x)"""
        return _libBornAgainDevice.vdouble2d_t_append(self, x)

    def empty(self):
        r"""empty(vdouble2d_t self) -> bool"""
        return _libBornAgainDevice.vdouble2d_t_empty(self)

    def size(self):
        r"""size(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainDevice.vdouble2d_t_size(self)

    def swap(self, v):
        r"""swap(vdouble2d_t self, vdouble2d_t v)"""
        return _libBornAgainDevice.vdouble2d_t_swap(self, v)

    def begin(self):
        r"""begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
        return _libBornAgainDevice.vdouble2d_t_begin(self)

    def end(self):
        r"""end(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
        return _libBornAgainDevice.vdouble2d_t_end(self)

    def rbegin(self):
        r"""rbegin(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libBornAgainDevice.vdouble2d_t_rbegin(self)

    def rend(self):
        r"""rend(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libBornAgainDevice.vdouble2d_t_rend(self)

    def clear(self):
        r"""clear(vdouble2d_t self)"""
        return _libBornAgainDevice.vdouble2d_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
        return _libBornAgainDevice.vdouble2d_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vdouble2d_t self)"""
        return _libBornAgainDevice.vdouble2d_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator
        erase(vdouble2d_t self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator
        """
        return _libBornAgainDevice.vdouble2d_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vdouble2d_t self) -> vdouble2d_t
        __init__(vdouble2d_t self, vdouble2d_t other) -> vdouble2d_t
        __init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size) -> vdouble2d_t
        __init__(vdouble2d_t self, std::vector< std::vector< double > >::size_type size, vdouble1d_t value) -> vdouble2d_t
        """
        _libBornAgainDevice.vdouble2d_t_swiginit(self, _libBornAgainDevice.new_vdouble2d_t(*args))

    def push_back(self, x):
        r"""push_back(vdouble2d_t self, vdouble1d_t x)"""
        return _libBornAgainDevice.vdouble2d_t_push_back(self, x)

    def front(self):
        r"""front(vdouble2d_t self) -> vdouble1d_t"""
        return _libBornAgainDevice.vdouble2d_t_front(self)

    def back(self):
        r"""back(vdouble2d_t self) -> vdouble1d_t"""
        return _libBornAgainDevice.vdouble2d_t_back(self)

    def assign(self, n, x):
        r"""assign(vdouble2d_t self, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)"""
        return _libBornAgainDevice.vdouble2d_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size)
        resize(vdouble2d_t self, std::vector< std::vector< double > >::size_type new_size, vdouble1d_t x)
        """
        return _libBornAgainDevice.vdouble2d_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, vdouble1d_t x) -> std::vector< std::vector< double > >::iterator
        insert(vdouble2d_t self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, vdouble1d_t x)
        """
        return _libBornAgainDevice.vdouble2d_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vdouble2d_t self, std::vector< std::vector< double > >::size_type n)"""
        return _libBornAgainDevice.vdouble2d_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainDevice.vdouble2d_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vdouble2d_t

# Register vdouble2d_t in _libBornAgainDevice:
_libBornAgainDevice.vdouble2d_t_swigregister(vdouble2d_t)
class vector_integer_t(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(vector_integer_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vector_integer_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_integer_t self) -> bool"""
        return _libBornAgainDevice.vector_integer_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_integer_t self) -> bool"""
        return _libBornAgainDevice.vector_integer_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_integer_t self) -> std::vector< int >::size_type"""
        return _libBornAgainDevice.vector_integer_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"""
        return _libBornAgainDevice.vector_integer_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)
        """
        return _libBornAgainDevice.vector_integer_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _libBornAgainDevice.vector_integer_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_integer_t self, std::vector< int >::difference_type i)
        __delitem__(vector_integer_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vector_integer_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
        __getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _libBornAgainDevice.vector_integer_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
        __setitem__(vector_integer_t self, PySliceObject * slice)
        __setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _libBornAgainDevice.vector_integer_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_integer_t self) -> std::vector< int >::value_type"""
        return _libBornAgainDevice.vector_integer_t_pop(self)

    def append(self, x):
        r"""append(vector_integer_t self, std::vector< int >::value_type const & x)"""
        return _libBornAgainDevice.vector_integer_t_append(self, x)

    def empty(self):
        r"""empty(vector_integer_t self) -> bool"""
        return _libBornAgainDevice.vector_integer_t_empty(self)

    def size(self):
        r"""size(vector_integer_t self) -> std::vector< int >::size_type"""
        return _libBornAgainDevice.vector_integer_t_size(self)

    def swap(self, v):
        r"""swap(vector_integer_t self, vector_integer_t v)"""
        return _libBornAgainDevice.vector_integer_t_swap(self, v)

    def begin(self):
        r"""begin(vector_integer_t self) -> std::vector< int >::iterator"""
        return _libBornAgainDevice.vector_integer_t_begin(self)

    def end(self):
        r"""end(vector_integer_t self) -> std::vector< int >::iterator"""
        return _libBornAgainDevice.vector_integer_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_integer_t self) -> std::vector< int >::reverse_iterator"""
        return _libBornAgainDevice.vector_integer_t_rbegin(self)

    def rend(self):
        r"""rend(vector_integer_t self) -> std::vector< int >::reverse_iterator"""
        return _libBornAgainDevice.vector_integer_t_rend(self)

    def clear(self):
        r"""clear(vector_integer_t self)"""
        return _libBornAgainDevice.vector_integer_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
        return _libBornAgainDevice.vector_integer_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_integer_t self)"""
        return _libBornAgainDevice.vector_integer_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_integer_t self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(vector_integer_t self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _libBornAgainDevice.vector_integer_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_integer_t self) -> vector_integer_t
        __init__(vector_integer_t self, vector_integer_t other) -> vector_integer_t
        __init__(vector_integer_t self, std::vector< int >::size_type size) -> vector_integer_t
        __init__(vector_integer_t self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> vector_integer_t
        """
        _libBornAgainDevice.vector_integer_t_swiginit(self, _libBornAgainDevice.new_vector_integer_t(*args))

    def push_back(self, x):
        r"""push_back(vector_integer_t self, std::vector< int >::value_type const & x)"""
        return _libBornAgainDevice.vector_integer_t_push_back(self, x)

    def front(self):
        r"""front(vector_integer_t self) -> std::vector< int >::value_type const &"""
        return _libBornAgainDevice.vector_integer_t_front(self)

    def back(self):
        r"""back(vector_integer_t self) -> std::vector< int >::value_type const &"""
        return _libBornAgainDevice.vector_integer_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_integer_t self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _libBornAgainDevice.vector_integer_t_assign(self, n, x)

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

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

    def reserve(self, n):
        r"""reserve(vector_integer_t self, std::vector< int >::size_type n)"""
        return _libBornAgainDevice.vector_integer_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_integer_t self) -> std::vector< int >::size_type"""
        return _libBornAgainDevice.vector_integer_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vector_integer_t

# Register vector_integer_t in _libBornAgainDevice:
_libBornAgainDevice.vector_integer_t_swigregister(vector_integer_t)
class vinteger2d_t(object):
    r"""Proxy of C++ std::vector< 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(vinteger2d_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vinteger2d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vinteger2d_t self) -> bool"""
        return _libBornAgainDevice.vinteger2d_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vinteger2d_t self) -> bool"""
        return _libBornAgainDevice.vinteger2d_t___bool__(self)

    def __len__(self):
        r"""__len__(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
        return _libBornAgainDevice.vinteger2d_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) -> vinteger2d_t"""
        return _libBornAgainDevice.vinteger2d_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)
        __setslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, vinteger2d_t v)
        """
        return _libBornAgainDevice.vinteger2d_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"""
        return _libBornAgainDevice.vinteger2d_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
        __delitem__(vinteger2d_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vinteger2d_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
        __getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
        """
        return _libBornAgainDevice.vinteger2d_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
        __setitem__(vinteger2d_t self, PySliceObject * slice)
        __setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
        """
        return _libBornAgainDevice.vinteger2d_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vinteger2d_t self) -> vector_integer_t"""
        return _libBornAgainDevice.vinteger2d_t_pop(self)

    def append(self, x):
        r"""append(vinteger2d_t self, vector_integer_t x)"""
        return _libBornAgainDevice.vinteger2d_t_append(self, x)

    def empty(self):
        r"""empty(vinteger2d_t self) -> bool"""
        return _libBornAgainDevice.vinteger2d_t_empty(self)

    def size(self):
        r"""size(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
        return _libBornAgainDevice.vinteger2d_t_size(self)

    def swap(self, v):
        r"""swap(vinteger2d_t self, vinteger2d_t v)"""
        return _libBornAgainDevice.vinteger2d_t_swap(self, v)

    def begin(self):
        r"""begin(vinteger2d_t self) -> std::vector< std::vector< int > >::iterator"""
        return _libBornAgainDevice.vinteger2d_t_begin(self)

    def end(self):
        r"""end(vinteger2d_t self) -> std::vector< std::vector< int > >::iterator"""
        return _libBornAgainDevice.vinteger2d_t_end(self)

    def rbegin(self):
        r"""rbegin(vinteger2d_t self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _libBornAgainDevice.vinteger2d_t_rbegin(self)

    def rend(self):
        r"""rend(vinteger2d_t self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _libBornAgainDevice.vinteger2d_t_rend(self)

    def clear(self):
        r"""clear(vinteger2d_t self)"""
        return _libBornAgainDevice.vinteger2d_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vinteger2d_t self) -> std::vector< std::vector< int > >::allocator_type"""
        return _libBornAgainDevice.vinteger2d_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vinteger2d_t self)"""
        return _libBornAgainDevice.vinteger2d_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos) -> std::vector< std::vector< int > >::iterator
        erase(vinteger2d_t self, std::vector< std::vector< int > >::iterator first, std::vector< std::vector< int > >::iterator last) -> std::vector< std::vector< int > >::iterator
        """
        return _libBornAgainDevice.vinteger2d_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vinteger2d_t self) -> vinteger2d_t
        __init__(vinteger2d_t self, vinteger2d_t other) -> vinteger2d_t
        __init__(vinteger2d_t self, std::vector< std::vector< int > >::size_type size) -> vinteger2d_t
        __init__(vinteger2d_t self, std::vector< std::vector< int > >::size_type size, vector_integer_t value) -> vinteger2d_t
        """
        _libBornAgainDevice.vinteger2d_t_swiginit(self, _libBornAgainDevice.new_vinteger2d_t(*args))

    def push_back(self, x):
        r"""push_back(vinteger2d_t self, vector_integer_t x)"""
        return _libBornAgainDevice.vinteger2d_t_push_back(self, x)

    def front(self):
        r"""front(vinteger2d_t self) -> vector_integer_t"""
        return _libBornAgainDevice.vinteger2d_t_front(self)

    def back(self):
        r"""back(vinteger2d_t self) -> vector_integer_t"""
        return _libBornAgainDevice.vinteger2d_t_back(self)

    def assign(self, n, x):
        r"""assign(vinteger2d_t self, std::vector< std::vector< int > >::size_type n, vector_integer_t x)"""
        return _libBornAgainDevice.vinteger2d_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vinteger2d_t self, std::vector< std::vector< int > >::size_type new_size)
        resize(vinteger2d_t self, std::vector< std::vector< int > >::size_type new_size, vector_integer_t x)
        """
        return _libBornAgainDevice.vinteger2d_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos, vector_integer_t x) -> std::vector< std::vector< int > >::iterator
        insert(vinteger2d_t self, std::vector< std::vector< int > >::iterator pos, std::vector< std::vector< int > >::size_type n, vector_integer_t x)
        """
        return _libBornAgainDevice.vinteger2d_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vinteger2d_t self, std::vector< std::vector< int > >::size_type n)"""
        return _libBornAgainDevice.vinteger2d_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
        return _libBornAgainDevice.vinteger2d_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vinteger2d_t

# Register vinteger2d_t in _libBornAgainDevice:
_libBornAgainDevice.vinteger2d_t_swigregister(vinteger2d_t)
class vector_longinteger_t(object):
    r"""Proxy of C++ std::vector< unsigned 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(vector_longinteger_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vector_longinteger_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_longinteger_t self) -> bool"""
        return _libBornAgainDevice.vector_longinteger_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_longinteger_t self) -> bool"""
        return _libBornAgainDevice.vector_longinteger_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
        return _libBornAgainDevice.vector_longinteger_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"""
        return _libBornAgainDevice.vector_longinteger_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)
        """
        return _libBornAgainDevice.vector_longinteger_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"""
        return _libBornAgainDevice.vector_longinteger_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
        __delitem__(vector_longinteger_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vector_longinteger_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
        __getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
        """
        return _libBornAgainDevice.vector_longinteger_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
        __setitem__(vector_longinteger_t self, PySliceObject * slice)
        __setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
        """
        return _libBornAgainDevice.vector_longinteger_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
        return _libBornAgainDevice.vector_longinteger_t_pop(self)

    def append(self, x):
        r"""append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
        return _libBornAgainDevice.vector_longinteger_t_append(self, x)

    def empty(self):
        r"""empty(vector_longinteger_t self) -> bool"""
        return _libBornAgainDevice.vector_longinteger_t_empty(self)

    def size(self):
        r"""size(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
        return _libBornAgainDevice.vector_longinteger_t_size(self)

    def swap(self, v):
        r"""swap(vector_longinteger_t self, vector_longinteger_t v)"""
        return _libBornAgainDevice.vector_longinteger_t_swap(self, v)

    def begin(self):
        r"""begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
        return _libBornAgainDevice.vector_longinteger_t_begin(self)

    def end(self):
        r"""end(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
        return _libBornAgainDevice.vector_longinteger_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"""
        return _libBornAgainDevice.vector_longinteger_t_rbegin(self)

    def rend(self):
        r"""rend(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"""
        return _libBornAgainDevice.vector_longinteger_t_rend(self)

    def clear(self):
        r"""clear(vector_longinteger_t self)"""
        return _libBornAgainDevice.vector_longinteger_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
        return _libBornAgainDevice.vector_longinteger_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_longinteger_t self)"""
        return _libBornAgainDevice.vector_longinteger_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_longinteger_t self, std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator
        erase(vector_longinteger_t self, std::vector< unsigned long >::iterator first, std::vector< unsigned long >::iterator last) -> std::vector< unsigned long >::iterator
        """
        return _libBornAgainDevice.vector_longinteger_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_longinteger_t self) -> vector_longinteger_t
        __init__(vector_longinteger_t self, vector_longinteger_t other) -> vector_longinteger_t
        __init__(vector_longinteger_t self, std::vector< unsigned long >::size_type size) -> vector_longinteger_t
        __init__(vector_longinteger_t self, std::vector< unsigned long >::size_type size, std::vector< unsigned long >::value_type const & value) -> vector_longinteger_t
        """
        _libBornAgainDevice.vector_longinteger_t_swiginit(self, _libBornAgainDevice.new_vector_longinteger_t(*args))

    def push_back(self, x):
        r"""push_back(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
        return _libBornAgainDevice.vector_longinteger_t_push_back(self, x)

    def front(self):
        r"""front(vector_longinteger_t self) -> std::vector< unsigned long >::value_type const &"""
        return _libBornAgainDevice.vector_longinteger_t_front(self)

    def back(self):
        r"""back(vector_longinteger_t self) -> std::vector< unsigned long >::value_type const &"""
        return _libBornAgainDevice.vector_longinteger_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_longinteger_t self, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)"""
        return _libBornAgainDevice.vector_longinteger_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_longinteger_t self, std::vector< unsigned long >::size_type new_size)
        resize(vector_longinteger_t self, std::vector< unsigned long >::size_type new_size, std::vector< unsigned long >::value_type const & x)
        """
        return _libBornAgainDevice.vector_longinteger_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_longinteger_t self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::value_type const & x) -> std::vector< unsigned long >::iterator
        insert(vector_longinteger_t self, std::vector< unsigned long >::iterator pos, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)
        """
        return _libBornAgainDevice.vector_longinteger_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_longinteger_t self, std::vector< unsigned long >::size_type n)"""
        return _libBornAgainDevice.vector_longinteger_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
        return _libBornAgainDevice.vector_longinteger_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vector_longinteger_t

# Register vector_longinteger_t in _libBornAgainDevice:
_libBornAgainDevice.vector_longinteger_t_swigregister(vector_longinteger_t)
class vector_complex_t(object):
    r"""Proxy of C++ std::vector< std::complex< 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(vector_complex_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vector_complex_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_complex_t self) -> bool"""
        return _libBornAgainDevice.vector_complex_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_complex_t self) -> bool"""
        return _libBornAgainDevice.vector_complex_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
        return _libBornAgainDevice.vector_complex_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"""
        return _libBornAgainDevice.vector_complex_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)
        """
        return _libBornAgainDevice.vector_complex_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"""
        return _libBornAgainDevice.vector_complex_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
        __delitem__(vector_complex_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vector_complex_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
        __getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
        """
        return _libBornAgainDevice.vector_complex_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
        __setitem__(vector_complex_t self, PySliceObject * slice)
        __setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
        """
        return _libBornAgainDevice.vector_complex_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
        return _libBornAgainDevice.vector_complex_t_pop(self)

    def append(self, x):
        r"""append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
        return _libBornAgainDevice.vector_complex_t_append(self, x)

    def empty(self):
        r"""empty(vector_complex_t self) -> bool"""
        return _libBornAgainDevice.vector_complex_t_empty(self)

    def size(self):
        r"""size(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
        return _libBornAgainDevice.vector_complex_t_size(self)

    def swap(self, v):
        r"""swap(vector_complex_t self, vector_complex_t v)"""
        return _libBornAgainDevice.vector_complex_t_swap(self, v)

    def begin(self):
        r"""begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
        return _libBornAgainDevice.vector_complex_t_begin(self)

    def end(self):
        r"""end(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
        return _libBornAgainDevice.vector_complex_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _libBornAgainDevice.vector_complex_t_rbegin(self)

    def rend(self):
        r"""rend(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _libBornAgainDevice.vector_complex_t_rend(self)

    def clear(self):
        r"""clear(vector_complex_t self)"""
        return _libBornAgainDevice.vector_complex_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
        return _libBornAgainDevice.vector_complex_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_complex_t self)"""
        return _libBornAgainDevice.vector_complex_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_complex_t self, std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator
        erase(vector_complex_t self, std::vector< std::complex< double > >::iterator first, std::vector< std::complex< double > >::iterator last) -> std::vector< std::complex< double > >::iterator
        """
        return _libBornAgainDevice.vector_complex_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_complex_t self) -> vector_complex_t
        __init__(vector_complex_t self, vector_complex_t other) -> vector_complex_t
        __init__(vector_complex_t self, std::vector< std::complex< double > >::size_type size) -> vector_complex_t
        __init__(vector_complex_t self, std::vector< std::complex< double > >::size_type size, std::vector< std::complex< double > >::value_type const & value) -> vector_complex_t
        """
        _libBornAgainDevice.vector_complex_t_swiginit(self, _libBornAgainDevice.new_vector_complex_t(*args))

    def push_back(self, x):
        r"""push_back(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
        return _libBornAgainDevice.vector_complex_t_push_back(self, x)

    def front(self):
        r"""front(vector_complex_t self) -> std::vector< std::complex< double > >::value_type const &"""
        return _libBornAgainDevice.vector_complex_t_front(self)

    def back(self):
        r"""back(vector_complex_t self) -> std::vector< std::complex< double > >::value_type const &"""
        return _libBornAgainDevice.vector_complex_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_complex_t self, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)"""
        return _libBornAgainDevice.vector_complex_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_complex_t self, std::vector< std::complex< double > >::size_type new_size)
        resize(vector_complex_t self, std::vector< std::complex< double > >::size_type new_size, std::vector< std::complex< double > >::value_type const & x)
        """
        return _libBornAgainDevice.vector_complex_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_complex_t self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::value_type const & x) -> std::vector< std::complex< double > >::iterator
        insert(vector_complex_t self, std::vector< std::complex< double > >::iterator pos, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)
        """
        return _libBornAgainDevice.vector_complex_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_complex_t self, std::vector< std::complex< double > >::size_type n)"""
        return _libBornAgainDevice.vector_complex_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
        return _libBornAgainDevice.vector_complex_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vector_complex_t

# Register vector_complex_t in _libBornAgainDevice:
_libBornAgainDevice.vector_complex_t_swigregister(vector_complex_t)
class vector_string_t(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(vector_string_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vector_string_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_string_t self) -> bool"""
        return _libBornAgainDevice.vector_string_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_string_t self) -> bool"""
        return _libBornAgainDevice.vector_string_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_string_t self) -> std::vector< std::string >::size_type"""
        return _libBornAgainDevice.vector_string_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"""
        return _libBornAgainDevice.vector_string_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)
        """
        return _libBornAgainDevice.vector_string_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _libBornAgainDevice.vector_string_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
        __delitem__(vector_string_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vector_string_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
        __getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _libBornAgainDevice.vector_string_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
        __setitem__(vector_string_t self, PySliceObject * slice)
        __setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _libBornAgainDevice.vector_string_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_string_t self) -> std::vector< std::string >::value_type"""
        return _libBornAgainDevice.vector_string_t_pop(self)

    def append(self, x):
        r"""append(vector_string_t self, std::vector< std::string >::value_type const & x)"""
        return _libBornAgainDevice.vector_string_t_append(self, x)

    def empty(self):
        r"""empty(vector_string_t self) -> bool"""
        return _libBornAgainDevice.vector_string_t_empty(self)

    def size(self):
        r"""size(vector_string_t self) -> std::vector< std::string >::size_type"""
        return _libBornAgainDevice.vector_string_t_size(self)

    def swap(self, v):
        r"""swap(vector_string_t self, vector_string_t v)"""
        return _libBornAgainDevice.vector_string_t_swap(self, v)

    def begin(self):
        r"""begin(vector_string_t self) -> std::vector< std::string >::iterator"""
        return _libBornAgainDevice.vector_string_t_begin(self)

    def end(self):
        r"""end(vector_string_t self) -> std::vector< std::string >::iterator"""
        return _libBornAgainDevice.vector_string_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_string_t self) -> std::vector< std::string >::reverse_iterator"""
        return _libBornAgainDevice.vector_string_t_rbegin(self)

    def rend(self):
        r"""rend(vector_string_t self) -> std::vector< std::string >::reverse_iterator"""
        return _libBornAgainDevice.vector_string_t_rend(self)

    def clear(self):
        r"""clear(vector_string_t self)"""
        return _libBornAgainDevice.vector_string_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
        return _libBornAgainDevice.vector_string_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_string_t self)"""
        return _libBornAgainDevice.vector_string_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_string_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(vector_string_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _libBornAgainDevice.vector_string_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_string_t self) -> vector_string_t
        __init__(vector_string_t self, vector_string_t other) -> vector_string_t
        __init__(vector_string_t self, std::vector< std::string >::size_type size) -> vector_string_t
        __init__(vector_string_t self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> vector_string_t
        """
        _libBornAgainDevice.vector_string_t_swiginit(self, _libBornAgainDevice.new_vector_string_t(*args))

    def push_back(self, x):
        r"""push_back(vector_string_t self, std::vector< std::string >::value_type const & x)"""
        return _libBornAgainDevice.vector_string_t_push_back(self, x)

    def front(self):
        r"""front(vector_string_t self) -> std::vector< std::string >::value_type const &"""
        return _libBornAgainDevice.vector_string_t_front(self)

    def back(self):
        r"""back(vector_string_t self) -> std::vector< std::string >::value_type const &"""
        return _libBornAgainDevice.vector_string_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_string_t self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _libBornAgainDevice.vector_string_t_assign(self, n, x)

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

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

    def reserve(self, n):
        r"""reserve(vector_string_t self, std::vector< std::string >::size_type n)"""
        return _libBornAgainDevice.vector_string_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_string_t self) -> std::vector< std::string >::size_type"""
        return _libBornAgainDevice.vector_string_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vector_string_t

# Register vector_string_t in _libBornAgainDevice:
_libBornAgainDevice.vector_string_t_swigregister(vector_string_t)
class map_string_double_t(object):
    r"""Proxy of C++ std::map< std::string,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(map_string_double_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.map_string_double_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(map_string_double_t self) -> bool"""
        return _libBornAgainDevice.map_string_double_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(map_string_double_t self) -> bool"""
        return _libBornAgainDevice.map_string_double_t___bool__(self)

    def __len__(self):
        r"""__len__(map_string_double_t self) -> std::map< std::string,double >::size_type"""
        return _libBornAgainDevice.map_string_double_t___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__(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> std::map< std::string,double >::mapped_type const &"""
        return _libBornAgainDevice.map_string_double_t___getitem__(self, key)

    def __delitem__(self, key):
        r"""__delitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key)"""
        return _libBornAgainDevice.map_string_double_t___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> bool"""
        return _libBornAgainDevice.map_string_double_t_has_key(self, key)

    def keys(self):
        r"""keys(map_string_double_t self) -> PyObject *"""
        return _libBornAgainDevice.map_string_double_t_keys(self)

    def values(self):
        r"""values(map_string_double_t self) -> PyObject *"""
        return _libBornAgainDevice.map_string_double_t_values(self)

    def items(self):
        r"""items(map_string_double_t self) -> PyObject *"""
        return _libBornAgainDevice.map_string_double_t_items(self)

    def __contains__(self, key):
        r"""__contains__(map_string_double_t self, std::map< std::string,double >::key_type const & key) -> bool"""
        return _libBornAgainDevice.map_string_double_t___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(map_string_double_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.map_string_double_t_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(map_string_double_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.map_string_double_t_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key)
        __setitem__(map_string_double_t self, std::map< std::string,double >::key_type const & key, std::map< std::string,double >::mapped_type const & x)
        """
        return _libBornAgainDevice.map_string_double_t___setitem__(self, *args)

    def asdict(self):
        r"""asdict(map_string_double_t self) -> PyObject *"""
        return _libBornAgainDevice.map_string_double_t_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(map_string_double_t self, std::less< std::string > const & other) -> map_string_double_t
        __init__(map_string_double_t self) -> map_string_double_t
        __init__(map_string_double_t self, map_string_double_t other) -> map_string_double_t
        """
        _libBornAgainDevice.map_string_double_t_swiginit(self, _libBornAgainDevice.new_map_string_double_t(*args))

    def empty(self):
        r"""empty(map_string_double_t self) -> bool"""
        return _libBornAgainDevice.map_string_double_t_empty(self)

    def size(self):
        r"""size(map_string_double_t self) -> std::map< std::string,double >::size_type"""
        return _libBornAgainDevice.map_string_double_t_size(self)

    def swap(self, v):
        r"""swap(map_string_double_t self, map_string_double_t v)"""
        return _libBornAgainDevice.map_string_double_t_swap(self, v)

    def begin(self):
        r"""begin(map_string_double_t self) -> std::map< std::string,double >::iterator"""
        return _libBornAgainDevice.map_string_double_t_begin(self)

    def end(self):
        r"""end(map_string_double_t self) -> std::map< std::string,double >::iterator"""
        return _libBornAgainDevice.map_string_double_t_end(self)

    def rbegin(self):
        r"""rbegin(map_string_double_t self) -> std::map< std::string,double >::reverse_iterator"""
        return _libBornAgainDevice.map_string_double_t_rbegin(self)

    def rend(self):
        r"""rend(map_string_double_t self) -> std::map< std::string,double >::reverse_iterator"""
        return _libBornAgainDevice.map_string_double_t_rend(self)

    def clear(self):
        r"""clear(map_string_double_t self)"""
        return _libBornAgainDevice.map_string_double_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(map_string_double_t self) -> std::map< std::string,double >::allocator_type"""
        return _libBornAgainDevice.map_string_double_t_get_allocator(self)

    def count(self, x):
        r"""count(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type"""
        return _libBornAgainDevice.map_string_double_t_count(self, x)

    def erase(self, *args):
        r"""
        erase(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type
        erase(map_string_double_t self, std::map< std::string,double >::iterator position)
        erase(map_string_double_t self, std::map< std::string,double >::iterator first, std::map< std::string,double >::iterator last)
        """
        return _libBornAgainDevice.map_string_double_t_erase(self, *args)

    def find(self, x):
        r"""find(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
        return _libBornAgainDevice.map_string_double_t_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
        return _libBornAgainDevice.map_string_double_t_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(map_string_double_t self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
        return _libBornAgainDevice.map_string_double_t_upper_bound(self, x)
    __swig_destroy__ = _libBornAgainDevice.delete_map_string_double_t

# Register map_string_double_t in _libBornAgainDevice:
_libBornAgainDevice.map_string_double_t_swigregister(map_string_double_t)
class pvacuum_double_t(object):
    r"""Proxy of C++ std::pair< double,double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(pvacuum_double_t self) -> pvacuum_double_t
        __init__(pvacuum_double_t self, double first, double second) -> pvacuum_double_t
        __init__(pvacuum_double_t self, pvacuum_double_t other) -> pvacuum_double_t
        """
        _libBornAgainDevice.pvacuum_double_t_swiginit(self, _libBornAgainDevice.new_pvacuum_double_t(*args))
    first = property(_libBornAgainDevice.pvacuum_double_t_first_get, _libBornAgainDevice.pvacuum_double_t_first_set, doc=r"""first : double""")
    second = property(_libBornAgainDevice.pvacuum_double_t_second_get, _libBornAgainDevice.pvacuum_double_t_second_set, doc=r"""second : double""")
    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__ = _libBornAgainDevice.delete_pvacuum_double_t

# Register pvacuum_double_t in _libBornAgainDevice:
_libBornAgainDevice.pvacuum_double_t_swigregister(pvacuum_double_t)
class vector_pvacuum_double_t(object):
    r"""Proxy of C++ std::vector< std::pair< double,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(vector_pvacuum_double_t self) -> SwigPyIterator"""
        return _libBornAgainDevice.vector_pvacuum_double_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_pvacuum_double_t self) -> bool"""
        return _libBornAgainDevice.vector_pvacuum_double_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_pvacuum_double_t self) -> bool"""
        return _libBornAgainDevice.vector_pvacuum_double_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
        return _libBornAgainDevice.vector_pvacuum_double_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j) -> vector_pvacuum_double_t"""
        return _libBornAgainDevice.vector_pvacuum_double_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)
        __setslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j, vector_pvacuum_double_t v)
        """
        return _libBornAgainDevice.vector_pvacuum_double_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"""
        return _libBornAgainDevice.vector_pvacuum_double_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
        __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vector_pvacuum_double_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
        __getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
        """
        return _libBornAgainDevice.vector_pvacuum_double_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
        __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
        __setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
        """
        return _libBornAgainDevice.vector_pvacuum_double_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_pvacuum_double_t self) -> pvacuum_double_t"""
        return _libBornAgainDevice.vector_pvacuum_double_t_pop(self)

    def append(self, x):
        r"""append(vector_pvacuum_double_t self, pvacuum_double_t x)"""
        return _libBornAgainDevice.vector_pvacuum_double_t_append(self, x)

    def empty(self):
        r"""empty(vector_pvacuum_double_t self) -> bool"""
        return _libBornAgainDevice.vector_pvacuum_double_t_empty(self)

    def size(self):
        r"""size(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
        return _libBornAgainDevice.vector_pvacuum_double_t_size(self)

    def swap(self, v):
        r"""swap(vector_pvacuum_double_t self, vector_pvacuum_double_t v)"""
        return _libBornAgainDevice.vector_pvacuum_double_t_swap(self, v)

    def begin(self):
        r"""begin(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::iterator"""
        return _libBornAgainDevice.vector_pvacuum_double_t_begin(self)

    def end(self):
        r"""end(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::iterator"""
        return _libBornAgainDevice.vector_pvacuum_double_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
        return _libBornAgainDevice.vector_pvacuum_double_t_rbegin(self)

    def rend(self):
        r"""rend(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
        return _libBornAgainDevice.vector_pvacuum_double_t_rend(self)

    def clear(self):
        r"""clear(vector_pvacuum_double_t self)"""
        return _libBornAgainDevice.vector_pvacuum_double_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::allocator_type"""
        return _libBornAgainDevice.vector_pvacuum_double_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_pvacuum_double_t self)"""
        return _libBornAgainDevice.vector_pvacuum_double_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos) -> std::vector< std::pair< double,double > >::iterator
        erase(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator first, std::vector< std::pair< double,double > >::iterator last) -> std::vector< std::pair< double,double > >::iterator
        """
        return _libBornAgainDevice.vector_pvacuum_double_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_pvacuum_double_t self) -> vector_pvacuum_double_t
        __init__(vector_pvacuum_double_t self, vector_pvacuum_double_t other) -> vector_pvacuum_double_t
        __init__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type size) -> vector_pvacuum_double_t
        __init__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type size, pvacuum_double_t value) -> vector_pvacuum_double_t
        """
        _libBornAgainDevice.vector_pvacuum_double_t_swiginit(self, _libBornAgainDevice.new_vector_pvacuum_double_t(*args))

    def push_back(self, x):
        r"""push_back(vector_pvacuum_double_t self, pvacuum_double_t x)"""
        return _libBornAgainDevice.vector_pvacuum_double_t_push_back(self, x)

    def front(self):
        r"""front(vector_pvacuum_double_t self) -> pvacuum_double_t"""
        return _libBornAgainDevice.vector_pvacuum_double_t_front(self)

    def back(self):
        r"""back(vector_pvacuum_double_t self) -> pvacuum_double_t"""
        return _libBornAgainDevice.vector_pvacuum_double_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_t x)"""
        return _libBornAgainDevice.vector_pvacuum_double_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type new_size)
        resize(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type new_size, pvacuum_double_t x)
        """
        return _libBornAgainDevice.vector_pvacuum_double_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos, pvacuum_double_t x) -> std::vector< std::pair< double,double > >::iterator
        insert(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::iterator pos, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_t x)
        """
        return _libBornAgainDevice.vector_pvacuum_double_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::size_type n)"""
        return _libBornAgainDevice.vector_pvacuum_double_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_pvacuum_double_t self) -> std::vector< std::pair< double,double > >::size_type"""
        return _libBornAgainDevice.vector_pvacuum_double_t_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vector_pvacuum_double_t

# Register vector_pvacuum_double_t in _libBornAgainDevice:
_libBornAgainDevice.vector_pvacuum_double_t_swigregister(vector_pvacuum_double_t)
import libBornAgainFit
import libBornAgainBase
class R3(object):
    r"""Proxy of C++ Vec3< double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(R3 self, double const x_, double const y_, double const z_) -> R3
        __init__(R3 self) -> R3
        """
        _libBornAgainDevice.R3_swiginit(self, _libBornAgainDevice.new_R3(*args))

    def x(self):
        r"""x(R3 self) -> double"""
        return _libBornAgainDevice.R3_x(self)

    def y(self):
        r"""y(R3 self) -> double"""
        return _libBornAgainDevice.R3_y(self)

    def z(self):
        r"""z(R3 self) -> double"""
        return _libBornAgainDevice.R3_z(self)

    def setX(self, a):
        r"""setX(R3 self, double const & a)"""
        return _libBornAgainDevice.R3_setX(self, a)

    def setY(self, a):
        r"""setY(R3 self, double const & a)"""
        return _libBornAgainDevice.R3_setY(self, a)

    def setZ(self, a):
        r"""setZ(R3 self, double const & a)"""
        return _libBornAgainDevice.R3_setZ(self, a)

    def __iadd__(self, v):
        r"""__iadd__(R3 self, R3 v) -> R3"""
        return _libBornAgainDevice.R3___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(R3 self, R3 v) -> R3"""
        return _libBornAgainDevice.R3___isub__(self, v)

    def conj(self):
        r"""conj(R3 self) -> R3"""
        return _libBornAgainDevice.R3_conj(self)

    def mag2(self):
        r"""mag2(R3 self) -> double"""
        return _libBornAgainDevice.R3_mag2(self)

    def mag(self):
        r"""mag(R3 self) -> double"""
        return _libBornAgainDevice.R3_mag(self)

    def magxy2(self):
        r"""magxy2(R3 self) -> double"""
        return _libBornAgainDevice.R3_magxy2(self)

    def magxy(self):
        r"""magxy(R3 self) -> double"""
        return _libBornAgainDevice.R3_magxy(self)

    def unit_or_throw(self):
        r"""unit_or_throw(R3 self) -> R3"""
        return _libBornAgainDevice.R3_unit_or_throw(self)

    def unit_or_null(self):
        r"""unit_or_null(R3 self) -> R3"""
        return _libBornAgainDevice.R3_unit_or_null(self)

    def complex(self):
        r"""complex(R3 self) -> C3"""
        return _libBornAgainDevice.R3_complex(self)

    def real(self):
        r"""real(R3 self) -> R3"""
        return _libBornAgainDevice.R3_real(self)

    def __eq__(self, other):
        r"""__eq__(R3 self, R3 other) -> bool"""
        return _libBornAgainDevice.R3___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(R3 self, R3 other) -> bool"""
        return _libBornAgainDevice.R3___ne__(self, other)

    def rotatedY(self, a):
        r"""rotatedY(R3 self, double a) -> R3"""
        return _libBornAgainDevice.R3_rotatedY(self, a)

    def rotatedZ(self, a):
        r"""rotatedZ(R3 self, double a) -> R3"""
        return _libBornAgainDevice.R3_rotatedZ(self, a)
    __swig_destroy__ = _libBornAgainDevice.delete_R3

# Register R3 in _libBornAgainDevice:
_libBornAgainDevice.R3_swigregister(R3)
class C3(object):
    r"""Proxy of C++ Vec3< std::complex< double > > class."""

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

    def __init__(self, *args):
        r"""
        __init__(C3 self, std::complex< double > const x_, std::complex< double > const y_, std::complex< double > const z_) -> C3
        __init__(C3 self) -> C3
        """
        _libBornAgainDevice.C3_swiginit(self, _libBornAgainDevice.new_C3(*args))

    def x(self):
        r"""x(C3 self) -> std::complex< double >"""
        return _libBornAgainDevice.C3_x(self)

    def y(self):
        r"""y(C3 self) -> std::complex< double >"""
        return _libBornAgainDevice.C3_y(self)

    def z(self):
        r"""z(C3 self) -> std::complex< double >"""
        return _libBornAgainDevice.C3_z(self)

    def setX(self, a):
        r"""setX(C3 self, std::complex< double > const & a)"""
        return _libBornAgainDevice.C3_setX(self, a)

    def setY(self, a):
        r"""setY(C3 self, std::complex< double > const & a)"""
        return _libBornAgainDevice.C3_setY(self, a)

    def setZ(self, a):
        r"""setZ(C3 self, std::complex< double > const & a)"""
        return _libBornAgainDevice.C3_setZ(self, a)

    def __iadd__(self, v):
        r"""__iadd__(C3 self, C3 v) -> C3"""
        return _libBornAgainDevice.C3___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(C3 self, C3 v) -> C3"""
        return _libBornAgainDevice.C3___isub__(self, v)

    def conj(self):
        r"""conj(C3 self) -> C3"""
        return _libBornAgainDevice.C3_conj(self)

    def mag2(self):
        r"""mag2(C3 self) -> double"""
        return _libBornAgainDevice.C3_mag2(self)

    def mag(self):
        r"""mag(C3 self) -> double"""
        return _libBornAgainDevice.C3_mag(self)

    def magxy2(self):
        r"""magxy2(C3 self) -> double"""
        return _libBornAgainDevice.C3_magxy2(self)

    def magxy(self):
        r"""magxy(C3 self) -> double"""
        return _libBornAgainDevice.C3_magxy(self)

    def unit_or_throw(self):
        r"""unit_or_throw(C3 self) -> C3"""
        return _libBornAgainDevice.C3_unit_or_throw(self)

    def unit_or_null(self):
        r"""unit_or_null(C3 self) -> C3"""
        return _libBornAgainDevice.C3_unit_or_null(self)

    def complex(self):
        r"""complex(C3 self) -> C3"""
        return _libBornAgainDevice.C3_complex(self)

    def real(self):
        r"""real(C3 self) -> R3"""
        return _libBornAgainDevice.C3_real(self)

    def __eq__(self, other):
        r"""__eq__(C3 self, C3 other) -> bool"""
        return _libBornAgainDevice.C3___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(C3 self, C3 other) -> bool"""
        return _libBornAgainDevice.C3___ne__(self, other)

    def rotatedY(self, a):
        r"""rotatedY(C3 self, double a) -> C3"""
        return _libBornAgainDevice.C3_rotatedY(self, a)

    def rotatedZ(self, a):
        r"""rotatedZ(C3 self, double a) -> C3"""
        return _libBornAgainDevice.C3_rotatedZ(self, a)
    __swig_destroy__ = _libBornAgainDevice.delete_C3

# Register C3 in _libBornAgainDevice:
_libBornAgainDevice.C3_swigregister(C3)
class vector_R3(object):
    r"""Proxy of C++ std::vector< Vec3< 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(vector_R3 self) -> SwigPyIterator"""
        return _libBornAgainDevice.vector_R3_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_R3 self) -> bool"""
        return _libBornAgainDevice.vector_R3___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_R3 self) -> bool"""
        return _libBornAgainDevice.vector_R3___bool__(self)

    def __len__(self):
        r"""__len__(vector_R3 self) -> std::vector< Vec3< double > >::size_type"""
        return _libBornAgainDevice.vector_R3___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j) -> vector_R3"""
        return _libBornAgainDevice.vector_R3___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)
        __setslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j, vector_R3 v)
        """
        return _libBornAgainDevice.vector_R3___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)"""
        return _libBornAgainDevice.vector_R3___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)
        __delitem__(vector_R3 self, PySliceObject * slice)
        """
        return _libBornAgainDevice.vector_R3___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
        __getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3
        """
        return _libBornAgainDevice.vector_R3___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
        __setitem__(vector_R3 self, PySliceObject * slice)
        __setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)
        """
        return _libBornAgainDevice.vector_R3___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_R3 self) -> R3"""
        return _libBornAgainDevice.vector_R3_pop(self)

    def append(self, x):
        r"""append(vector_R3 self, R3 x)"""
        return _libBornAgainDevice.vector_R3_append(self, x)

    def empty(self):
        r"""empty(vector_R3 self) -> bool"""
        return _libBornAgainDevice.vector_R3_empty(self)

    def size(self):
        r"""size(vector_R3 self) -> std::vector< Vec3< double > >::size_type"""
        return _libBornAgainDevice.vector_R3_size(self)

    def swap(self, v):
        r"""swap(vector_R3 self, vector_R3 v)"""
        return _libBornAgainDevice.vector_R3_swap(self, v)

    def begin(self):
        r"""begin(vector_R3 self) -> std::vector< Vec3< double > >::iterator"""
        return _libBornAgainDevice.vector_R3_begin(self)

    def end(self):
        r"""end(vector_R3 self) -> std::vector< Vec3< double > >::iterator"""
        return _libBornAgainDevice.vector_R3_end(self)

    def rbegin(self):
        r"""rbegin(vector_R3 self) -> std::vector< Vec3< double > >::reverse_iterator"""
        return _libBornAgainDevice.vector_R3_rbegin(self)

    def rend(self):
        r"""rend(vector_R3 self) -> std::vector< Vec3< double > >::reverse_iterator"""
        return _libBornAgainDevice.vector_R3_rend(self)

    def clear(self):
        r"""clear(vector_R3 self)"""
        return _libBornAgainDevice.vector_R3_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_R3 self) -> std::vector< Vec3< double > >::allocator_type"""
        return _libBornAgainDevice.vector_R3_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_R3 self)"""
        return _libBornAgainDevice.vector_R3_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_R3 self, std::vector< Vec3< double > >::iterator pos) -> std::vector< Vec3< double > >::iterator
        erase(vector_R3 self, std::vector< Vec3< double > >::iterator first, std::vector< Vec3< double > >::iterator last) -> std::vector< Vec3< double > >::iterator
        """
        return _libBornAgainDevice.vector_R3_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_R3 self) -> vector_R3
        __init__(vector_R3 self, vector_R3 other) -> vector_R3
        __init__(vector_R3 self, std::vector< Vec3< double > >::size_type size) -> vector_R3
        __init__(vector_R3 self, std::vector< Vec3< double > >::size_type size, R3 value) -> vector_R3
        """
        _libBornAgainDevice.vector_R3_swiginit(self, _libBornAgainDevice.new_vector_R3(*args))

    def push_back(self, x):
        r"""push_back(vector_R3 self, R3 x)"""
        return _libBornAgainDevice.vector_R3_push_back(self, x)

    def front(self):
        r"""front(vector_R3 self) -> R3"""
        return _libBornAgainDevice.vector_R3_front(self)

    def back(self):
        r"""back(vector_R3 self) -> R3"""
        return _libBornAgainDevice.vector_R3_back(self)

    def assign(self, n, x):
        r"""assign(vector_R3 self, std::vector< Vec3< double > >::size_type n, R3 x)"""
        return _libBornAgainDevice.vector_R3_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_R3 self, std::vector< Vec3< double > >::size_type new_size)
        resize(vector_R3 self, std::vector< Vec3< double > >::size_type new_size, R3 x)
        """
        return _libBornAgainDevice.vector_R3_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_R3 self, std::vector< Vec3< double > >::iterator pos, R3 x) -> std::vector< Vec3< double > >::iterator
        insert(vector_R3 self, std::vector< Vec3< double > >::iterator pos, std::vector< Vec3< double > >::size_type n, R3 x)
        """
        return _libBornAgainDevice.vector_R3_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_R3 self, std::vector< Vec3< double > >::size_type n)"""
        return _libBornAgainDevice.vector_R3_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_R3 self) -> std::vector< Vec3< double > >::size_type"""
        return _libBornAgainDevice.vector_R3_capacity(self)
    __swig_destroy__ = _libBornAgainDevice.delete_vector_R3

# Register vector_R3 in _libBornAgainDevice:
_libBornAgainDevice.vector_R3_swigregister(vector_R3)
import libBornAgainParam
class Datafield(object):
    r"""Proxy of C++ Datafield 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__(Datafield self) -> Datafield
        __init__(Datafield self, Frame frame, vdouble1d_t values={}, vdouble1d_t errSigmas={}) -> Datafield
        __init__(Datafield self, std::vector< Scale const *,std::allocator< Scale const * > > && axes, vdouble1d_t values={}, vdouble1d_t errSigmas={}) -> Datafield
        __init__(Datafield self, Datafield arg2) -> Datafield
        __init__(Datafield self, Datafield arg2) -> Datafield
        """
        _libBornAgainDevice.Datafield_swiginit(self, _libBornAgainDevice.new_Datafield(*args))
    __swig_destroy__ = _libBornAgainDevice.delete_Datafield

    def clone(self):
        r"""clone(Datafield self) -> Datafield"""
        return _libBornAgainDevice.Datafield_clone(self)

    def setAt(self, i, val):
        r"""setAt(Datafield self, size_t i, double val)"""
        return _libBornAgainDevice.Datafield_setAt(self, i, val)

    def valAt(self, i):
        r"""valAt(Datafield self, size_t i) -> double"""
        return _libBornAgainDevice.Datafield_valAt(self, i)

    def frame(self):
        r"""frame(Datafield self) -> Frame"""
        return _libBornAgainDevice.Datafield_frame(self)

    def rank(self):
        r"""rank(Datafield self) -> size_t"""
        return _libBornAgainDevice.Datafield_rank(self)

    def axis(self, k):
        r"""axis(Datafield self, size_t k) -> Scale"""
        return _libBornAgainDevice.Datafield_axis(self, k)

    def xAxis(self):
        r"""xAxis(Datafield self) -> Scale"""
        return _libBornAgainDevice.Datafield_xAxis(self)

    def yAxis(self):
        r"""yAxis(Datafield self) -> Scale"""
        return _libBornAgainDevice.Datafield_yAxis(self)

    def size(self):
        r"""size(Datafield self) -> size_t"""
        return _libBornAgainDevice.Datafield_size(self)

    def empty(self):
        r"""empty(Datafield self) -> bool"""
        return _libBornAgainDevice.Datafield_empty(self)

    def flatVector(self):
        r"""flatVector(Datafield self) -> vdouble1d_t"""
        return _libBornAgainDevice.Datafield_flatVector(self)

    def maxVal(self):
        r"""maxVal(Datafield self) -> double"""
        return _libBornAgainDevice.Datafield_maxVal(self)

    def minVal(self):
        r"""minVal(Datafield self) -> double"""
        return _libBornAgainDevice.Datafield_minVal(self)

    def scale(self, factor):
        r"""scale(Datafield self, double factor)"""
        return _libBornAgainDevice.Datafield_scale(self, factor)

    def crop(self, *args):
        r"""
        crop(Datafield self, double xmin, double ymin, double xmax, double ymax) -> Datafield
        crop(Datafield self, double xmin, double xmax) -> Datafield
        """
        return _libBornAgainDevice.Datafield_crop(self, *args)

    def npArray(self):
        r"""npArray(Datafield self) -> PyObject *"""
        return _libBornAgainDevice.Datafield_npArray(self)

    def xProjection(self, *args):
        r"""
        xProjection(Datafield self) -> Datafield
        xProjection(Datafield self, double yvalue) -> Datafield
        xProjection(Datafield self, double ylow, double yup) -> Datafield
        """
        return _libBornAgainDevice.Datafield_xProjection(self, *args)

    def yProjection(self, *args):
        r"""
        yProjection(Datafield self) -> Datafield
        yProjection(Datafield self, double xvalue) -> Datafield
        yProjection(Datafield self, double xlow, double xup) -> Datafield
        """
        return _libBornAgainDevice.Datafield_yProjection(self, *args)

# Register Datafield in _libBornAgainDevice:
_libBornAgainDevice.Datafield_swigregister(Datafield)

def meanRelVecDiff(dat, ref):
    r"""meanRelVecDiff(vdouble1d_t dat, vdouble1d_t ref) -> double"""
    return _libBornAgainDevice.meanRelVecDiff(dat, ref)

def relativeDifferenceField(dat, ref):
    r"""relativeDifferenceField(Datafield dat, Datafield ref) -> Datafield"""
    return _libBornAgainDevice.relativeDifferenceField(dat, ref)

def meanRelativeDifference(dat, ref):
    r"""meanRelativeDifference(SimulationResult dat, SimulationResult ref) -> double"""
    return _libBornAgainDevice.meanRelativeDifference(dat, ref)

def checkRelativeDifference(dat, ref, threshold):
    r"""checkRelativeDifference(vdouble1d_t dat, vdouble1d_t ref, double threshold) -> bool"""
    return _libBornAgainDevice.checkRelativeDifference(dat, ref, threshold)

def invertAxis(axis, original):
    r"""invertAxis(int axis, vdouble2d_t original) -> vdouble2d_t"""
    return _libBornAgainDevice.invertAxis(axis, original)

def transpose(original):
    r"""transpose(vdouble2d_t original) -> vdouble2d_t"""
    return _libBornAgainDevice.transpose(original)

def create2DArrayfromDatafield(data):
    r"""create2DArrayfromDatafield(Datafield data) -> vdouble2d_t"""
    return _libBornAgainDevice.create2DArrayfromDatafield(data)

def importArrayToDatafield(*args):
    r"""
    importArrayToDatafield(vdouble1d_t vec) -> Datafield
    importArrayToDatafield(vdouble2d_t vec) -> Datafield
    """
    return _libBornAgainDevice.importArrayToDatafield(*args)

def FindPeaks(*args):
    r"""FindPeaks(Datafield data, double sigma=2, std::string const & option={}, double threshold=0.05) -> vector_pvacuum_double_t"""
    return _libBornAgainDevice.FindPeaks(*args)
class Beam(libBornAgainParam.INode):
    r"""Proxy of C++ Beam 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, intensity, wavelength, alpha, phi=0):
        r"""__init__(Beam self, double intensity, double wavelength, double alpha, double phi=0) -> Beam"""
        _libBornAgainDevice.Beam_swiginit(self, _libBornAgainDevice.new_Beam(intensity, wavelength, alpha, phi))
    __swig_destroy__ = _libBornAgainDevice.delete_Beam

    def className(self):
        r"""className(Beam self) -> std::string"""
        return _libBornAgainDevice.Beam_className(self)

    def setFootprint(self, shape_factor):
        r"""setFootprint(Beam self, IFootprint shape_factor)"""
        return _libBornAgainDevice.Beam_setFootprint(self, shape_factor)

    def setPolarization(self, polarization):
        r"""setPolarization(Beam self, R3 polarization)"""
        return _libBornAgainDevice.Beam_setPolarization(self, polarization)

# Register Beam in _libBornAgainDevice:
_libBornAgainDevice.Beam_swigregister(Beam)
class IFootprint(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""Proxy of C++ IFootprint 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__ = _libBornAgainDevice.delete_IFootprint

    def clone(self):
        r"""clone(IFootprint self) -> IFootprint"""
        return _libBornAgainDevice.IFootprint_clone(self)

    def parDefs(self):
        r"""parDefs(IFootprint self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainDevice.IFootprint_parDefs(self)

    def widthRatio(self):
        r"""widthRatio(IFootprint self) -> double"""
        return _libBornAgainDevice.IFootprint_widthRatio(self)

    def calculate(self, alpha):
        r"""calculate(IFootprint self, double alpha) -> double"""
        return _libBornAgainDevice.IFootprint_calculate(self, alpha)

    def validate(self):
        r"""validate(IFootprint self) -> std::string"""
        return _libBornAgainDevice.IFootprint_validate(self)

# Register IFootprint in _libBornAgainDevice:
_libBornAgainDevice.IFootprint_swigregister(IFootprint)
class FootprintGauss(IFootprint):
    r"""Proxy of C++ FootprintGauss 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__(FootprintGauss self, vdouble1d_t P) -> FootprintGauss
        __init__(FootprintGauss self, double width_ratio) -> FootprintGauss
        """
        _libBornAgainDevice.FootprintGauss_swiginit(self, _libBornAgainDevice.new_FootprintGauss(*args))

    def clone(self):
        r"""clone(FootprintGauss self) -> FootprintGauss"""
        return _libBornAgainDevice.FootprintGauss_clone(self)

    def className(self):
        r"""className(FootprintGauss self) -> std::string"""
        return _libBornAgainDevice.FootprintGauss_className(self)

    def calculate(self, alpha):
        r"""calculate(FootprintGauss self, double alpha) -> double"""
        return _libBornAgainDevice.FootprintGauss_calculate(self, alpha)
    __swig_destroy__ = _libBornAgainDevice.delete_FootprintGauss

# Register FootprintGauss in _libBornAgainDevice:
_libBornAgainDevice.FootprintGauss_swigregister(FootprintGauss)
class FootprintSquare(IFootprint):
    r"""Proxy of C++ FootprintSquare 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__(FootprintSquare self, vdouble1d_t P) -> FootprintSquare
        __init__(FootprintSquare self, double width_ratio) -> FootprintSquare
        """
        _libBornAgainDevice.FootprintSquare_swiginit(self, _libBornAgainDevice.new_FootprintSquare(*args))

    def clone(self):
        r"""clone(FootprintSquare self) -> FootprintSquare"""
        return _libBornAgainDevice.FootprintSquare_clone(self)

    def className(self):
        r"""className(FootprintSquare self) -> std::string"""
        return _libBornAgainDevice.FootprintSquare_className(self)

    def calculate(self, alpha):
        r"""calculate(FootprintSquare self, double alpha) -> double"""
        return _libBornAgainDevice.FootprintSquare_calculate(self, alpha)
    __swig_destroy__ = _libBornAgainDevice.delete_FootprintSquare

# Register FootprintSquare in _libBornAgainDevice:
_libBornAgainDevice.FootprintSquare_swigregister(FootprintSquare)
class IShape2D(libBornAgainBase.ICloneable):
    r"""Proxy of C++ IShape2D 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__ = _libBornAgainDevice.delete_IShape2D

    def clone(self):
        r"""clone(IShape2D self) -> IShape2D"""
        return _libBornAgainDevice.IShape2D_clone(self)

    def contains(self, *args):
        r"""
        contains(IShape2D self, double x, double y) -> bool
        contains(IShape2D self, Bin1D const & binx, Bin1D const & biny) -> bool
        """
        return _libBornAgainDevice.IShape2D_contains(self, *args)

# Register IShape2D in _libBornAgainDevice:
_libBornAgainDevice.IShape2D_swigregister(IShape2D)
class Ellipse(IShape2D):
    r"""Proxy of C++ Ellipse 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, xcenter, ycenter, xradius, yradius, theta=0.0):
        r"""__init__(Ellipse self, double xcenter, double ycenter, double xradius, double yradius, double theta=0.0) -> Ellipse"""
        _libBornAgainDevice.Ellipse_swiginit(self, _libBornAgainDevice.new_Ellipse(xcenter, ycenter, xradius, yradius, theta))

    def clone(self):
        r"""clone(Ellipse self) -> Ellipse"""
        return _libBornAgainDevice.Ellipse_clone(self)

    def contains(self, *args):
        r"""
        contains(Ellipse self, double x, double y) -> bool
        contains(Ellipse self, Bin1D const & binx, Bin1D const & biny) -> bool
        """
        return _libBornAgainDevice.Ellipse_contains(self, *args)

    def getCenterX(self):
        r"""getCenterX(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_getCenterX(self)

    def getCenterY(self):
        r"""getCenterY(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_getCenterY(self)

    def radiusX(self):
        r"""radiusX(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_radiusX(self)

    def radiusY(self):
        r"""radiusY(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_radiusY(self)

    def getTheta(self):
        r"""getTheta(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_getTheta(self)
    __swig_destroy__ = _libBornAgainDevice.delete_Ellipse

# Register Ellipse in _libBornAgainDevice:
_libBornAgainDevice.Ellipse_swigregister(Ellipse)
class Line(IShape2D):
    r"""Proxy of C++ Line 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, x1, y1, x2, y2):
        r"""__init__(Line self, double x1, double y1, double x2, double y2) -> Line"""
        _libBornAgainDevice.Line_swiginit(self, _libBornAgainDevice.new_Line(x1, y1, x2, y2))

    def clone(self):
        r"""clone(Line self) -> Line"""
        return _libBornAgainDevice.Line_clone(self)

    def contains(self, *args):
        r"""
        contains(Line self, double x, double y) -> bool
        contains(Line self, Bin1D const & binx, Bin1D const & biny) -> bool
        """
        return _libBornAgainDevice.Line_contains(self, *args)
    __swig_destroy__ = _libBornAgainDevice.delete_Line

# Register Line in _libBornAgainDevice:
_libBornAgainDevice.Line_swigregister(Line)
class VerticalLine(IShape2D):
    r"""Proxy of C++ VerticalLine 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, x):
        r"""__init__(VerticalLine self, double x) -> VerticalLine"""
        _libBornAgainDevice.VerticalLine_swiginit(self, _libBornAgainDevice.new_VerticalLine(x))

    def clone(self):
        r"""clone(VerticalLine self) -> VerticalLine"""
        return _libBornAgainDevice.VerticalLine_clone(self)

    def contains(self, *args):
        r"""
        contains(VerticalLine self, double x, double y) -> bool
        contains(VerticalLine self, Bin1D const & binx, Bin1D const & biny) -> bool
        """
        return _libBornAgainDevice.VerticalLine_contains(self, *args)

    def getXpos(self):
        r"""getXpos(VerticalLine self) -> double"""
        return _libBornAgainDevice.VerticalLine_getXpos(self)
    __swig_destroy__ = _libBornAgainDevice.delete_VerticalLine

# Register VerticalLine in _libBornAgainDevice:
_libBornAgainDevice.VerticalLine_swigregister(VerticalLine)
class HorizontalLine(IShape2D):
    r"""Proxy of C++ HorizontalLine 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, y):
        r"""__init__(HorizontalLine self, double y) -> HorizontalLine"""
        _libBornAgainDevice.HorizontalLine_swiginit(self, _libBornAgainDevice.new_HorizontalLine(y))

    def clone(self):
        r"""clone(HorizontalLine self) -> HorizontalLine"""
        return _libBornAgainDevice.HorizontalLine_clone(self)

    def contains(self, *args):
        r"""
        contains(HorizontalLine self, double x, double y) -> bool
        contains(HorizontalLine self, Bin1D const & binx, Bin1D const & biny) -> bool
        """
        return _libBornAgainDevice.HorizontalLine_contains(self, *args)

    def getYpos(self):
        r"""getYpos(HorizontalLine self) -> double"""
        return _libBornAgainDevice.HorizontalLine_getYpos(self)
    __swig_destroy__ = _libBornAgainDevice.delete_HorizontalLine

# Register HorizontalLine in _libBornAgainDevice:
_libBornAgainDevice.HorizontalLine_swigregister(HorizontalLine)
class Polygon(IShape2D):
    r"""Proxy of C++ Polygon 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__(Polygon self, vdouble1d_t x, vdouble1d_t y) -> Polygon
        __init__(Polygon self, vector_pvacuum_double_t points) -> Polygon
        __init__(Polygon self, PolygonPrivate const * d) -> Polygon
        """
        _libBornAgainDevice.Polygon_swiginit(self, _libBornAgainDevice.new_Polygon(*args))
    __swig_destroy__ = _libBornAgainDevice.delete_Polygon

    def clone(self):
        r"""clone(Polygon self) -> Polygon"""
        return _libBornAgainDevice.Polygon_clone(self)

    def contains(self, *args):
        r"""
        contains(Polygon self, double x, double y) -> bool
        contains(Polygon self, Bin1D const & binx, Bin1D const & biny) -> bool
        """
        return _libBornAgainDevice.Polygon_contains(self, *args)

    def getArea(self):
        r"""getArea(Polygon self) -> double"""
        return _libBornAgainDevice.Polygon_getArea(self)

    def getPoints(self, xpos, ypos):
        r"""getPoints(Polygon self, vdouble1d_t xpos, vdouble1d_t ypos)"""
        return _libBornAgainDevice.Polygon_getPoints(self, xpos, ypos)

# Register Polygon in _libBornAgainDevice:
_libBornAgainDevice.Polygon_swigregister(Polygon)
class Rectangle(IShape2D):
    r"""Proxy of C++ Rectangle 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, xlow, ylow, xup, yup, inverted=False):
        r"""__init__(Rectangle self, double xlow, double ylow, double xup, double yup, bool inverted=False) -> Rectangle"""
        _libBornAgainDevice.Rectangle_swiginit(self, _libBornAgainDevice.new_Rectangle(xlow, ylow, xup, yup, inverted))

    def clone(self):
        r"""clone(Rectangle self) -> Rectangle"""
        return _libBornAgainDevice.Rectangle_clone(self)

    def setInverted(self, inverted=True):
        r"""setInverted(Rectangle self, bool inverted=True)"""
        return _libBornAgainDevice.Rectangle_setInverted(self, inverted)

    def contains(self, *args):
        r"""
        contains(Rectangle self, double x, double y) -> bool
        contains(Rectangle self, Bin1D const & binx, Bin1D const & biny) -> bool
        """
        return _libBornAgainDevice.Rectangle_contains(self, *args)

    def getArea(self):
        r"""getArea(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_getArea(self)

    def getXlow(self):
        r"""getXlow(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_getXlow(self)

    def getYlow(self):
        r"""getYlow(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_getYlow(self)

    def getXup(self):
        r"""getXup(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_getXup(self)

    def getYup(self):
        r"""getYup(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_getYup(self)
    __swig_destroy__ = _libBornAgainDevice.delete_Rectangle

# Register Rectangle in _libBornAgainDevice:
_libBornAgainDevice.Rectangle_swigregister(Rectangle)
class IDetectorResolution(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""Proxy of C++ IDetectorResolution 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__ = _libBornAgainDevice.delete_IDetectorResolution

    def clone(self):
        r"""clone(IDetectorResolution self) -> IDetectorResolution"""
        return _libBornAgainDevice.IDetectorResolution_clone(self)

    def applyDetectorResolution(self, p_intensity_map):
        r"""applyDetectorResolution(IDetectorResolution self, Datafield p_intensity_map)"""
        return _libBornAgainDevice.IDetectorResolution_applyDetectorResolution(self, p_intensity_map)

# Register IDetectorResolution in _libBornAgainDevice:
_libBornAgainDevice.IDetectorResolution_swigregister(IDetectorResolution)
class IResolutionFunction2D(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""Proxy of C++ IResolutionFunction2D 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__ = _libBornAgainDevice.delete_IResolutionFunction2D

    def evaluateCDF(self, x, y):
        r"""evaluateCDF(IResolutionFunction2D self, double x, double y) -> double"""
        return _libBornAgainDevice.IResolutionFunction2D_evaluateCDF(self, x, y)

    def clone(self):
        r"""clone(IResolutionFunction2D self) -> IResolutionFunction2D"""
        return _libBornAgainDevice.IResolutionFunction2D_clone(self)

# Register IResolutionFunction2D in _libBornAgainDevice:
_libBornAgainDevice.IResolutionFunction2D_swigregister(IResolutionFunction2D)
class ResolutionFunction2DGaussian(IResolutionFunction2D):
    r"""Proxy of C++ ResolutionFunction2DGaussian 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, sigma_x, sigma_y):
        r"""__init__(ResolutionFunction2DGaussian self, double sigma_x, double sigma_y) -> ResolutionFunction2DGaussian"""
        _libBornAgainDevice.ResolutionFunction2DGaussian_swiginit(self, _libBornAgainDevice.new_ResolutionFunction2DGaussian(sigma_x, sigma_y))

    def clone(self):
        r"""clone(ResolutionFunction2DGaussian self) -> ResolutionFunction2DGaussian"""
        return _libBornAgainDevice.ResolutionFunction2DGaussian_clone(self)

    def className(self):
        r"""className(ResolutionFunction2DGaussian self) -> std::string"""
        return _libBornAgainDevice.ResolutionFunction2DGaussian_className(self)

    def parDefs(self):
        r"""parDefs(ResolutionFunction2DGaussian self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainDevice.ResolutionFunction2DGaussian_parDefs(self)

    def evaluateCDF(self, x, y):
        r"""evaluateCDF(ResolutionFunction2DGaussian self, double x, double y) -> double"""
        return _libBornAgainDevice.ResolutionFunction2DGaussian_evaluateCDF(self, x, y)

    def sigmaX(self):
        r"""sigmaX(ResolutionFunction2DGaussian self) -> double"""
        return _libBornAgainDevice.ResolutionFunction2DGaussian_sigmaX(self)

    def sigmaY(self):
        r"""sigmaY(ResolutionFunction2DGaussian self) -> double"""
        return _libBornAgainDevice.ResolutionFunction2DGaussian_sigmaY(self)

    def validate(self):
        r"""validate(ResolutionFunction2DGaussian self) -> std::string"""
        return _libBornAgainDevice.ResolutionFunction2DGaussian_validate(self)
    __swig_destroy__ = _libBornAgainDevice.delete_ResolutionFunction2DGaussian

# Register ResolutionFunction2DGaussian in _libBornAgainDevice:
_libBornAgainDevice.ResolutionFunction2DGaussian_swigregister(ResolutionFunction2DGaussian)
Coords_UNDEFINED = _libBornAgainDevice.Coords_UNDEFINED

Coords_NBINS = _libBornAgainDevice.Coords_NBINS

Coords_RADIANS = _libBornAgainDevice.Coords_RADIANS

Coords_DEGREES = _libBornAgainDevice.Coords_DEGREES

Coords_MM = _libBornAgainDevice.Coords_MM

Coords_QSPACE = _libBornAgainDevice.Coords_QSPACE

class MaskPattern(object):
    r"""Proxy of C++ MaskPattern 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, shape_, doMask_):
        r"""__init__(MaskPattern self, IShape2D shape_, bool doMask_) -> MaskPattern"""
        _libBornAgainDevice.MaskPattern_swiginit(self, _libBornAgainDevice.new_MaskPattern(shape_, doMask_))
    __swig_destroy__ = _libBornAgainDevice.delete_MaskPattern

    def clone(self):
        r"""clone(MaskPattern self) -> MaskPattern"""
        return _libBornAgainDevice.MaskPattern_clone(self)
    shape = property(_libBornAgainDevice.MaskPattern_shape_get, _libBornAgainDevice.MaskPattern_shape_set, doc=r"""shape : p.IShape2D""")
    doMask = property(_libBornAgainDevice.MaskPattern_doMask_get, _libBornAgainDevice.MaskPattern_doMask_set, doc=r"""doMask : bool""")

# Register MaskPattern in _libBornAgainDevice:
_libBornAgainDevice.MaskPattern_swigregister(MaskPattern)
class DetectorMask(object):
    r"""Proxy of C++ DetectorMask class."""

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

    def __init__(self, *args):
        r"""
        __init__(DetectorMask self, Scale xAxis, Scale yAxis) -> DetectorMask
        __init__(DetectorMask self, DetectorMask other) -> DetectorMask
        """
        _libBornAgainDevice.DetectorMask_swiginit(self, _libBornAgainDevice.new_DetectorMask(*args))

    def addMask(self, shape, mask_value):
        r"""addMask(DetectorMask self, IShape2D shape, bool mask_value)"""
        return _libBornAgainDevice.DetectorMask_addMask(self, shape, mask_value)

    def isMasked(self, i_flat):
        r"""isMasked(DetectorMask self, size_t i_flat) -> bool"""
        return _libBornAgainDevice.DetectorMask_isMasked(self, i_flat)

    def hasMasks(self):
        r"""hasMasks(DetectorMask self) -> bool"""
        return _libBornAgainDevice.DetectorMask_hasMasks(self)

    def numberOfMaskedChannels(self):
        r"""numberOfMaskedChannels(DetectorMask self) -> int"""
        return _libBornAgainDevice.DetectorMask_numberOfMaskedChannels(self)

    def numberOfMasks(self):
        r"""numberOfMasks(DetectorMask self) -> size_t"""
        return _libBornAgainDevice.DetectorMask_numberOfMasks(self)

    def patternAt(self, iMask):
        r"""patternAt(DetectorMask self, size_t iMask) -> MaskPattern"""
        return _libBornAgainDevice.DetectorMask_patternAt(self, iMask)

# Register DetectorMask in _libBornAgainDevice:
_libBornAgainDevice.DetectorMask_swigregister(DetectorMask)
class IDetector(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""Proxy of C++ IDetector 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

    def clone(self):
        r"""clone(IDetector self) -> IDetector"""
        return _libBornAgainDevice.IDetector_clone(self)
    __swig_destroy__ = _libBornAgainDevice.delete_IDetector

    def setDetectorNormal(self, arg2):
        r"""setDetectorNormal(IDetector self, R3 arg2)"""
        return _libBornAgainDevice.IDetector_setDetectorNormal(self, arg2)

    def setAnalyzer(self, *args):
        r"""
        setAnalyzer(IDetector self, R3 Bloch_vector={}, double mean_transmission=0.5)
        setAnalyzer(IDetector self, R3 direction, double efficiency, double transmission)
        """
        return _libBornAgainDevice.IDetector_setAnalyzer(self, *args)

    def setDetectorResolution(self, detector_resolution):
        r"""setDetectorResolution(IDetector self, IDetectorResolution detector_resolution)"""
        return _libBornAgainDevice.IDetector_setDetectorResolution(self, detector_resolution)

    def setResolutionFunction(self, resFunc):
        r"""setResolutionFunction(IDetector self, IResolutionFunction2D resFunc)"""
        return _libBornAgainDevice.IDetector_setResolutionFunction(self, resFunc)

    def nodeChildren(self):
        r"""nodeChildren(IDetector self) -> std::vector< INode const *,std::allocator< INode const * > >"""
        return _libBornAgainDevice.IDetector_nodeChildren(self)

    def iterateOverNonMaskedPoints(self, func):
        r"""iterateOverNonMaskedPoints(IDetector self, std::function< void (IDetector::const_iterator) > func)"""
        return _libBornAgainDevice.IDetector_iterateOverNonMaskedPoints(self, func)

    def detectorMask(self):
        r"""detectorMask(IDetector self) -> DetectorMask"""
        return _libBornAgainDevice.IDetector_detectorMask(self)

    def addMask(self, shape, mask_value=True):
        r"""addMask(IDetector self, IShape2D shape, bool mask_value=True)"""
        return _libBornAgainDevice.IDetector_addMask(self, shape, mask_value)

    def maskAll(self):
        r"""maskAll(IDetector self)"""
        return _libBornAgainDevice.IDetector_maskAll(self)

    def setRegionOfInterest(self, xlow, ylow, xup, yup):
        r"""setRegionOfInterest(IDetector self, double xlow, double ylow, double xup, double yup)"""
        return _libBornAgainDevice.IDetector_setRegionOfInterest(self, xlow, ylow, xup, yup)

    def scatteringCoords(self, beam):
        r"""scatteringCoords(IDetector self, Beam beam) -> CoordSystem2D const *"""
        return _libBornAgainDevice.IDetector_scatteringCoords(self, beam)

    def active_indices(self):
        r"""active_indices(IDetector self) -> std::vector< size_t,std::allocator< size_t > >"""
        return _libBornAgainDevice.IDetector_active_indices(self)

    def createPixel(self, i):
        r"""createPixel(IDetector self, size_t i) -> IPixel const *"""
        return _libBornAgainDevice.IDetector_createPixel(self, i)

    def indexOfSpecular(self, beam):
        r"""indexOfSpecular(IDetector self, Beam beam) -> size_t"""
        return _libBornAgainDevice.IDetector_indexOfSpecular(self, beam)

    def axis(self, i):
        r"""axis(IDetector self, size_t i) -> Scale"""
        return _libBornAgainDevice.IDetector_axis(self, i)

    def axisBinIndex(self, i, selected_axis):
        r"""axisBinIndex(IDetector self, size_t i, size_t selected_axis) -> size_t"""
        return _libBornAgainDevice.IDetector_axisBinIndex(self, i, selected_axis)

    def totalSize(self):
        r"""totalSize(IDetector self) -> size_t"""
        return _libBornAgainDevice.IDetector_totalSize(self)

    def sizeOfRegionOfInterest(self):
        r"""sizeOfRegionOfInterest(IDetector self) -> size_t"""
        return _libBornAgainDevice.IDetector_sizeOfRegionOfInterest(self)

    def hasExplicitRegionOfInterest(self):
        r"""hasExplicitRegionOfInterest(IDetector self) -> bool"""
        return _libBornAgainDevice.IDetector_hasExplicitRegionOfInterest(self)

    def axesClippedToRegionOfInterest(self):
        r"""axesClippedToRegionOfInterest(IDetector self) -> std::vector< Scale const *,std::allocator< Scale const * > >"""
        return _libBornAgainDevice.IDetector_axesClippedToRegionOfInterest(self)

    def regionOfInterestIndexToDetectorIndex(self, i):
        r"""regionOfInterestIndexToDetectorIndex(IDetector self, size_t i) -> size_t"""
        return _libBornAgainDevice.IDetector_regionOfInterestIndexToDetectorIndex(self, i)

    def applyDetectorResolution(self, intensity_map):
        r"""applyDetectorResolution(IDetector self, Datafield intensity_map)"""
        return _libBornAgainDevice.IDetector_applyDetectorResolution(self, intensity_map)

    def detectorResolution(self):
        r"""detectorResolution(IDetector self) -> IDetectorResolution"""
        return _libBornAgainDevice.IDetector_detectorResolution(self)

    def defaultCoords(self):
        r"""defaultCoords(IDetector self) -> Coords"""
        return _libBornAgainDevice.IDetector_defaultCoords(self)

    def regionOfInterestBounds(self, iAxis):
        r"""regionOfInterestBounds(IDetector self, size_t iAxis) -> pvacuum_double_t"""
        return _libBornAgainDevice.IDetector_regionOfInterestBounds(self, iAxis)

# Register IDetector in _libBornAgainDevice:
_libBornAgainDevice.IDetector_swigregister(IDetector)
class RectangularDetector(IDetector):
    r"""Proxy of C++ RectangularDetector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    GENERIC = _libBornAgainDevice.RectangularDetector_GENERIC
    
    PERPENDICULAR_TO_SAMPLE = _libBornAgainDevice.RectangularDetector_PERPENDICULAR_TO_SAMPLE
    
    PERPENDICULAR_TO_DIRECT_BEAM = _libBornAgainDevice.RectangularDetector_PERPENDICULAR_TO_DIRECT_BEAM
    
    PERPENDICULAR_TO_REFLECTED_BEAM = _libBornAgainDevice.RectangularDetector_PERPENDICULAR_TO_REFLECTED_BEAM
    

    def __init__(self, *args):
        r"""
        __init__(RectangularDetector self, std::array< std::shared_ptr< Scale >,2 > axes) -> RectangularDetector
        __init__(RectangularDetector self, size_t nxbins, double width, size_t nybins, double height) -> RectangularDetector
        __init__(RectangularDetector self, RectangularDetector other) -> RectangularDetector
        """
        _libBornAgainDevice.RectangularDetector_swiginit(self, _libBornAgainDevice.new_RectangularDetector(*args))
    __swig_destroy__ = _libBornAgainDevice.delete_RectangularDetector

    def clone(self):
        r"""clone(RectangularDetector self) -> RectangularDetector"""
        return _libBornAgainDevice.RectangularDetector_clone(self)

    def className(self):
        r"""className(RectangularDetector self) -> std::string"""
        return _libBornAgainDevice.RectangularDetector_className(self)

    def setDetectorNormal(self, k):
        r"""setDetectorNormal(RectangularDetector self, R3 k)"""
        return _libBornAgainDevice.RectangularDetector_setDetectorNormal(self, k)

    def setDetectorPosition(self, *args):
        r"""setDetectorPosition(RectangularDetector self, R3 normal_to_detector, double u0, double v0, R3 direction=R3(0.0, -1.0, 0.0))"""
        return _libBornAgainDevice.RectangularDetector_setDetectorPosition(self, *args)

    def setPerpendicularToSampleX(self, distance, u0, v0):
        r"""setPerpendicularToSampleX(RectangularDetector self, double distance, double u0, double v0)"""
        return _libBornAgainDevice.RectangularDetector_setPerpendicularToSampleX(self, distance, u0, v0)

    def setPerpendicularToDirectBeam(self, distance, u0, v0):
        r"""setPerpendicularToDirectBeam(RectangularDetector self, double distance, double u0, double v0)"""
        return _libBornAgainDevice.RectangularDetector_setPerpendicularToDirectBeam(self, distance, u0, v0)

    def setPerpendicularToReflectedBeam(self, distance, u0=0.0, v0=0.0):
        r"""setPerpendicularToReflectedBeam(RectangularDetector self, double distance, double u0=0.0, double v0=0.0)"""
        return _libBornAgainDevice.RectangularDetector_setPerpendicularToReflectedBeam(self, distance, u0, v0)

    def width(self):
        r"""width(RectangularDetector self) -> double"""
        return _libBornAgainDevice.RectangularDetector_width(self)

    def height(self):
        r"""height(RectangularDetector self) -> double"""
        return _libBornAgainDevice.RectangularDetector_height(self)

    def xSize(self):
        r"""xSize(RectangularDetector self) -> size_t"""
        return _libBornAgainDevice.RectangularDetector_xSize(self)

    def ySize(self):
        r"""ySize(RectangularDetector self) -> size_t"""
        return _libBornAgainDevice.RectangularDetector_ySize(self)

    def getNormalVector(self):
        r"""getNormalVector(RectangularDetector self) -> R3"""
        return _libBornAgainDevice.RectangularDetector_getNormalVector(self)

    def getU0(self):
        r"""getU0(RectangularDetector self) -> double"""
        return _libBornAgainDevice.RectangularDetector_getU0(self)

    def getV0(self):
        r"""getV0(RectangularDetector self) -> double"""
        return _libBornAgainDevice.RectangularDetector_getV0(self)

    def getDirectionVector(self):
        r"""getDirectionVector(RectangularDetector self) -> R3"""
        return _libBornAgainDevice.RectangularDetector_getDirectionVector(self)

    def getDistance(self):
        r"""getDistance(RectangularDetector self) -> double"""
        return _libBornAgainDevice.RectangularDetector_getDistance(self)

    def getDirectBeamU0(self):
        r"""getDirectBeamU0(RectangularDetector self) -> double"""
        return _libBornAgainDevice.RectangularDetector_getDirectBeamU0(self)

    def getDirectBeamV0(self):
        r"""getDirectBeamV0(RectangularDetector self) -> double"""
        return _libBornAgainDevice.RectangularDetector_getDirectBeamV0(self)

    def getDetectorArrangment(self):
        r"""getDetectorArrangment(RectangularDetector self) -> RectangularDetector::EDetectorArrangement"""
        return _libBornAgainDevice.RectangularDetector_getDetectorArrangment(self)

    def defaultCoords(self):
        r"""defaultCoords(RectangularDetector self) -> Coords"""
        return _libBornAgainDevice.RectangularDetector_defaultCoords(self)

    def regionOfInterestPixel(self):
        r"""regionOfInterestPixel(RectangularDetector self) -> RectangularPixel const *"""
        return _libBornAgainDevice.RectangularDetector_regionOfInterestPixel(self)

    def scatteringCoords(self, beam):
        r"""scatteringCoords(RectangularDetector self, Beam beam) -> CoordSystem2D const *"""
        return _libBornAgainDevice.RectangularDetector_scatteringCoords(self, beam)

# Register RectangularDetector in _libBornAgainDevice:
_libBornAgainDevice.RectangularDetector_swigregister(RectangularDetector)
class OffspecDetector(libBornAgainParam.INode):
    r"""Proxy of C++ OffspecDetector 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__(OffspecDetector self, size_t n_phi, double phi_min, double phi_max, size_t n_alpha, double alpha_min, double alpha_max) -> OffspecDetector
        __init__(OffspecDetector self, OffspecDetector other) -> OffspecDetector
        """
        _libBornAgainDevice.OffspecDetector_swiginit(self, _libBornAgainDevice.new_OffspecDetector(*args))
    __swig_destroy__ = _libBornAgainDevice.delete_OffspecDetector

    def clone(self):
        r"""clone(OffspecDetector self) -> OffspecDetector"""
        return _libBornAgainDevice.OffspecDetector_clone(self)

    def className(self):
        r"""className(OffspecDetector self) -> std::string"""
        return _libBornAgainDevice.OffspecDetector_className(self)

    def setAnalyzer(self, *args):
        r"""
        setAnalyzer(OffspecDetector self, R3 Bloch_vector={}, double mean_transmission=0.5)
        setAnalyzer(OffspecDetector self, R3 direction, double efficiency, double transmission)
        """
        return _libBornAgainDevice.OffspecDetector_setAnalyzer(self, *args)

    def axis(self, index):
        r"""axis(OffspecDetector self, size_t index) -> Scale"""
        return _libBornAgainDevice.OffspecDetector_axis(self, index)

    def axisBinIndex(self, index, selected_axis):
        r"""axisBinIndex(OffspecDetector self, size_t index, size_t selected_axis) -> size_t"""
        return _libBornAgainDevice.OffspecDetector_axisBinIndex(self, index, selected_axis)

    def totalSize(self):
        r"""totalSize(OffspecDetector self) -> size_t"""
        return _libBornAgainDevice.OffspecDetector_totalSize(self)

    def defaultCoords(self):
        r"""defaultCoords(OffspecDetector self) -> Coords"""
        return _libBornAgainDevice.OffspecDetector_defaultCoords(self)

    def createPixel(self, index):
        r"""createPixel(OffspecDetector self, size_t index) -> IPixel *"""
        return _libBornAgainDevice.OffspecDetector_createPixel(self, index)

    def indexOfSpecular(self, alpha, phi):
        r"""indexOfSpecular(OffspecDetector self, double alpha, double phi) -> size_t"""
        return _libBornAgainDevice.OffspecDetector_indexOfSpecular(self, alpha, phi)

    def analyzer(self):
        r"""analyzer(OffspecDetector self) -> PolFilter const &"""
        return _libBornAgainDevice.OffspecDetector_analyzer(self)

# Register OffspecDetector in _libBornAgainDevice:
_libBornAgainDevice.OffspecDetector_swigregister(OffspecDetector)
class SphericalDetector(IDetector):
    r"""Proxy of C++ SphericalDetector 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__(SphericalDetector self, std::array< std::shared_ptr< Scale >,2 > axes) -> SphericalDetector
        __init__(SphericalDetector self, size_t n_phi, double phi_min, double phi_max, size_t n_alpha, double alpha_min, double alpha_max) -> SphericalDetector
        __init__(SphericalDetector self, size_t n_bin, double width, double phi, double alpha) -> SphericalDetector
        __init__(SphericalDetector self, SphericalDetector other) -> SphericalDetector
        """
        _libBornAgainDevice.SphericalDetector_swiginit(self, _libBornAgainDevice.new_SphericalDetector(*args))
    __swig_destroy__ = _libBornAgainDevice.delete_SphericalDetector

    def clone(self):
        r"""clone(SphericalDetector self) -> SphericalDetector"""
        return _libBornAgainDevice.SphericalDetector_clone(self)

    def className(self):
        r"""className(SphericalDetector self) -> std::string"""
        return _libBornAgainDevice.SphericalDetector_className(self)

    def defaultCoords(self):
        r"""defaultCoords(SphericalDetector self) -> Coords"""
        return _libBornAgainDevice.SphericalDetector_defaultCoords(self)

    def scatteringCoords(self, beam):
        r"""scatteringCoords(SphericalDetector self, Beam beam) -> CoordSystem2D const *"""
        return _libBornAgainDevice.SphericalDetector_scatteringCoords(self, beam)

    def createPixel(self, index):
        r"""createPixel(SphericalDetector self, size_t index) -> IPixel *"""
        return _libBornAgainDevice.SphericalDetector_createPixel(self, index)

    def indexOfSpecular(self, beam):
        r"""indexOfSpecular(SphericalDetector self, Beam beam) -> size_t"""
        return _libBornAgainDevice.SphericalDetector_indexOfSpecular(self, beam)

# Register SphericalDetector in _libBornAgainDevice:
_libBornAgainDevice.SphericalDetector_swigregister(SphericalDetector)
unknown1D = _libBornAgainDevice.unknown1D

csv1D = _libBornAgainDevice.csv1D

csv1D_2cols = _libBornAgainDevice.csv1D_2cols

csv1D_3cols = _libBornAgainDevice.csv1D_3cols

csv1D_4cols = _libBornAgainDevice.csv1D_4cols

csv1D_5cols = _libBornAgainDevice.csv1D_5cols

bornagain1D = _libBornAgainDevice.bornagain1D

mft = _libBornAgainDevice.mft

unknown2D = _libBornAgainDevice.unknown2D

csv2D = _libBornAgainDevice.csv2D

bornagain2D = _libBornAgainDevice.bornagain2D

tiff = _libBornAgainDevice.tiff

nicos2D = _libBornAgainDevice.nicos2D

refsans2D = _libBornAgainDevice.refsans2D


def readData1D(*args):
    r"""readData1D(std::string const & file_name, IO::Filetype1D ftype=unknown1D, ImportSettings1D const * importSettings=None) -> Datafield"""
    return _libBornAgainDevice.readData1D(*args)

def readData2D(*args):
    r"""readData2D(std::string const & file_name, IO::Filetype2D ftype=unknown2D) -> Datafield"""
    return _libBornAgainDevice.readData2D(*args)

def writeDatafield(data, file_name):
    r"""writeDatafield(Datafield data, std::string const & file_name)"""
    return _libBornAgainDevice.writeDatafield(data, file_name)

def dataMatchesFile(data, refFileName, tol):
    r"""dataMatchesFile(Datafield data, std::string const & refFileName, double tol) -> bool"""
    return _libBornAgainDevice.dataMatchesFile(data, refFileName, tol)
class SimulationResult(Datafield):
    r"""Proxy of C++ SimulationResult 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__(SimulationResult self) -> SimulationResult
        __init__(SimulationResult self, Datafield data, ICoordSystem const * coords) -> SimulationResult
        __init__(SimulationResult self, SimulationResult other) -> SimulationResult
        __init__(SimulationResult self, SimulationResult other) -> SimulationResult
        """
        _libBornAgainDevice.SimulationResult_swiginit(self, _libBornAgainDevice.new_SimulationResult(*args))
    __swig_destroy__ = _libBornAgainDevice.delete_SimulationResult

    def extracted_field(self):
        r"""extracted_field(SimulationResult self) -> Datafield"""
        return _libBornAgainDevice.SimulationResult_extracted_field(self)

    def axisMinMax(self, *args):
        r"""axisMinMax(SimulationResult self, size_t i, Coords units=UNDEFINED) -> pvacuum_double_t"""
        return _libBornAgainDevice.SimulationResult_axisMinMax(self, *args)

    def name_of_axis(self, *args):
        r"""name_of_axis(SimulationResult self, size_t i, Coords units=UNDEFINED) -> std::string"""
        return _libBornAgainDevice.SimulationResult_name_of_axis(self, *args)

    def array(self, *args):
        r"""array(SimulationResult self, Coords units=UNDEFINED) -> PyObject"""
        return _libBornAgainDevice.SimulationResult_array(self, *args)

    def convertedBinCenters(self, *args):
        r"""
        convertedBinCenters(SimulationResult self, Coords units=UNDEFINED) -> vdouble1d_t
        convertedBinCenters(SimulationResult self, size_t i_axis, Coords units=UNDEFINED) -> vdouble1d_t
        """
        return _libBornAgainDevice.SimulationResult_convertedBinCenters(self, *args)

    def setTitle(self, title):
        r"""setTitle(SimulationResult self, std::string const & title)"""
        return _libBornAgainDevice.SimulationResult_setTitle(self, title)

    def title(self):
        r"""title(SimulationResult self) -> std::string"""
        return _libBornAgainDevice.SimulationResult_title(self)

# Register SimulationResult in _libBornAgainDevice:
_libBornAgainDevice.SimulationResult_swigregister(SimulationResult)
