# 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 _libBornAgainSim

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__ = _libBornAgainSim.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vdouble1d_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vdouble1d_T self) -> bool"""
        return _libBornAgainSim.vdouble1d_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vdouble1d_T self) -> bool"""
        return _libBornAgainSim.vdouble1d_T___bool__(self)

    def __len__(self):
        r"""__len__(vdouble1d_T self) -> std::vector< double >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vdouble1d_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vdouble1d_T self) -> std::vector< double >::value_type"""
        return _libBornAgainSim.vdouble1d_T_pop(self)

    def append(self, x):
        r"""append(vdouble1d_T self, std::vector< double >::value_type const & x)"""
        return _libBornAgainSim.vdouble1d_T_append(self, x)

    def empty(self):
        r"""empty(vdouble1d_T self) -> bool"""
        return _libBornAgainSim.vdouble1d_T_empty(self)

    def size(self):
        r"""size(vdouble1d_T self) -> std::vector< double >::size_type"""
        return _libBornAgainSim.vdouble1d_T_size(self)

    def swap(self, v):
        r"""swap(vdouble1d_T self, vdouble1d_T v)"""
        return _libBornAgainSim.vdouble1d_T_swap(self, v)

    def begin(self):
        r"""begin(vdouble1d_T self) -> std::vector< double >::iterator"""
        return _libBornAgainSim.vdouble1d_T_begin(self)

    def end(self):
        r"""end(vdouble1d_T self) -> std::vector< double >::iterator"""
        return _libBornAgainSim.vdouble1d_T_end(self)

    def rbegin(self):
        r"""rbegin(vdouble1d_T self) -> std::vector< double >::reverse_iterator"""
        return _libBornAgainSim.vdouble1d_T_rbegin(self)

    def rend(self):
        r"""rend(vdouble1d_T self) -> std::vector< double >::reverse_iterator"""
        return _libBornAgainSim.vdouble1d_T_rend(self)

    def clear(self):
        r"""clear(vdouble1d_T self)"""
        return _libBornAgainSim.vdouble1d_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vdouble1d_T self) -> std::vector< double >::allocator_type"""
        return _libBornAgainSim.vdouble1d_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vdouble1d_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vdouble1d_T_swiginit(self, _libBornAgainSim.new_vdouble1d_T(*args))

    def push_back(self, x):
        r"""push_back(vdouble1d_T self, std::vector< double >::value_type const & x)"""
        return _libBornAgainSim.vdouble1d_T_push_back(self, x)

    def front(self):
        r"""front(vdouble1d_T self) -> std::vector< double >::value_type const &"""
        return _libBornAgainSim.vdouble1d_T_front(self)

    def back(self):
        r"""back(vdouble1d_T self) -> std::vector< double >::value_type const &"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vdouble1d_T_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vdouble1d_T self, std::vector< double >::size_type n)"""
        return _libBornAgainSim.vdouble1d_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vdouble1d_T self) -> std::vector< double >::size_type"""
        return _libBornAgainSim.vdouble1d_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vdouble1d_T

# Register vdouble1d_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vdouble2d_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vdouble2d_T self) -> bool"""
        return _libBornAgainSim.vdouble2d_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vdouble2d_T self) -> bool"""
        return _libBornAgainSim.vdouble2d_T___bool__(self)

    def __len__(self):
        r"""__len__(vdouble2d_T self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vdouble2d_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vdouble2d_T self) -> vdouble1d_T"""
        return _libBornAgainSim.vdouble2d_T_pop(self)

    def append(self, x):
        r"""append(vdouble2d_T self, vdouble1d_T x)"""
        return _libBornAgainSim.vdouble2d_T_append(self, x)

    def empty(self):
        r"""empty(vdouble2d_T self) -> bool"""
        return _libBornAgainSim.vdouble2d_T_empty(self)

    def size(self):
        r"""size(vdouble2d_T self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainSim.vdouble2d_T_size(self)

    def swap(self, v):
        r"""swap(vdouble2d_T self, vdouble2d_T v)"""
        return _libBornAgainSim.vdouble2d_T_swap(self, v)

    def begin(self):
        r"""begin(vdouble2d_T self) -> std::vector< std::vector< double > >::iterator"""
        return _libBornAgainSim.vdouble2d_T_begin(self)

    def end(self):
        r"""end(vdouble2d_T self) -> std::vector< std::vector< double > >::iterator"""
        return _libBornAgainSim.vdouble2d_T_end(self)

    def rbegin(self):
        r"""rbegin(vdouble2d_T self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libBornAgainSim.vdouble2d_T_rbegin(self)

    def rend(self):
        r"""rend(vdouble2d_T self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libBornAgainSim.vdouble2d_T_rend(self)

    def clear(self):
        r"""clear(vdouble2d_T self)"""
        return _libBornAgainSim.vdouble2d_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vdouble2d_T self) -> std::vector< std::vector< double > >::allocator_type"""
        return _libBornAgainSim.vdouble2d_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vdouble2d_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vdouble2d_T_swiginit(self, _libBornAgainSim.new_vdouble2d_T(*args))

    def push_back(self, x):
        r"""push_back(vdouble2d_T self, vdouble1d_T x)"""
        return _libBornAgainSim.vdouble2d_T_push_back(self, x)

    def front(self):
        r"""front(vdouble2d_T self) -> vdouble1d_T"""
        return _libBornAgainSim.vdouble2d_T_front(self)

    def back(self):
        r"""back(vdouble2d_T self) -> vdouble1d_T"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vdouble2d_T_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vdouble2d_T self, std::vector< std::vector< double > >::size_type n)"""
        return _libBornAgainSim.vdouble2d_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vdouble2d_T self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainSim.vdouble2d_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vdouble2d_T

# Register vdouble2d_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vector_integer_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_integer_T self) -> bool"""
        return _libBornAgainSim.vector_integer_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_integer_T self) -> bool"""
        return _libBornAgainSim.vector_integer_T___bool__(self)

    def __len__(self):
        r"""__len__(vector_integer_T self) -> std::vector< int >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_integer_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_integer_T self) -> std::vector< int >::value_type"""
        return _libBornAgainSim.vector_integer_T_pop(self)

    def append(self, x):
        r"""append(vector_integer_T self, std::vector< int >::value_type const & x)"""
        return _libBornAgainSim.vector_integer_T_append(self, x)

    def empty(self):
        r"""empty(vector_integer_T self) -> bool"""
        return _libBornAgainSim.vector_integer_T_empty(self)

    def size(self):
        r"""size(vector_integer_T self) -> std::vector< int >::size_type"""
        return _libBornAgainSim.vector_integer_T_size(self)

    def swap(self, v):
        r"""swap(vector_integer_T self, vector_integer_T v)"""
        return _libBornAgainSim.vector_integer_T_swap(self, v)

    def begin(self):
        r"""begin(vector_integer_T self) -> std::vector< int >::iterator"""
        return _libBornAgainSim.vector_integer_T_begin(self)

    def end(self):
        r"""end(vector_integer_T self) -> std::vector< int >::iterator"""
        return _libBornAgainSim.vector_integer_T_end(self)

    def rbegin(self):
        r"""rbegin(vector_integer_T self) -> std::vector< int >::reverse_iterator"""
        return _libBornAgainSim.vector_integer_T_rbegin(self)

    def rend(self):
        r"""rend(vector_integer_T self) -> std::vector< int >::reverse_iterator"""
        return _libBornAgainSim.vector_integer_T_rend(self)

    def clear(self):
        r"""clear(vector_integer_T self)"""
        return _libBornAgainSim.vector_integer_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_integer_T self) -> std::vector< int >::allocator_type"""
        return _libBornAgainSim.vector_integer_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_integer_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vector_integer_T_swiginit(self, _libBornAgainSim.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 _libBornAgainSim.vector_integer_T_push_back(self, x)

    def front(self):
        r"""front(vector_integer_T self) -> std::vector< int >::value_type const &"""
        return _libBornAgainSim.vector_integer_T_front(self)

    def back(self):
        r"""back(vector_integer_T self) -> std::vector< int >::value_type const &"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_integer_T_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_integer_T self, std::vector< int >::size_type n)"""
        return _libBornAgainSim.vector_integer_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_integer_T self) -> std::vector< int >::size_type"""
        return _libBornAgainSim.vector_integer_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vector_integer_T

# Register vector_integer_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vinteger2d_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vinteger2d_T self) -> bool"""
        return _libBornAgainSim.vinteger2d_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vinteger2d_T self) -> bool"""
        return _libBornAgainSim.vinteger2d_T___bool__(self)

    def __len__(self):
        r"""__len__(vinteger2d_T self) -> std::vector< std::vector< int > >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vinteger2d_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vinteger2d_T self) -> vector_integer_T"""
        return _libBornAgainSim.vinteger2d_T_pop(self)

    def append(self, x):
        r"""append(vinteger2d_T self, vector_integer_T x)"""
        return _libBornAgainSim.vinteger2d_T_append(self, x)

    def empty(self):
        r"""empty(vinteger2d_T self) -> bool"""
        return _libBornAgainSim.vinteger2d_T_empty(self)

    def size(self):
        r"""size(vinteger2d_T self) -> std::vector< std::vector< int > >::size_type"""
        return _libBornAgainSim.vinteger2d_T_size(self)

    def swap(self, v):
        r"""swap(vinteger2d_T self, vinteger2d_T v)"""
        return _libBornAgainSim.vinteger2d_T_swap(self, v)

    def begin(self):
        r"""begin(vinteger2d_T self) -> std::vector< std::vector< int > >::iterator"""
        return _libBornAgainSim.vinteger2d_T_begin(self)

    def end(self):
        r"""end(vinteger2d_T self) -> std::vector< std::vector< int > >::iterator"""
        return _libBornAgainSim.vinteger2d_T_end(self)

    def rbegin(self):
        r"""rbegin(vinteger2d_T self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _libBornAgainSim.vinteger2d_T_rbegin(self)

    def rend(self):
        r"""rend(vinteger2d_T self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _libBornAgainSim.vinteger2d_T_rend(self)

    def clear(self):
        r"""clear(vinteger2d_T self)"""
        return _libBornAgainSim.vinteger2d_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vinteger2d_T self) -> std::vector< std::vector< int > >::allocator_type"""
        return _libBornAgainSim.vinteger2d_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vinteger2d_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vinteger2d_T_swiginit(self, _libBornAgainSim.new_vinteger2d_T(*args))

    def push_back(self, x):
        r"""push_back(vinteger2d_T self, vector_integer_T x)"""
        return _libBornAgainSim.vinteger2d_T_push_back(self, x)

    def front(self):
        r"""front(vinteger2d_T self) -> vector_integer_T"""
        return _libBornAgainSim.vinteger2d_T_front(self)

    def back(self):
        r"""back(vinteger2d_T self) -> vector_integer_T"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vinteger2d_T_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vinteger2d_T self, std::vector< std::vector< int > >::size_type n)"""
        return _libBornAgainSim.vinteger2d_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vinteger2d_T self) -> std::vector< std::vector< int > >::size_type"""
        return _libBornAgainSim.vinteger2d_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vinteger2d_T

# Register vinteger2d_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vector_longinteger_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_longinteger_T self) -> bool"""
        return _libBornAgainSim.vector_longinteger_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_longinteger_T self) -> bool"""
        return _libBornAgainSim.vector_longinteger_T___bool__(self)

    def __len__(self):
        r"""__len__(vector_longinteger_T self) -> std::vector< unsigned long >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_longinteger_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_longinteger_T self) -> std::vector< unsigned long >::value_type"""
        return _libBornAgainSim.vector_longinteger_T_pop(self)

    def append(self, x):
        r"""append(vector_longinteger_T self, std::vector< unsigned long >::value_type const & x)"""
        return _libBornAgainSim.vector_longinteger_T_append(self, x)

    def empty(self):
        r"""empty(vector_longinteger_T self) -> bool"""
        return _libBornAgainSim.vector_longinteger_T_empty(self)

    def size(self):
        r"""size(vector_longinteger_T self) -> std::vector< unsigned long >::size_type"""
        return _libBornAgainSim.vector_longinteger_T_size(self)

    def swap(self, v):
        r"""swap(vector_longinteger_T self, vector_longinteger_T v)"""
        return _libBornAgainSim.vector_longinteger_T_swap(self, v)

    def begin(self):
        r"""begin(vector_longinteger_T self) -> std::vector< unsigned long >::iterator"""
        return _libBornAgainSim.vector_longinteger_T_begin(self)

    def end(self):
        r"""end(vector_longinteger_T self) -> std::vector< unsigned long >::iterator"""
        return _libBornAgainSim.vector_longinteger_T_end(self)

    def rbegin(self):
        r"""rbegin(vector_longinteger_T self) -> std::vector< unsigned long >::reverse_iterator"""
        return _libBornAgainSim.vector_longinteger_T_rbegin(self)

    def rend(self):
        r"""rend(vector_longinteger_T self) -> std::vector< unsigned long >::reverse_iterator"""
        return _libBornAgainSim.vector_longinteger_T_rend(self)

    def clear(self):
        r"""clear(vector_longinteger_T self)"""
        return _libBornAgainSim.vector_longinteger_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_longinteger_T self) -> std::vector< unsigned long >::allocator_type"""
        return _libBornAgainSim.vector_longinteger_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_longinteger_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vector_longinteger_T_swiginit(self, _libBornAgainSim.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 _libBornAgainSim.vector_longinteger_T_push_back(self, x)

    def front(self):
        r"""front(vector_longinteger_T self) -> std::vector< unsigned long >::value_type const &"""
        return _libBornAgainSim.vector_longinteger_T_front(self)

    def back(self):
        r"""back(vector_longinteger_T self) -> std::vector< unsigned long >::value_type const &"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_longinteger_T_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_longinteger_T self, std::vector< unsigned long >::size_type n)"""
        return _libBornAgainSim.vector_longinteger_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_longinteger_T self) -> std::vector< unsigned long >::size_type"""
        return _libBornAgainSim.vector_longinteger_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vector_longinteger_T

# Register vector_longinteger_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vector_complex_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_complex_T self) -> bool"""
        return _libBornAgainSim.vector_complex_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_complex_T self) -> bool"""
        return _libBornAgainSim.vector_complex_T___bool__(self)

    def __len__(self):
        r"""__len__(vector_complex_T self) -> std::vector< std::complex< double > >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_complex_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_complex_T self) -> std::vector< std::complex< double > >::value_type"""
        return _libBornAgainSim.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 _libBornAgainSim.vector_complex_T_append(self, x)

    def empty(self):
        r"""empty(vector_complex_T self) -> bool"""
        return _libBornAgainSim.vector_complex_T_empty(self)

    def size(self):
        r"""size(vector_complex_T self) -> std::vector< std::complex< double > >::size_type"""
        return _libBornAgainSim.vector_complex_T_size(self)

    def swap(self, v):
        r"""swap(vector_complex_T self, vector_complex_T v)"""
        return _libBornAgainSim.vector_complex_T_swap(self, v)

    def begin(self):
        r"""begin(vector_complex_T self) -> std::vector< std::complex< double > >::iterator"""
        return _libBornAgainSim.vector_complex_T_begin(self)

    def end(self):
        r"""end(vector_complex_T self) -> std::vector< std::complex< double > >::iterator"""
        return _libBornAgainSim.vector_complex_T_end(self)

    def rbegin(self):
        r"""rbegin(vector_complex_T self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _libBornAgainSim.vector_complex_T_rbegin(self)

    def rend(self):
        r"""rend(vector_complex_T self) -> std::vector< std::complex< double > >::reverse_iterator"""
        return _libBornAgainSim.vector_complex_T_rend(self)

    def clear(self):
        r"""clear(vector_complex_T self)"""
        return _libBornAgainSim.vector_complex_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_complex_T self) -> std::vector< std::complex< double > >::allocator_type"""
        return _libBornAgainSim.vector_complex_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_complex_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vector_complex_T_swiginit(self, _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_complex_T_front(self)

    def back(self):
        r"""back(vector_complex_T self) -> std::vector< std::complex< double > >::value_type const &"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_complex_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_complex_T self) -> std::vector< std::complex< double > >::size_type"""
        return _libBornAgainSim.vector_complex_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vector_complex_T

