# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.1
#
# 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__)


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)

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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vdouble1d_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble1d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_T v)
        __setitem__(vdouble1d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vdouble2d_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_T v)
        __setitem__(vdouble2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vector_integer_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_integer_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_integer_T v)
        __setitem__(vector_integer_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vinteger2d_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_T v)
        __setitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vector_longinteger_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_longinteger_T v)
        __setitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vector_complex_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_complex_T v)
        __setitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vector_string_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_string_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_string_T v)
        __setitem__(vector_string_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainDevice.vector_pvacuum_double_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * 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, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_T v)
        __setitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * 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 libBornAgainBase
class Coordinate(object):
    r""" Defines class Coordinate. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2023 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) A name and a unit."""

    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__(Coordinate self, char const * label) -> Coordinate
        __init__(Coordinate self, std::string const & label) -> Coordinate
        __init__(Coordinate self, std::string name, std::string unit) -> Coordinate
        """
        _libBornAgainDevice.Coordinate_swiginit(self, _libBornAgainDevice.new_Coordinate(*args))

    def name(self):
        r"""name(Coordinate self) -> std::string const &"""
        return _libBornAgainDevice.Coordinate_name(self)

    def unit(self):
        r"""unit(Coordinate self) -> std::string const &"""
        return _libBornAgainDevice.Coordinate_unit(self)

    def label(self):
        r"""label(Coordinate self) -> std::string"""
        return _libBornAgainDevice.Coordinate_label(self)
    __swig_destroy__ = _libBornAgainDevice.delete_Coordinate

# Register Coordinate in _libBornAgainDevice:
_libBornAgainDevice.Coordinate_swigregister(Coordinate)
class Datafield(object):
    r""" Stores one- or two-dimensional data with associated scales."""

    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, std::string title, Frame frame, vdouble1d_T values, vdouble1d_T errSigmas={}) -> Datafield
        __init__(Datafield self, std::string const & title, Frame frame) -> Datafield
        __init__(Datafield self, Frame frame, vdouble1d_T values, vdouble1d_T errSigmas={}) -> Datafield
        __init__(Datafield self, Frame frame) -> Datafield
        __init__(Datafield self, std::string const & xlabel, std::string const & ylabel, double2d_t const & vec) -> Datafield
        __init__(Datafield self, Datafield arg2) -> Datafield
        """
        _libBornAgainDevice.Datafield_swiginit(self, _libBornAgainDevice.new_Datafield(*args))
    __swig_destroy__ = _libBornAgainDevice.delete_Datafield

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

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

    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 title(self):
        r"""title(Datafield self) -> std::string"""
        return _libBornAgainDevice.Datafield_title(self)

    def size(self):
        r""" Returns total size of data buffer (product of bin number in every dimension)."""
        return _libBornAgainDevice.Datafield_size(self)

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

    def flatVector(self):
        r""" Returns reference to the flat data."""
        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 valAt(self, i):
        r"""valAt(Datafield self, size_t i) -> double"""
        return _libBornAgainDevice.Datafield_valAt(self, i)

    def xCenters(self, *args):
        _arrayf64Wrapper = _libBornAgainDevice.Datafield_xCenters(self, *args)
        return _arrayf64Wrapper.to_numpy()



    def yCenters(self, *args):
        _arrayf64Wrapper = _libBornAgainDevice.Datafield_yCenters(self, *args)
        return _arrayf64Wrapper.to_numpy()



    def intensities(self, *args):
        _arrayf64Wrapper = _libBornAgainDevice.Datafield_intensities(self, *args)  # call the original SWIG-generated method
        return _arrayf64Wrapper.to_numpy()



    def errors(self, *args):
        _arrayf64Wrapper = _libBornAgainDevice.Datafield_errors(self, *args)
        return _arrayf64Wrapper.to_numpy()



    def plottableField(self):
        r"""plottableField(Datafield self) -> Datafield"""
        return _libBornAgainDevice.Datafield_plottableField(self)

    def flat(self):
        r"""flat(Datafield self) -> Datafield"""
        return _libBornAgainDevice.Datafield_flat(self)

    def noisy(self, prefactor, minimum):
        r"""noisy(Datafield self, double prefactor, double minimum) -> Datafield"""
        return _libBornAgainDevice.Datafield_noisy(self, prefactor, minimum)

    def normalizedToMax(self):
        r"""normalizedToMax(Datafield self) -> Datafield"""
        return _libBornAgainDevice.Datafield_normalizedToMax(self)

    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 xProjection(self, *args):
        r"""
        *Overload 1:*
         Project a 2D histogram into 1D histogram along X. The projection is made from all bins along y-axis.

        |

        *Overload 2:*
         Project a 2D histogram into 1D histogram along X. The projection is made from the y-bin closest to given ordinate yvalue. :type yvalue: float
        :param yvalue: the value on y-axis at which projection is taken

        |

        *Overload 3:*
         Project a 2D histogram into 1D histogram along X. The projection is made from all y-bins corresponding to ordinate between ylow and yup. :type ylow: float
        :param ylow: lower edje on y-axis :type yup: float
        :param yup: upper edje on y-axis
        """
        return _libBornAgainDevice.Datafield_xProjection(self, *args)

    def yProjection(self, *args):
        r"""
        *Overload 1:*
         Project a 2D histogram into 1D histogram along Y. The projection is made from all bins along x-axis.

        |

        *Overload 2:*
         Project a 2D histogram into 1D histogram along Y. The projection is made from the x-bin closest to given abscissa xvalue. :type xvalue: float
        :param xvalue: the value on x-axis at which projection is taken

        |

        *Overload 3:*
         Project a 2D histogram into 1D histogram along Y. The projection is made from all x-bins corresponding to abscissa between xlow and xup. :type xlow: float
        :param xlow: lower edje on x-axis :type xup: float
        :param xup: upper edje on x-axis
        """
        return _libBornAgainDevice.Datafield_yProjection(self, *args)

    def setAllTo(self, value):
        r""" Sets content of output data to specific value."""
        return _libBornAgainDevice.Datafield_setAllTo(self, value)

    def errorSigmas(self):
        r"""errorSigmas(Datafield self) -> vdouble1d_T"""
        return _libBornAgainDevice.Datafield_errorSigmas(self)