# Register vector_complex_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vector_string_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_string_T self) -> bool"""
        return _libBornAgainSim.vector_string_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_string_T self) -> bool"""
        return _libBornAgainSim.vector_string_T___bool__(self)

    def __len__(self):
        r"""__len__(vector_string_T self) -> std::vector< std::string >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_string_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_string_T self) -> std::vector< std::string >::value_type"""
        return _libBornAgainSim.vector_string_T_pop(self)

    def append(self, x):
        r"""append(vector_string_T self, std::vector< std::string >::value_type const & x)"""
        return _libBornAgainSim.vector_string_T_append(self, x)

    def empty(self):
        r"""empty(vector_string_T self) -> bool"""
        return _libBornAgainSim.vector_string_T_empty(self)

    def size(self):
        r"""size(vector_string_T self) -> std::vector< std::string >::size_type"""
        return _libBornAgainSim.vector_string_T_size(self)

    def swap(self, v):
        r"""swap(vector_string_T self, vector_string_T v)"""
        return _libBornAgainSim.vector_string_T_swap(self, v)

    def begin(self):
        r"""begin(vector_string_T self) -> std::vector< std::string >::iterator"""
        return _libBornAgainSim.vector_string_T_begin(self)

    def end(self):
        r"""end(vector_string_T self) -> std::vector< std::string >::iterator"""
        return _libBornAgainSim.vector_string_T_end(self)

    def rbegin(self):
        r"""rbegin(vector_string_T self) -> std::vector< std::string >::reverse_iterator"""
        return _libBornAgainSim.vector_string_T_rbegin(self)

    def rend(self):
        r"""rend(vector_string_T self) -> std::vector< std::string >::reverse_iterator"""
        return _libBornAgainSim.vector_string_T_rend(self)

    def clear(self):
        r"""clear(vector_string_T self)"""
        return _libBornAgainSim.vector_string_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_string_T self) -> std::vector< std::string >::allocator_type"""
        return _libBornAgainSim.vector_string_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_string_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vector_string_T_swiginit(self, _libBornAgainSim.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 _libBornAgainSim.vector_string_T_push_back(self, x)

    def front(self):
        r"""front(vector_string_T self) -> std::vector< std::string >::value_type const &"""
        return _libBornAgainSim.vector_string_T_front(self)

    def back(self):
        r"""back(vector_string_T self) -> std::vector< std::string >::value_type const &"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_string_T_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_string_T self, std::vector< std::string >::size_type n)"""
        return _libBornAgainSim.vector_string_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_string_T self) -> std::vector< std::string >::size_type"""
        return _libBornAgainSim.vector_string_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vector_string_T

# Register vector_string_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.map_string_double_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(map_string_double_T self) -> bool"""
        return _libBornAgainSim.map_string_double_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(map_string_double_T self) -> bool"""
        return _libBornAgainSim.map_string_double_T___bool__(self)

    def __len__(self):
        r"""__len__(map_string_double_T self) -> std::map< std::string,double >::size_type"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.map_string_double_T_has_key(self, key)

    def keys(self):
        r"""keys(map_string_double_T self) -> PyObject *"""
        return _libBornAgainSim.map_string_double_T_keys(self)

    def values(self):
        r"""values(map_string_double_T self) -> PyObject *"""
        return _libBornAgainSim.map_string_double_T_values(self)

    def items(self):
        r"""items(map_string_double_T self) -> PyObject *"""
        return _libBornAgainSim.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 _libBornAgainSim.map_string_double_T___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(map_string_double_T self) -> SwigPyIterator"""
        return _libBornAgainSim.map_string_double_T_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(map_string_double_T self) -> SwigPyIterator"""
        return _libBornAgainSim.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 _libBornAgainSim.map_string_double_T___setitem__(self, *args)

    def asdict(self):
        r"""asdict(map_string_double_T self) -> PyObject *"""
        return _libBornAgainSim.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
        """
        _libBornAgainSim.map_string_double_T_swiginit(self, _libBornAgainSim.new_map_string_double_T(*args))

    def empty(self):
        r"""empty(map_string_double_T self) -> bool"""
        return _libBornAgainSim.map_string_double_T_empty(self)

    def size(self):
        r"""size(map_string_double_T self) -> std::map< std::string,double >::size_type"""
        return _libBornAgainSim.map_string_double_T_size(self)

    def swap(self, v):
        r"""swap(map_string_double_T self, map_string_double_T v)"""
        return _libBornAgainSim.map_string_double_T_swap(self, v)

    def begin(self):
        r"""begin(map_string_double_T self) -> std::map< std::string,double >::iterator"""
        return _libBornAgainSim.map_string_double_T_begin(self)

    def end(self):
        r"""end(map_string_double_T self) -> std::map< std::string,double >::iterator"""
        return _libBornAgainSim.map_string_double_T_end(self)

    def rbegin(self):
        r"""rbegin(map_string_double_T self) -> std::map< std::string,double >::reverse_iterator"""
        return _libBornAgainSim.map_string_double_T_rbegin(self)

    def rend(self):
        r"""rend(map_string_double_T self) -> std::map< std::string,double >::reverse_iterator"""
        return _libBornAgainSim.map_string_double_T_rend(self)

    def clear(self):
        r"""clear(map_string_double_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.map_string_double_T_upper_bound(self, x)
    __swig_destroy__ = _libBornAgainSim.delete_map_string_double_T

# Register map_string_double_T in _libBornAgainSim:
_libBornAgainSim.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
        """
        _libBornAgainSim.pvacuum_double_T_swiginit(self, _libBornAgainSim.new_pvacuum_double_T(*args))
    first = property(_libBornAgainSim.pvacuum_double_T_first_get, _libBornAgainSim.pvacuum_double_T_first_set, doc=r"""first : double""")
    second = property(_libBornAgainSim.pvacuum_double_T_second_get, _libBornAgainSim.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__ = _libBornAgainSim.delete_pvacuum_double_T

# Register pvacuum_double_T in _libBornAgainSim:
_libBornAgainSim.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 _libBornAgainSim.vector_pvacuum_double_T_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_pvacuum_double_T self) -> bool"""
        return _libBornAgainSim.vector_pvacuum_double_T___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_pvacuum_double_T self) -> bool"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_pvacuum_double_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_pvacuum_double_T self) -> pvacuum_double_T"""
        return _libBornAgainSim.vector_pvacuum_double_T_pop(self)

    def append(self, x):
        r"""append(vector_pvacuum_double_T self, pvacuum_double_T x)"""
        return _libBornAgainSim.vector_pvacuum_double_T_append(self, x)

    def empty(self):
        r"""empty(vector_pvacuum_double_T self) -> bool"""
        return _libBornAgainSim.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 _libBornAgainSim.vector_pvacuum_double_T_size(self)

    def swap(self, v):
        r"""swap(vector_pvacuum_double_T self, vector_pvacuum_double_T v)"""
        return _libBornAgainSim.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 _libBornAgainSim.vector_pvacuum_double_T_begin(self)

    def end(self):
        r"""end(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::iterator"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_pvacuum_double_T_rend(self)

    def clear(self):
        r"""clear(vector_pvacuum_double_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.vector_pvacuum_double_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_pvacuum_double_T self)"""
        return _libBornAgainSim.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 _libBornAgainSim.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
        """
        _libBornAgainSim.vector_pvacuum_double_T_swiginit(self, _libBornAgainSim.new_vector_pvacuum_double_T(*args))

    def push_back(self, x):
        r"""push_back(vector_pvacuum_double_T self, pvacuum_double_T x)"""
        return _libBornAgainSim.vector_pvacuum_double_T_push_back(self, x)

    def front(self):
        r"""front(vector_pvacuum_double_T self) -> pvacuum_double_T"""
        return _libBornAgainSim.vector_pvacuum_double_T_front(self)

    def back(self):
        r"""back(vector_pvacuum_double_T self) -> pvacuum_double_T"""
        return _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.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 _libBornAgainSim.vector_pvacuum_double_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vector_pvacuum_double_T

# Register vector_pvacuum_double_T in _libBornAgainSim:
_libBornAgainSim.vector_pvacuum_double_T_swigregister(vector_pvacuum_double_T)
import libBornAgainBase
import libBornAgainDevice
class BeamScan(object):
    r""" Abstract base class for all types of specular scans."""

    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__ = _libBornAgainSim.delete_BeamScan

    def setIntensity(self, intensity):
        r"""setIntensity(BeamScan self, double intensity)"""
        return _libBornAgainSim.BeamScan_setIntensity(self, intensity)

    def setPolarization(self, bloch_vector):
        r""" Sets the polarization density matrix according to the given Bloch vector"""
        return _libBornAgainSim.BeamScan_setPolarization(self, bloch_vector)

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

# Register BeamScan in _libBornAgainSim:
_libBornAgainSim.BeamScan_swigregister(BeamScan)
cvar = _libBornAgainSim.cvar
version = cvar.version

class PhysicalScan(BeamScan):
    r""" Abstract base class for alpha and lambda scans."""

    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__ = _libBornAgainSim.delete_PhysicalScan

    def setWavelength(self, _lambda):
        r"""setWavelength(PhysicalScan self, double _lambda)"""
        return _libBornAgainSim.PhysicalScan_setWavelength(self, _lambda)

    def setWavelengthDistribution(self, distr):
        r""" Distribution with absolute width, **complementing** wavelength values"""
        return _libBornAgainSim.PhysicalScan_setWavelengthDistribution(self, distr)

    def setGrazingAngle(self, alpha):
        r"""setGrazingAngle(PhysicalScan self, double alpha)"""
        return _libBornAgainSim.PhysicalScan_setGrazingAngle(self, alpha)

    def setGrazingAngleDistribution(self, distr):
        r""" Distribution with absolute width, **complementing** grazing angle values"""
        return _libBornAgainSim.PhysicalScan_setGrazingAngleDistribution(self, distr)

    def setAzimuthalAngle(self, phi):
        r"""setAzimuthalAngle(PhysicalScan self, double phi)"""
        return _libBornAgainSim.PhysicalScan_setAzimuthalAngle(self, phi)

    def setAzimuthalAngleDistribution(self, distr):
        r""" Distribution with absolute width, **complementing** azimuthal angle values"""
        return _libBornAgainSim.PhysicalScan_setAzimuthalAngleDistribution(self, distr)

    def setFootprint(self, footprint):
        r"""setFootprint(PhysicalScan self, Footprint const * footprint)"""
        return _libBornAgainSim.PhysicalScan_setFootprint(self, footprint)