# Register Datafield in _libBornAgainDevice:
_libBornAgainDevice.Datafield_swigregister(Datafield)
class Transformer(object):
    r""" A stub. To be generalized as need arises."""

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

    def __init__(self, wavelength, alpha_i, phi_i):
        r"""__init__(Transformer self, double wavelength, double alpha_i, double phi_i) -> Transformer"""
        _libBornAgainDevice.Transformer_swiginit(self, _libBornAgainDevice.new_Transformer(wavelength, alpha_i, phi_i))

    def transformedDatafield(self, df):
        r"""transformedDatafield(Transformer self, Datafield df) -> Datafield"""
        return _libBornAgainDevice.Transformer_transformedDatafield(self, df)
    __swig_destroy__ = _libBornAgainDevice.delete_Transformer

# Register Transformer in _libBornAgainDevice:
_libBornAgainDevice.Transformer_swigregister(Transformer)
class FrameTrafo(object):
    r""" Collection of factory functions that return coordinate-frame transformers. As this class only contains static functions, it better were a namespace. However, a class is easier to expose to Swig."""

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

    @staticmethod
    def ScatteringToQ(wavelength, alpha_i, phi_i=0):
        r"""ScatteringToQ(double wavelength, double alpha_i, double phi_i=0) -> Transformer"""
        return _libBornAgainDevice.FrameTrafo_ScatteringToQ(wavelength, alpha_i, phi_i)

    @staticmethod
    def Transpose(df):
        r"""Transpose(Datafield df) -> Datafield"""
        return _libBornAgainDevice.FrameTrafo_Transpose(df)

    def __init__(self):
        r"""__init__(FrameTrafo self) -> FrameTrafo"""
        _libBornAgainDevice.FrameTrafo_swiginit(self, _libBornAgainDevice.new_FrameTrafo())
    __swig_destroy__ = _libBornAgainDevice.delete_FrameTrafo

# Register FrameTrafo in _libBornAgainDevice:
_libBornAgainDevice.FrameTrafo_swigregister(FrameTrafo)
class Beam(object):
    r""" An incident neutron or x-ray beam."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    minGrazingAngle = _libBornAgainDevice.Beam_minGrazingAngle
    r""" Minimum grazing angle magnitude to prevent ill-defined physics near zero"""

    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 setFootprint(self, shape_factor):
        r"""setFootprint(Beam self, Footprint shape_factor)"""
        return _libBornAgainDevice.Beam_setFootprint(self, shape_factor)

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

# Register Beam in _libBornAgainDevice:
_libBornAgainDevice.Beam_swigregister(Beam)
class Footprint(object):
    r""" Defines interface Footprint. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) Abstract base for classes that calculate the beam footprint factor"""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainDevice.delete_Footprint

# Register Footprint in _libBornAgainDevice:
_libBornAgainDevice.Footprint_swigregister(Footprint)
class FootprintGauss(Footprint):
    r""" Defines class FootprintGauss. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) Gaussian beam footprint. Beam width is the full width at half maximum."""

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

    def __init__(self, width_ratio):
        r"""__init__(FootprintGauss self, double width_ratio) -> FootprintGauss"""
        _libBornAgainDevice.FootprintGauss_swiginit(self, _libBornAgainDevice.new_FootprintGauss(width_ratio))

    def calculate(self, alpha):
        r""" Calculate footprint correction coefficient from the beam incident angle _alpha_."""
        return _libBornAgainDevice.FootprintGauss_calculate(self, alpha)
    __swig_destroy__ = _libBornAgainDevice.delete_FootprintGauss

# Register FootprintGauss in _libBornAgainDevice:
_libBornAgainDevice.FootprintGauss_swigregister(FootprintGauss)
class FootprintSquare(Footprint):
    r""" Defines class FootprintSquare. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) Rectangular beam footprint."""

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

    def __init__(self, width_ratio):
        r"""__init__(FootprintSquare self, double width_ratio) -> FootprintSquare"""
        _libBornAgainDevice.FootprintSquare_swiginit(self, _libBornAgainDevice.new_FootprintSquare(width_ratio))

    def calculate(self, alpha):
        r""" Calculate footprint correction coefficient from the beam incident angle _alpha_."""
        return _libBornAgainDevice.FootprintSquare_calculate(self, alpha)
    __swig_destroy__ = _libBornAgainDevice.delete_FootprintSquare

# Register FootprintSquare in _libBornAgainDevice:
_libBornAgainDevice.FootprintSquare_swigregister(FootprintSquare)
class Shape2D(object):
    r""" Abstract base class for all shapes in 2D."""

    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_Shape2D

    def contains(self, *args):
        r"""
        *Overload 1:*
        Returns true if point with given coordinates is inside or on border of the shape.

        |

        *Overload 2:*
        Returns true if area defined by two bins is inside or on border of polygon (more precisely, if mid point of two bins satisfy this condition).
        """
        return _libBornAgainDevice.Shape2D_contains(self, *args)

# Register Shape2D in _libBornAgainDevice:
_libBornAgainDevice.Shape2D_swigregister(Shape2D)
class Ellipse(Shape2D):
    r""" Defines class Rectangle. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) An ellipse, for use in detector masks."""

    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 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 centerX(self):
        r"""centerX(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_centerX(self)

    def centerY(self):
        r"""centerY(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_centerY(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 theta(self):
        r"""theta(Ellipse self) -> double"""
        return _libBornAgainDevice.Ellipse_theta(self)
    __swig_destroy__ = _libBornAgainDevice.delete_Ellipse

# Register Ellipse in _libBornAgainDevice:
_libBornAgainDevice.Ellipse_swigregister(Ellipse)
class Line(Shape2D):
    r""" Defines class Line. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) A line segment, for use in detector masks."""

    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 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(Shape2D):
    r""" An infinite vertical line."""

    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 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 xpos(self):
        r"""xpos(VerticalLine self) -> double"""
        return _libBornAgainDevice.VerticalLine_xpos(self)
    __swig_destroy__ = _libBornAgainDevice.delete_VerticalLine

# Register VerticalLine in _libBornAgainDevice:
_libBornAgainDevice.VerticalLine_swigregister(VerticalLine)
class HorizontalLine(Shape2D):
    r""" An infinite horizontal line."""

    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 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 ypos(self):
        r"""ypos(HorizontalLine self) -> double"""
        return _libBornAgainDevice.HorizontalLine_ypos(self)
    __swig_destroy__ = _libBornAgainDevice.delete_HorizontalLine

# Register HorizontalLine in _libBornAgainDevice:
_libBornAgainDevice.HorizontalLine_swigregister(HorizontalLine)
class Polygon(Shape2D):
    r""" A polygon, for use in detector masks. Polygon defined by two arrays with x and y coordinates of points. Sizes of arrays should coincide.  If polygon is unclosed (the last point doesn't repeat the first one), it will be closed automatically."""

    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, 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 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 area(self):
        r"""area(Polygon self) -> double"""
        return _libBornAgainDevice.Polygon_area(self)

    def points(self):
        r"""points(Polygon self) -> std::pair< std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > > >"""
        return _libBornAgainDevice.Polygon_points(self)

# Register Polygon in _libBornAgainDevice:
_libBornAgainDevice.Polygon_swigregister(Polygon)
class Rectangle(Shape2D):
    r""" Defines class Rectangle. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) A rectangle, for use in detector masks. Edges are along the coordinate axes."""

    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 setInverted(self, inverted):
        r"""setInverted(Rectangle self, bool inverted)"""
        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 area(self):
        r"""area(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_area(self)

    def xlow(self):
        r"""xlow(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_xlow(self)

    def ylow(self):
        r"""ylow(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_ylow(self)

    def xup(self):
        r"""xup(Rectangle self) -> double"""
        return _libBornAgainDevice.Rectangle_xup(self)

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

# Register Rectangle in _libBornAgainDevice:
_libBornAgainDevice.Rectangle_swigregister(Rectangle)
class DetectorResolution(object):
    r""" Interface for detector resolution algorithms"""

    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_DetectorResolution

    def execDetectorResolution(self, p_intensity_map):
        r""" Apply the resolution function to the intensity data"""
        return _libBornAgainDevice.DetectorResolution_execDetectorResolution(self, p_intensity_map)

# Register DetectorResolution in _libBornAgainDevice:
_libBornAgainDevice.DetectorResolution_swigregister(DetectorResolution)
class ResolutionFunction2D(object):
    r""" Defines class interface ResolutionFunction2D. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) Interface providing two-dimensional resolution function."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainDevice.delete_ResolutionFunction2D

# Register ResolutionFunction2D in _libBornAgainDevice:
_libBornAgainDevice.ResolutionFunction2D_swigregister(ResolutionFunction2D)
class ResolutionFunction2DGaussian(ResolutionFunction2D):
    r""" Defines class ResolutionFunction2DGaussian. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) Simple gaussian two-dimensional resolution function."""

    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))
    __swig_destroy__ = _libBornAgainDevice.delete_ResolutionFunction2DGaussian