# Register PhysicalScan in _libBornAgainSim:
_libBornAgainSim.PhysicalScan_swigregister(PhysicalScan)
class AlphaScan(PhysicalScan):
    r""" Scan type with grazing angles as coordinate values and a unique wavelength. Features footprint correction."""

    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__(AlphaScan self, Scale alpha_axis) -> AlphaScan
        __init__(AlphaScan self, vdouble1d_T points) -> AlphaScan
        __init__(AlphaScan self, int nbins, double alpha_i_min, double alpha_i_max) -> AlphaScan
        """
        _libBornAgainSim.AlphaScan_swiginit(self, _libBornAgainSim.new_AlphaScan(*args))
    __swig_destroy__ = _libBornAgainSim.delete_AlphaScan

    def setAlphaOffset(self, offset):
        r"""setAlphaOffset(AlphaScan self, double offset)"""
        return _libBornAgainSim.AlphaScan_setAlphaOffset(self, offset)

# Register AlphaScan in _libBornAgainSim:
_libBornAgainSim.AlphaScan_swigregister(AlphaScan)
class LambdaScan(PhysicalScan):
    r""" Scan type with z-components of scattering vector as coordinate values. Wavelength and incident angles are not accessible separately."""

    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__(LambdaScan self, Scale lambdaScale) -> LambdaScan
        __init__(LambdaScan self, vdouble1d_T points) -> LambdaScan
        __init__(LambdaScan self, int nbins, double lambda_min, double lambda_max) -> LambdaScan
        """
        _libBornAgainSim.LambdaScan_swiginit(self, _libBornAgainSim.new_LambdaScan(*args))
    __swig_destroy__ = _libBornAgainSim.delete_LambdaScan

# Register LambdaScan in _libBornAgainSim:
_libBornAgainSim.LambdaScan_swigregister(LambdaScan)
class QzScan(BeamScan):
    r""" Scan type with z-components of scattering vector as coordinate values. Wavelength and incident angles are not accessible separately."""

    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"""
        *Overload 1:*
        Accepts qz-value vector (in inverse nm)

        |

        *Overload 2:*
        Sets q-defined specular scan. Accepts either numpy array of q-values sorted in ascending order or an Scale object with q-values. Alternatively an axis can be defined in-place, then the first passed parameter is the number of bins, second - minimum on-axis q-value, third - maximum on-axis q_value.
        """
        _libBornAgainSim.QzScan_swiginit(self, _libBornAgainSim.new_QzScan(*args))
    __swig_destroy__ = _libBornAgainSim.delete_QzScan

    def setRelativeQResolution(self, distr, rel_dev):
        r"""setRelativeQResolution(QzScan self, Distribution1D const & distr, double rel_dev)"""
        return _libBornAgainSim.QzScan_setRelativeQResolution(self, distr, rel_dev)

    def setAbsoluteQResolution(self, distr, std_dev):
        r"""setAbsoluteQResolution(QzScan self, Distribution1D const & distr, double std_dev)"""
        return _libBornAgainSim.QzScan_setAbsoluteQResolution(self, distr, std_dev)

    def setVectorResolution(self, distr, std_devs):
        r""" Sets qz resolution function and list of standard deviations."""
        return _libBornAgainSim.QzScan_setVectorResolution(self, distr, std_devs)

    def setOffset(self, offset):
        r"""setOffset(QzScan self, double offset)"""
        return _libBornAgainSim.QzScan_setOffset(self, offset)

# Register QzScan in _libBornAgainSim:
_libBornAgainSim.QzScan_swigregister(QzScan)
class Simulation(object):
    r""" Abstract base class, holds the infrastructure to run a simulation. Base class of SpecularSimulation, OffspecSimulation, and DepthprobeSimulation. Holds an instrument and sample model. Provides the common infrastructure to run a simulation: multithreading, batch processing, averaging over parameter distributions, etc. Simulations are run, and results returned, by the function Simulation::simulate()."""

    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__ = _libBornAgainSim.delete_Simulation

    def setBackground(self, bg):
        r"""setBackground(Simulation self, Background bg)"""
        return _libBornAgainSim.Simulation_setBackground(self, bg)

    def setTerminalProgressMonitor(self):
        r"""setTerminalProgressMonitor(Simulation self)"""
        return _libBornAgainSim.Simulation_setTerminalProgressMonitor(self)

    def options(self):
        r"""options(Simulation self) -> SimulationOptions &"""
        return _libBornAgainSim.Simulation_options(self)

    def simulate(self):
        r""" Runs a simulation, and returns the result."""
        return _libBornAgainSim.Simulation_simulate(self)

# Register Simulation in _libBornAgainSim:
_libBornAgainSim.Simulation_swigregister(Simulation)
class ScatteringSimulation(Simulation):
    r""" GISAS simulation. Holds an instrument and sample model. Computes the scattered intensity as function of 2D detector coordinates."""

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

    def __init__(self, beam, sample, detector):
        r"""__init__(ScatteringSimulation self, Beam const & beam, Sample const & sample, Detector const & detector) -> ScatteringSimulation"""
        _libBornAgainSim.ScatteringSimulation_swiginit(self, _libBornAgainSim.new_ScatteringSimulation(beam, sample, detector))
    __swig_destroy__ = _libBornAgainSim.delete_ScatteringSimulation

    def beam(self):
        r"""beam(ScatteringSimulation self) -> Beam &"""
        return _libBornAgainSim.ScatteringSimulation_beam(self)

    def detector(self):
        r"""detector(ScatteringSimulation self) -> Detector &"""
        return _libBornAgainSim.ScatteringSimulation_detector(self)

    def addParameterDistribution(self, whichParameter, distribution):
        r"""addParameterDistribution(ScatteringSimulation self, ParameterDistribution::WhichParameter whichParameter, Distribution1D const & distribution)"""
        return _libBornAgainSim.ScatteringSimulation_addParameterDistribution(self, whichParameter, distribution)

# Register ScatteringSimulation in _libBornAgainSim:
_libBornAgainSim.ScatteringSimulation_swigregister(ScatteringSimulation)
class DepthprobeSimulation(Simulation):
    r""" Simulation of radiation depth profile. Holds an instrument and sample model. Computes radiation intensity as function of incoming glancing angle and penetration depth. Scattered rays are neglected. Only refraction, reflection and attenuation of the incoming beam are accounted for."""

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

    def __init__(self, scan, sample, zaxis, flags=0):
        r"""__init__(DepthprobeSimulation self, BeamScan scan, Sample const & sample, Scale zaxis, int flags=0) -> DepthprobeSimulation"""
        _libBornAgainSim.DepthprobeSimulation_swiginit(self, _libBornAgainSim.new_DepthprobeSimulation(scan, sample, zaxis, flags))
    __swig_destroy__ = _libBornAgainSim.delete_DepthprobeSimulation

    def transmitted(self):
        r""" Returns the Fresnel energy-flux transmission T per alpha bin. T = (k_{z,sub} / k_{z,vac}) * |t|^2 is the fraction of incident energy flux that enters the substrate. T <= 1 always."""
        return _libBornAgainSim.DepthprobeSimulation_transmitted(self)

    def reflected(self):
        r""" Returns the Fresnel reflectance R = |r|^2 per alpha bin."""
        return _libBornAgainSim.DepthprobeSimulation_reflected(self)

# Register DepthprobeSimulation in _libBornAgainSim:
_libBornAgainSim.DepthprobeSimulation_swigregister(DepthprobeSimulation)
ZDirection_None = cvar.ZDirection_None
ZDirection_Reflected = cvar.ZDirection_Reflected
ZDirection_Transmitted = cvar.ZDirection_Transmitted
WaveProperty_Intensity = cvar.WaveProperty_Intensity
WaveProperty_Modulus = cvar.WaveProperty_Modulus
WaveProperty_Phase = cvar.WaveProperty_Phase

class SpecularSimulation(Simulation):
    r""" Specular reflectometry simulation. Holds an instrument and sample model. Computes detected intensity as function of the glancing angles alpha_i=alpha_f."""

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

    def __init__(self, scan, sample):
        r"""__init__(SpecularSimulation self, BeamScan scan, Sample const & sample) -> SpecularSimulation"""
        _libBornAgainSim.SpecularSimulation_swiginit(self, _libBornAgainSim.new_SpecularSimulation(scan, sample))
    __swig_destroy__ = _libBornAgainSim.delete_SpecularSimulation

# Register SpecularSimulation in _libBornAgainSim:
_libBornAgainSim.SpecularSimulation_swigregister(SpecularSimulation)
class OffspecSimulation(Simulation):
    r""" Off-specular scattering simulation. Holds an instrument and sample model. Computes reflected and scattered intensity as function of incident and final glancing angle."""

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

    def __init__(self, scan, sample, detector):
        r"""__init__(OffspecSimulation self, PhysicalScan scan, Sample const & sample, OffspecDetector const & detector) -> OffspecSimulation"""
        _libBornAgainSim.OffspecSimulation_swiginit(self, _libBornAgainSim.new_OffspecSimulation(scan, sample, detector))
    __swig_destroy__ = _libBornAgainSim.delete_OffspecSimulation

# Register OffspecSimulation in _libBornAgainSim:
_libBornAgainSim.OffspecSimulation_swigregister(OffspecSimulation)
class ParticleSimulation(object):
    r""" Simulation of scattering from isolated particles (pure Born approximation). Computes |F(q)|² for each detector pixel, where F is the particle form factor and q is the scattering vector determined by beam and detector geometry. This simulation does not involve any sample, layers, or DWBA corrections. It is intended for computing and visualizing particle form factors."""

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

    def __init__(self, beam, particle, detector):
        r"""__init__(ParticleSimulation self, Beam const & beam, IParticle const & particle, Detector const & detector) -> ParticleSimulation"""
        _libBornAgainSim.ParticleSimulation_swiginit(self, _libBornAgainSim.new_ParticleSimulation(beam, particle, detector))
    __swig_destroy__ = _libBornAgainSim.delete_ParticleSimulation

    def simulate(self):
        r"""simulate(ParticleSimulation self) -> Datafield"""
        return _libBornAgainSim.ParticleSimulation_simulate(self)

# Register ParticleSimulation in _libBornAgainSim:
_libBornAgainSim.ParticleSimulation_swigregister(ParticleSimulation)
class Background(object):
    r""" Abstract base class for background noise, to be added to simulated scattering. Base class of ConstantBackground, PoissonBackground."""

    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__ = _libBornAgainSim.delete_Background

    def perturbed(self, element):
        r"""perturbed(Background self, double element) -> double"""
        return _libBornAgainSim.Background_perturbed(self, element)

# Register Background in _libBornAgainSim:
_libBornAgainSim.Background_swigregister(Background)
class ConstantBackground(Background):
    r""" Constant background, to be added to simulated scattering."""

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

    def __init__(self, background_value):
        r"""__init__(ConstantBackground self, double background_value) -> ConstantBackground"""
        _libBornAgainSim.ConstantBackground_swiginit(self, _libBornAgainSim.new_ConstantBackground(background_value))

    def perturbed(self, intensity):
        r"""perturbed(ConstantBackground self, double intensity) -> double"""
        return _libBornAgainSim.ConstantBackground_perturbed(self, intensity)
    __swig_destroy__ = _libBornAgainSim.delete_ConstantBackground

# Register ConstantBackground in _libBornAgainSim:
_libBornAgainSim.ConstantBackground_swigregister(ConstantBackground)
class PoissonBackground(Background):
    r""" Poisson distributed noise, to be added to simulated scattering."""

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

    def __init__(self):
        r"""__init__(PoissonBackground self) -> PoissonBackground"""
        _libBornAgainSim.PoissonBackground_swiginit(self, _libBornAgainSim.new_PoissonBackground())

    def perturbed(self, intensity):
        r"""perturbed(PoissonBackground self, double intensity) -> double"""
        return _libBornAgainSim.PoissonBackground_perturbed(self, intensity)
    __swig_destroy__ = _libBornAgainSim.delete_PoissonBackground