# Register ResolutionFunction2DGaussian in _libBornAgainDevice:
_libBornAgainDevice.ResolutionFunction2DGaussian_swigregister(ResolutionFunction2DGaussian)
class Detector(object):
    r""" Abstract base for 2D detectors, realized by SphericalDetector. Handles also "region of interest" (ROI). In general, the ROI is the whole detector, and all methods related to ROI work on the whole detector. If a ROI different to the detector size is explicitly set, then ROI-related methods work on this reduced ROI. Therefore, when calling ROI related methods, the distinction between "explicit ROI exists: yes/no" does not have to be made by the caller, but it is handled in here. For access to the whole detector, even if a smaller ROI is explicitly defined, use the non-ROI-related methods like totalSize() or axes(). Any method which is not speaking of "explicit ROI" handles the "implicit ROI", i.e. uses an explicitly set ROI or the whole detector if no explicit ROI exists."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainDevice.delete_Detector

    def setAnalyzer(self, direction, transmission_selected=1, transmission_suppressed=0):
        r""" Sets the polarization analyzer characteristics of the detector"""
        return _libBornAgainDevice.Detector_setAnalyzer(self, direction, transmission_selected, transmission_suppressed)

    def setResolutionFunction(self, resFunc):
        r"""setResolutionFunction(Detector self, ResolutionFunction2D resFunc)"""
        return _libBornAgainDevice.Detector_setResolutionFunction(self, resFunc)

    def frame(self):
        r"""frame(Detector self) -> Frame"""
        return _libBornAgainDevice.Detector_frame(self)

    def detectorMask(self):
        r"""detectorMask(Detector self) -> MaskStack const *"""
        return _libBornAgainDevice.Detector_detectorMask(self)

    def addMask(self, shape, mask_value=True):
        r"""
         Adds mask of given shape to the stack of detector masks. The mask value 'true' means that the channel will be excluded from the simulation. The mask which is added last has priority. :type shape: :py:class:`Shape2D`
        :param shape: The shape of mask (Rectangle, Polygon, Line, Ellipse) :type mask_value: boolean, optional
        :param mask_value: The value of mask
        """
        return _libBornAgainDevice.Detector_addMask(self, shape, mask_value)

    def maskAll(self):
        r""" Put the mask for all detector channels (i.e. exclude whole detector from the analysis)"""
        return _libBornAgainDevice.Detector_maskAll(self)

    def axis(self, i):
        r""" One axis of the complete detector. Any region of interest is not taken into account."""
        return _libBornAgainDevice.Detector_axis(self, i)

    def setRegionOfInterest(self, xlow, ylow, xup, yup):
        r""" Sets rectangular region of interest with lower left and upper right corners defined."""
        return _libBornAgainDevice.Detector_setRegionOfInterest(self, xlow, ylow, xup, yup)

    def clippedFrame(self):
        r""" Returns a Frame clipped to the region of interest. If no region of interest is explicitly defined, then the whole detector is taken as "region of interest"."""
        return _libBornAgainDevice.Detector_clippedFrame(self)

    def roiToFullIndex(self, i):
        r""" Convert an index of the region of interest to an index of the detector. If no region of interest is set, then the index stays unmodified (since ROI == detector area)."""
        return _libBornAgainDevice.Detector_roiToFullIndex(self, i)

    def activeIndices(self):
        r"""activeIndices(Detector self) -> vector_longinteger_T"""
        return _libBornAgainDevice.Detector_activeIndices(self)

# Register Detector in _libBornAgainDevice:
_libBornAgainDevice.Detector_swigregister(Detector)
class SphericalDetector(Detector):
    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, n_phi, phi_min, phi_max, n_alpha, alpha_min, alpha_max):
        r"""__init__(SphericalDetector self, size_t n_phi, double phi_min, double phi_max, size_t n_alpha, double alpha_min, double alpha_max) -> SphericalDetector"""
        _libBornAgainDevice.SphericalDetector_swiginit(self, _libBornAgainDevice.new_SphericalDetector(n_phi, phi_min, phi_max, n_alpha, alpha_min, alpha_max))
    __swig_destroy__ = _libBornAgainDevice.delete_SphericalDetector

# Register SphericalDetector in _libBornAgainDevice:
_libBornAgainDevice.SphericalDetector_swigregister(SphericalDetector)
class OffspecDetector(object):
    r""" A phi-integrating detector with coordinate axis along alpha."""

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

    def __init__(self, n_alpha, alpha_min, alpha_max, phi_min, phi_max):
        r"""
         Returns a detector with given phi and alpha axes. :type phi_min: float
        :param phi_min: low edge of first phi-bin :type phi_max: float
        :param phi_max: upper edge of last phi-bin :type n_alpha: int
        :param n_alpha: number of alpha-axis bins :type alpha_min: float
        :param alpha_min: low edge of first alpha-bin :type alpha_max: float
        :param alpha_max: upper edge of last alpha-bin
        """
        _libBornAgainDevice.OffspecDetector_swiginit(self, _libBornAgainDevice.new_OffspecDetector(n_alpha, alpha_min, alpha_max, phi_min, phi_max))
    __swig_destroy__ = _libBornAgainDevice.delete_OffspecDetector

    def setAnalyzer(self, direction, transmission_selected=1, transmission_suppressed=0):
        r""" Sets the polarization analyzer characteristics of the detector"""
        return _libBornAgainDevice.OffspecDetector_setAnalyzer(self, direction, transmission_selected, transmission_suppressed)

# Register OffspecDetector in _libBornAgainDevice:
_libBornAgainDevice.OffspecDetector_swigregister(OffspecDetector)

def checkRelVecDifference(dat, ref, threshold):
    r""" Returns true is relative difference is below threshold; prints informative output"""
    return _libBornAgainDevice.checkRelVecDifference(dat, ref, threshold)

def checkRelativeDifference(dat, ref, threshold):
    r""" Returns true is relative difference is below threshold; prints informative output"""
    return _libBornAgainDevice.checkRelativeDifference(dat, ref, threshold)

def checkConsistence(dat, ref, precision, snr):
    r""" Returns true is relative and absolute differences are within given limits"""
    return _libBornAgainDevice.checkConsistence(dat, ref, precision, snr)
class ImportSettings1D(object):
    r""" Declares import settings structs. http://www.bornagainproject.org GNU General Public License v3 or higher (see COPYING) Copyright: Forschungszentrum Jülich GmbH 2018 Authors: Scientific Computing Group at MLZ (see CITATION, AUTHORS) This parameterization can be set interactively by GUI users. Therefore, exceptionally, indices are counting from 1, not  from 0."""

    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__(ImportSettings1D self, Coordinate _xCoord, std::string _prefix, std::string _skip, size_t __Q, size_t __R, size_t __sR=0, size_t __dQ=0, size_t __lambda=0, bool _sort=True, bool _rm_neg=True, bool _rm_dup=True) -> ImportSettings1D
        __init__(ImportSettings1D self, char const * _xCoord, std::string _prefix, std::string _skip, size_t __Q, size_t __R, size_t __sR=0, size_t __dQ=0, size_t __lambda=0, bool _sort=True, bool _rm_neg=True, bool _rm_dup=True) -> ImportSettings1D
        """
        _libBornAgainDevice.ImportSettings1D_swiginit(self, _libBornAgainDevice.new_ImportSettings1D(*args))
    xCoord = property(_libBornAgainDevice.ImportSettings1D_xCoord_get, _libBornAgainDevice.ImportSettings1D_xCoord_set, doc=r"""xCoord : Coordinate""")
    headerPrefix = property(_libBornAgainDevice.ImportSettings1D_headerPrefix_get, _libBornAgainDevice.ImportSettings1D_headerPrefix_set, doc=r""" prefix of header lines (usually a single character like "#")""")
    linesToSkip = property(_libBornAgainDevice.ImportSettings1D_linesToSkip_get, _libBornAgainDevice.ImportSettings1D_linesToSkip_set, doc=r""" pattern denoting line to skip (i.e. '1,10-12,42')""")
    col_Q = property(_libBornAgainDevice.ImportSettings1D_col_Q_get, _libBornAgainDevice.ImportSettings1D_col_Q_set, doc=r""" column number of Q (counting from 1!)""")
    col_R = property(_libBornAgainDevice.ImportSettings1D_col_R_get, _libBornAgainDevice.ImportSettings1D_col_R_set, doc=r""" column number of R""")
    col_sR = property(_libBornAgainDevice.ImportSettings1D_col_sR_get, _libBornAgainDevice.ImportSettings1D_col_sR_set, doc=r""" column number of sigma R, or 0""")
    col_dQ = property(_libBornAgainDevice.ImportSettings1D_col_dQ_get, _libBornAgainDevice.ImportSettings1D_col_dQ_set, doc=r""" column number of delta Q, or 0""")
    col_lambda = property(_libBornAgainDevice.ImportSettings1D_col_lambda_get, _libBornAgainDevice.ImportSettings1D_col_lambda_set, doc=r""" column number of wavelength, or 0""")
    sort = property(_libBornAgainDevice.ImportSettings1D_sort_get, _libBornAgainDevice.ImportSettings1D_sort_set, doc=r""" sort lines by argument""")
    rm_negative = property(_libBornAgainDevice.ImportSettings1D_rm_negative_get, _libBornAgainDevice.ImportSettings1D_rm_negative_set, doc=r""" discard lines with negative arguments""")
    rm_duplications = property(_libBornAgainDevice.ImportSettings1D_rm_duplications_get, _libBornAgainDevice.ImportSettings1D_rm_duplications_set, doc=r""" discard lines with duplicated arguments""")
    __swig_destroy__ = _libBornAgainDevice.delete_ImportSettings1D

# Register ImportSettings1D in _libBornAgainDevice:
_libBornAgainDevice.ImportSettings1D_swigregister(ImportSettings1D)
class ImportSettings2D(object):
    r""" This parameterization can be set interactively by GUI users. Therefore, exceptionally, indices are counting from 1, not  from 0."""

    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__(ImportSettings2D self, Coordinate _xCoord, Coordinate _yCoord, bool _axes=False, bool _swap=False, bool _first_row=True, bool _first_col=True) -> ImportSettings2D
        __init__(ImportSettings2D self, char const * _xCoord, char const * _yCoord, bool _axes=False, bool _swap=False, bool _first_row=True, bool _first_col=True) -> ImportSettings2D
        """
        _libBornAgainDevice.ImportSettings2D_swiginit(self, _libBornAgainDevice.new_ImportSettings2D(*args))
    xCoord = property(_libBornAgainDevice.ImportSettings2D_xCoord_get, _libBornAgainDevice.ImportSettings2D_xCoord_set, doc=r"""xCoord : Coordinate""")
    yCoord = property(_libBornAgainDevice.ImportSettings2D_yCoord_get, _libBornAgainDevice.ImportSettings2D_yCoord_set, doc=r"""yCoord : Coordinate""")
    has_axes = property(_libBornAgainDevice.ImportSettings2D_has_axes_get, _libBornAgainDevice.ImportSettings2D_has_axes_set, doc=r""" read axes or not""")
    swap_axes = property(_libBornAgainDevice.ImportSettings2D_swap_axes_get, _libBornAgainDevice.ImportSettings2D_swap_axes_set, doc=r""" orientation: x <-> y""")
    first_row = property(_libBornAgainDevice.ImportSettings2D_first_row_get, _libBornAgainDevice.ImportSettings2D_first_row_set, doc=r""" axis row: first or last""")
    first_col = property(_libBornAgainDevice.ImportSettings2D_first_col_get, _libBornAgainDevice.ImportSettings2D_first_col_set, doc=r""" axis column: first or last""")
    __swig_destroy__ = _libBornAgainDevice.delete_ImportSettings2D