# Register PoissonBackground in _libBornAgainSim:
_libBornAgainSim.PoissonBackground_swigregister(PoissonBackground)
class ColorRgba(object):
    r""" RGBA color with float components in [0, 1]. Plain struct, no Qt dependency."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    r = property(_libBornAgainSim.ColorRgba_r_get, _libBornAgainSim.ColorRgba_r_set, doc=r"""r : float""")
    g = property(_libBornAgainSim.ColorRgba_g_get, _libBornAgainSim.ColorRgba_g_set, doc=r"""g : float""")
    b = property(_libBornAgainSim.ColorRgba_b_get, _libBornAgainSim.ColorRgba_b_set, doc=r"""b : float""")
    a = property(_libBornAgainSim.ColorRgba_a_get, _libBornAgainSim.ColorRgba_a_set, doc=r"""a : float""")

    def __init__(self):
        r"""__init__(ColorRgba self) -> ColorRgba"""
        _libBornAgainSim.ColorRgba_swiginit(self, _libBornAgainSim.new_ColorRgba())
    __swig_destroy__ = _libBornAgainSim.delete_ColorRgba

# Register ColorRgba in _libBornAgainSim:
_libBornAgainSim.ColorRgba_swigregister(ColorRgba)
class ParticleData(object):
    r""" Describes a single particle in the 3D scene."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    shape = property(_libBornAgainSim.ParticleData_shape_get, _libBornAgainSim.ParticleData_shape_set, doc=r"""shape : std::string""")
    param_names = property(_libBornAgainSim.ParticleData_param_names_get, _libBornAgainSim.ParticleData_param_names_set, doc=r"""param_names : std::vector<(std::string,std::allocator<(std::string)>)>""")
    param_values = property(_libBornAgainSim.ParticleData_param_values_get, _libBornAgainSim.ParticleData_param_values_set, doc=r"""param_values : std::vector<(double,std::allocator<(double)>)>""")
    pos_x = property(_libBornAgainSim.ParticleData_pos_x_get, _libBornAgainSim.ParticleData_pos_x_set, doc=r"""pos_x : double""")
    pos_y = property(_libBornAgainSim.ParticleData_pos_y_get, _libBornAgainSim.ParticleData_pos_y_set, doc=r"""pos_y : double""")
    pos_z = property(_libBornAgainSim.ParticleData_pos_z_get, _libBornAgainSim.ParticleData_pos_z_set, doc=r"""pos_z : double""")
    euler_alpha = property(_libBornAgainSim.ParticleData_euler_alpha_get, _libBornAgainSim.ParticleData_euler_alpha_set, doc=r"""euler_alpha : double""")
    euler_beta = property(_libBornAgainSim.ParticleData_euler_beta_get, _libBornAgainSim.ParticleData_euler_beta_set, doc=r"""euler_beta : double""")
    euler_gamma = property(_libBornAgainSim.ParticleData_euler_gamma_get, _libBornAgainSim.ParticleData_euler_gamma_set, doc=r"""euler_gamma : double""")
    material = property(_libBornAgainSim.ParticleData_material_get, _libBornAgainSim.ParticleData_material_set, doc=r"""material : std::string""")
    color = property(_libBornAgainSim.ParticleData_color_get, _libBornAgainSim.ParticleData_color_set, doc=r"""color : ColorRgba""")
    alignment = property(_libBornAgainSim.ParticleData_alignment_get, _libBornAgainSim.ParticleData_alignment_set, doc=r"""alignment : int""")
    vert_x = property(_libBornAgainSim.ParticleData_vert_x_get, _libBornAgainSim.ParticleData_vert_x_set, doc=r""" Polyhedron geometry: parallel coordinate arrays (empty for smooth shapes).""")
    vert_y = property(_libBornAgainSim.ParticleData_vert_y_get, _libBornAgainSim.ParticleData_vert_y_set, doc=r"""vert_y : std::vector<(double,std::allocator<(double)>)>""")
    vert_z = property(_libBornAgainSim.ParticleData_vert_z_get, _libBornAgainSim.ParticleData_vert_z_set, doc=r"""vert_z : std::vector<(double,std::allocator<(double)>)>""")
    face_vertex_counts = property(_libBornAgainSim.ParticleData_face_vertex_counts_get, _libBornAgainSim.ParticleData_face_vertex_counts_set, doc=r""" Polyhedron faces: face_vertex_counts[i] gives the number of vertices in face i; face_vertex_indices is the flattened list of vertex indices for all faces.""")
    face_vertex_indices = property(_libBornAgainSim.ParticleData_face_vertex_indices_get, _libBornAgainSim.ParticleData_face_vertex_indices_set, doc=r"""face_vertex_indices : std::vector<(int,std::allocator<(int)>)>""")
    mixture_groups = property(_libBornAgainSim.ParticleData_mixture_groups_get, _libBornAgainSim.ParticleData_mixture_groups_set, doc=r""" Mixture activation path: the particle is visible only if each group picked its variant.""")
    mixture_variants = property(_libBornAgainSim.ParticleData_mixture_variants_get, _libBornAgainSim.ParticleData_mixture_variants_set, doc=r"""mixture_variants : std::vector<(int,std::allocator<(int)>)>""")

    def __init__(self):
        r"""__init__(ParticleData self) -> ParticleData"""
        _libBornAgainSim.ParticleData_swiginit(self, _libBornAgainSim.new_ParticleData())
    __swig_destroy__ = _libBornAgainSim.delete_ParticleData

# Register ParticleData in _libBornAgainSim:
_libBornAgainSim.ParticleData_swigregister(ParticleData)
class StructData(object):
    r""" Describes a particle layout (struct) in the 3D scene."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libBornAgainSim.StructData_type_get, _libBornAgainSim.StructData_type_set, doc=r""" "Crystal2D", "FiniteCrystal2D", "Dilute2D", etc.""")
    placement = property(_libBornAgainSim.StructData_placement_get, _libBornAgainSim.StructData_placement_set, doc=r""" "deposit" (bottom), "suspend" (top), or "fill" (volume)""")
    ref_z = property(_libBornAgainSim.StructData_ref_z_get, _libBornAgainSim.StructData_ref_z_set, doc=r"""ref_z : double""")
    pos_x = property(_libBornAgainSim.StructData_pos_x_get, _libBornAgainSim.StructData_pos_x_set, doc=r""" generated layout positions""")
    pos_y = property(_libBornAgainSim.StructData_pos_y_get, _libBornAgainSim.StructData_pos_y_set, doc=r"""pos_y : std::vector<(double,std::allocator<(double)>)>""")
    pos_z = property(_libBornAgainSim.StructData_pos_z_get, _libBornAgainSim.StructData_pos_z_set, doc=r"""pos_z : std::vector<(double,std::allocator<(double)>)>""")
    particles = property(_libBornAgainSim.StructData_particles_get, _libBornAgainSim.StructData_particles_set, doc=r"""particles : std::vector<(ParticleData,std::allocator<(ParticleData)>)>""")
    mixture_weights = property(_libBornAgainSim.StructData_mixture_weights_get, _libBornAgainSim.StructData_mixture_weights_set, doc=r""" Per-mixture-group normalized variant weights, indexed as [group_id][variant_id].""")

    def __init__(self):
        r"""__init__(StructData self) -> StructData"""
        _libBornAgainSim.StructData_swiginit(self, _libBornAgainSim.new_StructData())
    __swig_destroy__ = _libBornAgainSim.delete_StructData

# Register StructData in _libBornAgainSim:
_libBornAgainSim.StructData_swigregister(StructData)
class LayerData(object):
    r""" Describes a layer in the 3D scene."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    material = property(_libBornAgainSim.LayerData_material_get, _libBornAgainSim.LayerData_material_set, doc=r"""material : std::string""")
    color = property(_libBornAgainSim.LayerData_color_get, _libBornAgainSim.LayerData_color_set, doc=r"""color : ColorRgba""")
    z_top = property(_libBornAgainSim.LayerData_z_top_get, _libBornAgainSim.LayerData_z_top_set, doc=r"""z_top : double""")
    z_bottom = property(_libBornAgainSim.LayerData_z_bottom_get, _libBornAgainSim.LayerData_z_bottom_set, doc=r"""z_bottom : double""")
    semi_infinite = property(_libBornAgainSim.LayerData_semi_infinite_get, _libBornAgainSim.LayerData_semi_infinite_set, doc=r"""semi_infinite : bool""")
    roughness_nx = property(_libBornAgainSim.LayerData_roughness_nx_get, _libBornAgainSim.LayerData_roughness_nx_set, doc=r"""roughness_nx : unsigned int""")
    roughness_ny = property(_libBornAgainSim.LayerData_roughness_ny_get, _libBornAgainSim.LayerData_roughness_ny_set, doc=r"""roughness_ny : unsigned int""")
    top_roughness = property(_libBornAgainSim.LayerData_top_roughness_get, _libBornAgainSim.LayerData_top_roughness_set, doc=r""" Row-major height offsets, in nm, for the layer top interface. Empty means flat.""")

    def __init__(self):
        r"""__init__(LayerData self) -> LayerData"""
        _libBornAgainSim.LayerData_swiginit(self, _libBornAgainSim.new_LayerData())
    __swig_destroy__ = _libBornAgainSim.delete_LayerData

# Register LayerData in _libBornAgainSim:
_libBornAgainSim.LayerData_swigregister(LayerData)
class SceneDescription(object):
    r""" Complete 3D scene geometry for a sample, ready for Python rendering."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    layers = property(_libBornAgainSim.SceneDescription_layers_get, _libBornAgainSim.SceneDescription_layers_set, doc=r"""layers : std::vector<(LayerData,std::allocator<(LayerData)>)>""")
    structs = property(_libBornAgainSim.SceneDescription_structs_get, _libBornAgainSim.SceneDescription_structs_set, doc=r"""structs : std::vector<(StructData,std::allocator<(StructData)>)>""")
    lateral_half_extent = property(_libBornAgainSim.SceneDescription_lateral_half_extent_get, _libBornAgainSim.SceneDescription_lateral_half_extent_set, doc=r"""lateral_half_extent : double""")

    def __init__(self):
        r"""__init__(SceneDescription self) -> SceneDescription"""
        _libBornAgainSim.SceneDescription_swiginit(self, _libBornAgainSim.new_SceneDescription())
    __swig_destroy__ = _libBornAgainSim.delete_SceneDescription

# Register SceneDescription in _libBornAgainSim:
_libBornAgainSim.SceneDescription_swigregister(SceneDescription)

def buildScene3D(sample, lateral_half_extent, seed=0, roughness_points=0):
    r"""
     Returns the 3D scene description for the given sample. :type lateral_half_extent: float
    :param lateral_half_extent:  Half side length of the visible sample patch. :type seed: int, optional
    :param seed:                 Base seed for random particle positions (disordered layouts).                             Different seeds produce different position configurations. :type roughness_points: int, optional
    :param roughness_points:     Points along each axis for rough interface maps; 0 disables them.                             Values above the supported display range are limited with a warning.
    """
    return _libBornAgainSim.buildScene3D(sample, lateral_half_extent, seed, roughness_points)
class ParticleDataVector(object):
    r"""Proxy of C++ std::vector< ParticleData > 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(ParticleDataVector self) -> SwigPyIterator"""
        return _libBornAgainSim.ParticleDataVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ParticleDataVector self) -> bool"""
        return _libBornAgainSim.ParticleDataVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ParticleDataVector self) -> bool"""
        return _libBornAgainSim.ParticleDataVector___bool__(self)

    def __len__(self):
        r"""__len__(ParticleDataVector self) -> std::vector< ParticleData >::size_type"""
        return _libBornAgainSim.ParticleDataVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(ParticleDataVector self, std::vector< ParticleData >::difference_type i, std::vector< ParticleData >::difference_type j) -> ParticleDataVector"""
        return _libBornAgainSim.ParticleDataVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(ParticleDataVector self, std::vector< ParticleData >::difference_type i, std::vector< ParticleData >::difference_type j)
        __setslice__(ParticleDataVector self, std::vector< ParticleData >::difference_type i, std::vector< ParticleData >::difference_type j, ParticleDataVector v)
        """
        return _libBornAgainSim.ParticleDataVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(ParticleDataVector self, std::vector< ParticleData >::difference_type i, std::vector< ParticleData >::difference_type j)"""
        return _libBornAgainSim.ParticleDataVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(ParticleDataVector self, std::vector< ParticleData >::difference_type i)
        __delitem__(ParticleDataVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.ParticleDataVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ParticleDataVector self, SWIGPY_SLICEOBJECT * slice) -> ParticleDataVector
        __getitem__(ParticleDataVector self, std::vector< ParticleData >::difference_type i) -> ParticleData
        """
        return _libBornAgainSim.ParticleDataVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ParticleDataVector self, SWIGPY_SLICEOBJECT * slice, ParticleDataVector v)
        __setitem__(ParticleDataVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(ParticleDataVector self, std::vector< ParticleData >::difference_type i, ParticleData x)
        """
        return _libBornAgainSim.ParticleDataVector___setitem__(self, *args)

    def pop(self):
        r"""pop(ParticleDataVector self) -> ParticleData"""
        return _libBornAgainSim.ParticleDataVector_pop(self)

    def append(self, x):
        r"""append(ParticleDataVector self, ParticleData x)"""
        return _libBornAgainSim.ParticleDataVector_append(self, x)

    def empty(self):
        r"""empty(ParticleDataVector self) -> bool"""
        return _libBornAgainSim.ParticleDataVector_empty(self)

    def size(self):
        r"""size(ParticleDataVector self) -> std::vector< ParticleData >::size_type"""
        return _libBornAgainSim.ParticleDataVector_size(self)

    def swap(self, v):
        r"""swap(ParticleDataVector self, ParticleDataVector v)"""
        return _libBornAgainSim.ParticleDataVector_swap(self, v)

    def begin(self):
        r"""begin(ParticleDataVector self) -> std::vector< ParticleData >::iterator"""
        return _libBornAgainSim.ParticleDataVector_begin(self)

    def end(self):
        r"""end(ParticleDataVector self) -> std::vector< ParticleData >::iterator"""
        return _libBornAgainSim.ParticleDataVector_end(self)

    def rbegin(self):
        r"""rbegin(ParticleDataVector self) -> std::vector< ParticleData >::reverse_iterator"""
        return _libBornAgainSim.ParticleDataVector_rbegin(self)

    def rend(self):
        r"""rend(ParticleDataVector self) -> std::vector< ParticleData >::reverse_iterator"""
        return _libBornAgainSim.ParticleDataVector_rend(self)

    def clear(self):
        r"""clear(ParticleDataVector self)"""
        return _libBornAgainSim.ParticleDataVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(ParticleDataVector self) -> std::vector< ParticleData >::allocator_type"""
        return _libBornAgainSim.ParticleDataVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ParticleDataVector self)"""
        return _libBornAgainSim.ParticleDataVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(ParticleDataVector self, std::vector< ParticleData >::iterator pos) -> std::vector< ParticleData >::iterator
        erase(ParticleDataVector self, std::vector< ParticleData >::iterator first, std::vector< ParticleData >::iterator last) -> std::vector< ParticleData >::iterator
        """
        return _libBornAgainSim.ParticleDataVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ParticleDataVector self) -> ParticleDataVector
        __init__(ParticleDataVector self, ParticleDataVector other) -> ParticleDataVector
        __init__(ParticleDataVector self, std::vector< ParticleData >::size_type size) -> ParticleDataVector
        __init__(ParticleDataVector self, std::vector< ParticleData >::size_type size, ParticleData value) -> ParticleDataVector
        """
        _libBornAgainSim.ParticleDataVector_swiginit(self, _libBornAgainSim.new_ParticleDataVector(*args))

    def push_back(self, x):
        r"""push_back(ParticleDataVector self, ParticleData x)"""
        return _libBornAgainSim.ParticleDataVector_push_back(self, x)

    def front(self):
        r"""front(ParticleDataVector self) -> ParticleData"""
        return _libBornAgainSim.ParticleDataVector_front(self)

    def back(self):
        r"""back(ParticleDataVector self) -> ParticleData"""
        return _libBornAgainSim.ParticleDataVector_back(self)

    def assign(self, n, x):
        r"""assign(ParticleDataVector self, std::vector< ParticleData >::size_type n, ParticleData x)"""
        return _libBornAgainSim.ParticleDataVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(ParticleDataVector self, std::vector< ParticleData >::size_type new_size)
        resize(ParticleDataVector self, std::vector< ParticleData >::size_type new_size, ParticleData x)
        """
        return _libBornAgainSim.ParticleDataVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ParticleDataVector self, std::vector< ParticleData >::iterator pos, ParticleData x) -> std::vector< ParticleData >::iterator
        insert(ParticleDataVector self, std::vector< ParticleData >::iterator pos, std::vector< ParticleData >::size_type n, ParticleData x)
        """
        return _libBornAgainSim.ParticleDataVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(ParticleDataVector self, std::vector< ParticleData >::size_type n)"""
        return _libBornAgainSim.ParticleDataVector_reserve(self, n)

    def capacity(self):
        r"""capacity(ParticleDataVector self) -> std::vector< ParticleData >::size_type"""
        return _libBornAgainSim.ParticleDataVector_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_ParticleDataVector

# Register ParticleDataVector in _libBornAgainSim:
_libBornAgainSim.ParticleDataVector_swigregister(ParticleDataVector)
class StructDataVector(object):
    r"""Proxy of C++ std::vector< StructData > 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(StructDataVector self) -> SwigPyIterator"""
        return _libBornAgainSim.StructDataVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StructDataVector self) -> bool"""
        return _libBornAgainSim.StructDataVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StructDataVector self) -> bool"""
        return _libBornAgainSim.StructDataVector___bool__(self)

    def __len__(self):
        r"""__len__(StructDataVector self) -> std::vector< StructData >::size_type"""
        return _libBornAgainSim.StructDataVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(StructDataVector self, std::vector< StructData >::difference_type i, std::vector< StructData >::difference_type j) -> StructDataVector"""
        return _libBornAgainSim.StructDataVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StructDataVector self, std::vector< StructData >::difference_type i, std::vector< StructData >::difference_type j)
        __setslice__(StructDataVector self, std::vector< StructData >::difference_type i, std::vector< StructData >::difference_type j, StructDataVector v)
        """
        return _libBornAgainSim.StructDataVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(StructDataVector self, std::vector< StructData >::difference_type i, std::vector< StructData >::difference_type j)"""
        return _libBornAgainSim.StructDataVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StructDataVector self, std::vector< StructData >::difference_type i)
        __delitem__(StructDataVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.StructDataVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StructDataVector self, SWIGPY_SLICEOBJECT * slice) -> StructDataVector
        __getitem__(StructDataVector self, std::vector< StructData >::difference_type i) -> StructData
        """
        return _libBornAgainSim.StructDataVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StructDataVector self, SWIGPY_SLICEOBJECT * slice, StructDataVector v)
        __setitem__(StructDataVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(StructDataVector self, std::vector< StructData >::difference_type i, StructData x)
        """
        return _libBornAgainSim.StructDataVector___setitem__(self, *args)

    def pop(self):
        r"""pop(StructDataVector self) -> StructData"""
        return _libBornAgainSim.StructDataVector_pop(self)

    def append(self, x):
        r"""append(StructDataVector self, StructData x)"""
        return _libBornAgainSim.StructDataVector_append(self, x)

    def empty(self):
        r"""empty(StructDataVector self) -> bool"""
        return _libBornAgainSim.StructDataVector_empty(self)

    def size(self):
        r"""size(StructDataVector self) -> std::vector< StructData >::size_type"""
        return _libBornAgainSim.StructDataVector_size(self)

    def swap(self, v):
        r"""swap(StructDataVector self, StructDataVector v)"""
        return _libBornAgainSim.StructDataVector_swap(self, v)

    def begin(self):
        r"""begin(StructDataVector self) -> std::vector< StructData >::iterator"""
        return _libBornAgainSim.StructDataVector_begin(self)

    def end(self):
        r"""end(StructDataVector self) -> std::vector< StructData >::iterator"""
        return _libBornAgainSim.StructDataVector_end(self)

    def rbegin(self):
        r"""rbegin(StructDataVector self) -> std::vector< StructData >::reverse_iterator"""
        return _libBornAgainSim.StructDataVector_rbegin(self)

    def rend(self):
        r"""rend(StructDataVector self) -> std::vector< StructData >::reverse_iterator"""
        return _libBornAgainSim.StructDataVector_rend(self)

    def clear(self):
        r"""clear(StructDataVector self)"""
        return _libBornAgainSim.StructDataVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(StructDataVector self) -> std::vector< StructData >::allocator_type"""
        return _libBornAgainSim.StructDataVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StructDataVector self)"""
        return _libBornAgainSim.StructDataVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StructDataVector self, std::vector< StructData >::iterator pos) -> std::vector< StructData >::iterator
        erase(StructDataVector self, std::vector< StructData >::iterator first, std::vector< StructData >::iterator last) -> std::vector< StructData >::iterator
        """
        return _libBornAgainSim.StructDataVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StructDataVector self) -> StructDataVector
        __init__(StructDataVector self, StructDataVector other) -> StructDataVector
        __init__(StructDataVector self, std::vector< StructData >::size_type size) -> StructDataVector
        __init__(StructDataVector self, std::vector< StructData >::size_type size, StructData value) -> StructDataVector
        """
        _libBornAgainSim.StructDataVector_swiginit(self, _libBornAgainSim.new_StructDataVector(*args))

    def push_back(self, x):
        r"""push_back(StructDataVector self, StructData x)"""
        return _libBornAgainSim.StructDataVector_push_back(self, x)

    def front(self):
        r"""front(StructDataVector self) -> StructData"""
        return _libBornAgainSim.StructDataVector_front(self)

    def back(self):
        r"""back(StructDataVector self) -> StructData"""
        return _libBornAgainSim.StructDataVector_back(self)

    def assign(self, n, x):
        r"""assign(StructDataVector self, std::vector< StructData >::size_type n, StructData x)"""
        return _libBornAgainSim.StructDataVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StructDataVector self, std::vector< StructData >::size_type new_size)
        resize(StructDataVector self, std::vector< StructData >::size_type new_size, StructData x)
        """
        return _libBornAgainSim.StructDataVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(StructDataVector self, std::vector< StructData >::iterator pos, StructData x) -> std::vector< StructData >::iterator
        insert(StructDataVector self, std::vector< StructData >::iterator pos, std::vector< StructData >::size_type n, StructData x)
        """
        return _libBornAgainSim.StructDataVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(StructDataVector self, std::vector< StructData >::size_type n)"""
        return _libBornAgainSim.StructDataVector_reserve(self, n)

    def capacity(self):
        r"""capacity(StructDataVector self) -> std::vector< StructData >::size_type"""
        return _libBornAgainSim.StructDataVector_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_StructDataVector

# Register StructDataVector in _libBornAgainSim:
_libBornAgainSim.StructDataVector_swigregister(StructDataVector)
class LayerDataVector(object):
    r"""Proxy of C++ std::vector< LayerData > 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(LayerDataVector self) -> SwigPyIterator"""
        return _libBornAgainSim.LayerDataVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(LayerDataVector self) -> bool"""
        return _libBornAgainSim.LayerDataVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(LayerDataVector self) -> bool"""
        return _libBornAgainSim.LayerDataVector___bool__(self)

    def __len__(self):
        r"""__len__(LayerDataVector self) -> std::vector< LayerData >::size_type"""
        return _libBornAgainSim.LayerDataVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(LayerDataVector self, std::vector< LayerData >::difference_type i, std::vector< LayerData >::difference_type j) -> LayerDataVector"""
        return _libBornAgainSim.LayerDataVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(LayerDataVector self, std::vector< LayerData >::difference_type i, std::vector< LayerData >::difference_type j)
        __setslice__(LayerDataVector self, std::vector< LayerData >::difference_type i, std::vector< LayerData >::difference_type j, LayerDataVector v)
        """
        return _libBornAgainSim.LayerDataVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(LayerDataVector self, std::vector< LayerData >::difference_type i, std::vector< LayerData >::difference_type j)"""
        return _libBornAgainSim.LayerDataVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(LayerDataVector self, std::vector< LayerData >::difference_type i)
        __delitem__(LayerDataVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.LayerDataVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(LayerDataVector self, SWIGPY_SLICEOBJECT * slice) -> LayerDataVector
        __getitem__(LayerDataVector self, std::vector< LayerData >::difference_type i) -> LayerData
        """
        return _libBornAgainSim.LayerDataVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(LayerDataVector self, SWIGPY_SLICEOBJECT * slice, LayerDataVector v)
        __setitem__(LayerDataVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(LayerDataVector self, std::vector< LayerData >::difference_type i, LayerData x)
        """
        return _libBornAgainSim.LayerDataVector___setitem__(self, *args)

    def pop(self):
        r"""pop(LayerDataVector self) -> LayerData"""
        return _libBornAgainSim.LayerDataVector_pop(self)

    def append(self, x):
        r"""append(LayerDataVector self, LayerData x)"""
        return _libBornAgainSim.LayerDataVector_append(self, x)

    def empty(self):
        r"""empty(LayerDataVector self) -> bool"""
        return _libBornAgainSim.LayerDataVector_empty(self)

    def size(self):
        r"""size(LayerDataVector self) -> std::vector< LayerData >::size_type"""
        return _libBornAgainSim.LayerDataVector_size(self)

    def swap(self, v):
        r"""swap(LayerDataVector self, LayerDataVector v)"""
        return _libBornAgainSim.LayerDataVector_swap(self, v)

    def begin(self):
        r"""begin(LayerDataVector self) -> std::vector< LayerData >::iterator"""
        return _libBornAgainSim.LayerDataVector_begin(self)

    def end(self):
        r"""end(LayerDataVector self) -> std::vector< LayerData >::iterator"""
        return _libBornAgainSim.LayerDataVector_end(self)

    def rbegin(self):
        r"""rbegin(LayerDataVector self) -> std::vector< LayerData >::reverse_iterator"""
        return _libBornAgainSim.LayerDataVector_rbegin(self)

    def rend(self):
        r"""rend(LayerDataVector self) -> std::vector< LayerData >::reverse_iterator"""
        return _libBornAgainSim.LayerDataVector_rend(self)

    def clear(self):
        r"""clear(LayerDataVector self)"""
        return _libBornAgainSim.LayerDataVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(LayerDataVector self) -> std::vector< LayerData >::allocator_type"""
        return _libBornAgainSim.LayerDataVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(LayerDataVector self)"""
        return _libBornAgainSim.LayerDataVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(LayerDataVector self, std::vector< LayerData >::iterator pos) -> std::vector< LayerData >::iterator
        erase(LayerDataVector self, std::vector< LayerData >::iterator first, std::vector< LayerData >::iterator last) -> std::vector< LayerData >::iterator
        """
        return _libBornAgainSim.LayerDataVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(LayerDataVector self) -> LayerDataVector
        __init__(LayerDataVector self, LayerDataVector other) -> LayerDataVector
        __init__(LayerDataVector self, std::vector< LayerData >::size_type size) -> LayerDataVector
        __init__(LayerDataVector self, std::vector< LayerData >::size_type size, LayerData value) -> LayerDataVector
        """
        _libBornAgainSim.LayerDataVector_swiginit(self, _libBornAgainSim.new_LayerDataVector(*args))

    def push_back(self, x):
        r"""push_back(LayerDataVector self, LayerData x)"""
        return _libBornAgainSim.LayerDataVector_push_back(self, x)

    def front(self):
        r"""front(LayerDataVector self) -> LayerData"""
        return _libBornAgainSim.LayerDataVector_front(self)

    def back(self):
        r"""back(LayerDataVector self) -> LayerData"""
        return _libBornAgainSim.LayerDataVector_back(self)

    def assign(self, n, x):
        r"""assign(LayerDataVector self, std::vector< LayerData >::size_type n, LayerData x)"""
        return _libBornAgainSim.LayerDataVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(LayerDataVector self, std::vector< LayerData >::size_type new_size)
        resize(LayerDataVector self, std::vector< LayerData >::size_type new_size, LayerData x)
        """
        return _libBornAgainSim.LayerDataVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(LayerDataVector self, std::vector< LayerData >::iterator pos, LayerData x) -> std::vector< LayerData >::iterator
        insert(LayerDataVector self, std::vector< LayerData >::iterator pos, std::vector< LayerData >::size_type n, LayerData x)
        """
        return _libBornAgainSim.LayerDataVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(LayerDataVector self, std::vector< LayerData >::size_type n)"""
        return _libBornAgainSim.LayerDataVector_reserve(self, n)

    def capacity(self):
        r"""capacity(LayerDataVector self) -> std::vector< LayerData >::size_type"""
        return _libBornAgainSim.LayerDataVector_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_LayerDataVector

# Register LayerDataVector in _libBornAgainSim:
_libBornAgainSim.LayerDataVector_swigregister(LayerDataVector)
class IntensityFunction(object):
    r""" Interface for applying arbitrary function to the measured intensity."""

    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__ = _libBornAgainSim.delete_IntensityFunction

    def evaluate(self, value):
        r"""evaluate(IntensityFunction self, double value) -> double"""
        return _libBornAgainSim.IntensityFunction_evaluate(self, value)

# Register IntensityFunction in _libBornAgainSim:
_libBornAgainSim.IntensityFunction_swigregister(IntensityFunction)
class IntensityFunctionLog(IntensityFunction):
    r""" Algorithm for applying log function to the measured intensity."""

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

    def __init__(self):
        r"""__init__(IntensityFunctionLog self) -> IntensityFunctionLog"""
        _libBornAgainSim.IntensityFunctionLog_swiginit(self, _libBornAgainSim.new_IntensityFunctionLog())
    __swig_destroy__ = _libBornAgainSim.delete_IntensityFunctionLog

# Register IntensityFunctionLog in _libBornAgainSim:
_libBornAgainSim.IntensityFunctionLog_swigregister(IntensityFunctionLog)
class IntensityFunctionSqrt(IntensityFunction):
    r""" Algorithm for applying sqrt function to the measured intensity."""

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

    def __init__(self):
        r"""__init__(IntensityFunctionSqrt self) -> IntensityFunctionSqrt"""
        _libBornAgainSim.IntensityFunctionSqrt_swiginit(self, _libBornAgainSim.new_IntensityFunctionSqrt())
    __swig_destroy__ = _libBornAgainSim.delete_IntensityFunctionSqrt

# Register IntensityFunctionSqrt in _libBornAgainSim:
_libBornAgainSim.IntensityFunctionSqrt_swigregister(IntensityFunctionSqrt)
class ChiSquaredModule(object):
    r""" Calculation of chi2 between two data sets."""

    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__(ChiSquaredModule self) -> ChiSquaredModule
        __init__(ChiSquaredModule self, ChiSquaredModule other) -> ChiSquaredModule
        """
        _libBornAgainSim.ChiSquaredModule_swiginit(self, _libBornAgainSim.new_ChiSquaredModule(*args))
    __swig_destroy__ = _libBornAgainSim.delete_ChiSquaredModule

    def varianceFunction(self):
        r""" Returns variance function."""
        return _libBornAgainSim.ChiSquaredModule_varianceFunction(self)

    def setVarianceFunction(self, variance_function):
        r""" Sets variance function."""
        return _libBornAgainSim.ChiSquaredModule_setVarianceFunction(self, variance_function)

    def intensityFunction(self):
        r""" Returns data rescaler."""
        return _libBornAgainSim.ChiSquaredModule_intensityFunction(self)

    def setIntensityFunction(self, intensity_function):
        r""" Sets data rescaler."""
        return _libBornAgainSim.ChiSquaredModule_setIntensityFunction(self, intensity_function)

    def residual(self, a, b):
        r"""residual(ChiSquaredModule self, double a, double b) -> double"""
        return _libBornAgainSim.ChiSquaredModule_residual(self, a, b)

# Register ChiSquaredModule in _libBornAgainSim:
_libBornAgainSim.ChiSquaredModule_swigregister(ChiSquaredModule)
class VarianceFunction(object):
    r""" Variance function interface."""

    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__ = _libBornAgainSim.delete_VarianceFunction

    def variance(self, real_value, simulated_value):
        r"""variance(VarianceFunction self, double real_value, double simulated_value) -> double"""
        return _libBornAgainSim.VarianceFunction_variance(self, real_value, simulated_value)

# Register VarianceFunction in _libBornAgainSim:
_libBornAgainSim.VarianceFunction_swigregister(VarianceFunction)
class VarianceConstantFunction(VarianceFunction):
    r""" Returns 1.0 as variance value"""

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

    def __init__(self):
        r"""__init__(VarianceConstantFunction self) -> VarianceConstantFunction"""
        _libBornAgainSim.VarianceConstantFunction_swiginit(self, _libBornAgainSim.new_VarianceConstantFunction())
    __swig_destroy__ = _libBornAgainSim.delete_VarianceConstantFunction

# Register VarianceConstantFunction in _libBornAgainSim:
_libBornAgainSim.VarianceConstantFunction_swigregister(VarianceConstantFunction)
class VarianceSimFunction(VarianceFunction):
    r""" Returns max(sim, epsilon)"""

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

    def __init__(self, epsilon=1.0):
        r"""__init__(VarianceSimFunction self, double epsilon=1.0) -> VarianceSimFunction"""
        _libBornAgainSim.VarianceSimFunction_swiginit(self, _libBornAgainSim.new_VarianceSimFunction(epsilon))

    def variance(self, exp, sim):
        r"""variance(VarianceSimFunction self, double exp, double sim) -> double"""
        return _libBornAgainSim.VarianceSimFunction_variance(self, exp, sim)
    __swig_destroy__ = _libBornAgainSim.delete_VarianceSimFunction

# Register VarianceSimFunction in _libBornAgainSim:
_libBornAgainSim.VarianceSimFunction_swigregister(VarianceSimFunction)