# Register ImportSettings2D in _libBornAgainDevice:
_libBornAgainDevice.ImportSettings2D_swigregister(ImportSettings2D)
unknown1D = _libBornAgainDevice.unknown1D

csv1D = _libBornAgainDevice.csv1D

bornagain1D = _libBornAgainDevice.bornagain1D

mft = _libBornAgainDevice.mft

unknown2D = _libBornAgainDevice.unknown2D

csv2D = _libBornAgainDevice.csv2D

bornagain2D = _libBornAgainDevice.bornagain2D

tiff = _libBornAgainDevice.tiff

nicos2D = _libBornAgainDevice.nicos2D


def readData1D(*args):
    r"""
    *Overload 1:*
    Reads 1D data file and returns newly created Datafield object. If file name ends with "*.gz" or "*.bz2" the file will be unzipped on the fly. Otherwise the file extension is ignored, since the file type is given by argument. May throw, but will never return nullptr.

    |

    *Overload 2:*
    Reads 1D data file and returns newly created Datafield object. Determines type from file name extension.
    """
    return _libBornAgainDevice.readData1D(*args)

def readData2D(*args):
    r"""
    *Overload 1:*
    Reads 2D data file and returns newly created Datafield object. If file name ends with "*.gz" or "*.bz2" the file will be unzipped on the fly. Otherwise the file extension is ignored, since the file type is given by argument. May throw, but will never return nullptr.

    |

    *Overload 2:*
    Reads 2D data file and returns newly created Datafield object. Determines type from file name extension.
    """
    return _libBornAgainDevice.readData2D(*args)

def writeDatafield(data, fname):
    r""" Writes Datafield to file. The format is determined by the file extension. If file name ends with "*.gz" or "*.bz2" the file will be zipped on the fly."""
    return _libBornAgainDevice.writeDatafield(data, fname)

def dataMatchesFile(data, refFileName, tol):
    r""" Returns true if data matches reference file. For use in tests."""
    return _libBornAgainDevice.dataMatchesFile(data, refFileName, tol)

def FindPeaks(*args):
    r""" Returns vector of peak center coordinates, for peaks in given histogram."""
    return _libBornAgainDevice.FindPeaks(*args)

