# 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__)


import weakref

class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _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)
SHARED_PTR_DISOWN = _libBornAgainSim.SHARED_PTR_DISOWN


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

class vdouble1d_t(object):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(vdouble1d_t self) -> SwigPyIterator"""
        return _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 libBornAgainFit
import libBornAgainBase
class R3(object):
    r"""Proxy of C++ Vec3< double > class."""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def rotatedZ(self, a):
        r"""rotatedZ(R3 self, double a) -> R3"""
        return _libBornAgainSim.R3_rotatedZ(self, a)

    def __add__(self, rhs):
        r"""__add__(R3 self, R3 rhs) -> R3"""
        return _libBornAgainSim.R3___add__(self, rhs)

    def __mul__(self, c):
        r"""__mul__(R3 self, double c) -> R3"""
        return _libBornAgainSim.R3___mul__(self, c)

    def __rmul__(self, c):
        r"""__rmul__(R3 self, double c) -> R3"""
        return _libBornAgainSim.R3___rmul__(self, c)

    def __neg__(self):
        r"""__neg__(R3 self) -> R3"""
        return _libBornAgainSim.R3___neg__(self)
    __swig_destroy__ = _libBornAgainSim.delete_R3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register C3 in _libBornAgainSim:
_libBornAgainSim.C3_swigregister(C3)
class vector_R3(object):
    r"""Proxy of C++ std::vector< Vec3< double > > class."""

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

    def iterator(self):
        r"""iterator(vector_R3 self) -> SwigPyIterator"""
        return _libBornAgainSim.vector_R3_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register vector_R3 in _libBornAgainSim:
_libBornAgainSim.vector_R3_swigregister(vector_R3)
import libBornAgainParam
import libBornAgainSample
import libBornAgainDevice
class swig_dummy_type_const_inode_vector(object):
    r"""Proxy of C++ std::vector< INode const * > 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(swig_dummy_type_const_inode_vector self) -> SwigPyIterator"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(swig_dummy_type_const_inode_vector self) -> bool"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(swig_dummy_type_const_inode_vector self) -> bool"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___bool__(self)

    def __len__(self):
        r"""__len__(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::size_type"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j)
        __setslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j, swig_dummy_type_const_inode_vector v)
        """
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)
        __delitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector
        __getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode
        """
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice, swig_dummy_type_const_inode_vector v)
        __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)
        """
        return _libBornAgainSim.swig_dummy_type_const_inode_vector___setitem__(self, *args)

    def pop(self):
        r"""pop(swig_dummy_type_const_inode_vector self) -> INode"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_pop(self)

    def append(self, x):
        r"""append(swig_dummy_type_const_inode_vector self, INode x)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_append(self, x)

    def empty(self):
        r"""empty(swig_dummy_type_const_inode_vector self) -> bool"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_empty(self)

    def size(self):
        r"""size(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::size_type"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_size(self)

    def swap(self, v):
        r"""swap(swig_dummy_type_const_inode_vector self, swig_dummy_type_const_inode_vector v)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_swap(self, v)

    def begin(self):
        r"""begin(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::iterator"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_begin(self)

    def end(self):
        r"""end(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::iterator"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_end(self)

    def rbegin(self):
        r"""rbegin(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::reverse_iterator"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_rbegin(self)

    def rend(self):
        r"""rend(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::reverse_iterator"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_rend(self)

    def clear(self):
        r"""clear(swig_dummy_type_const_inode_vector self)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_clear(self)

    def get_allocator(self):
        r"""get_allocator(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::allocator_type"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(swig_dummy_type_const_inode_vector self)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator pos) -> std::vector< INode const * >::iterator
        erase(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator first, std::vector< INode const * >::iterator last) -> std::vector< INode const * >::iterator
        """
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(swig_dummy_type_const_inode_vector self) -> swig_dummy_type_const_inode_vector
        __init__(swig_dummy_type_const_inode_vector self, swig_dummy_type_const_inode_vector other) -> swig_dummy_type_const_inode_vector
        __init__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type size) -> swig_dummy_type_const_inode_vector
        __init__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type size, INode value) -> swig_dummy_type_const_inode_vector
        """
        _libBornAgainSim.swig_dummy_type_const_inode_vector_swiginit(self, _libBornAgainSim.new_swig_dummy_type_const_inode_vector(*args))

    def push_back(self, x):
        r"""push_back(swig_dummy_type_const_inode_vector self, INode x)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_push_back(self, x)

    def front(self):
        r"""front(swig_dummy_type_const_inode_vector self) -> INode"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_front(self)

    def back(self):
        r"""back(swig_dummy_type_const_inode_vector self) -> INode"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_back(self)

    def assign(self, n, x):
        r"""assign(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type n, INode x)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type new_size)
        resize(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type new_size, INode x)
        """
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator pos, INode x) -> std::vector< INode const * >::iterator
        insert(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::iterator pos, std::vector< INode const * >::size_type n, INode x)
        """
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::size_type n)"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_reserve(self, n)

    def capacity(self):
        r"""capacity(swig_dummy_type_const_inode_vector self) -> std::vector< INode const * >::size_type"""
        return _libBornAgainSim.swig_dummy_type_const_inode_vector_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_swig_dummy_type_const_inode_vector

# Register swig_dummy_type_const_inode_vector in _libBornAgainSim:
_libBornAgainSim.swig_dummy_type_const_inode_vector_swigregister(swig_dummy_type_const_inode_vector)

def GetMajorVersionNumber():
    r"""GetMajorVersionNumber() -> int"""
    return _libBornAgainSim.GetMajorVersionNumber()

def GetMinorVersionNumber():
    r"""GetMinorVersionNumber() -> int"""
    return _libBornAgainSim.GetMinorVersionNumber()

def GetName():
    r"""GetName() -> std::string"""
    return _libBornAgainSim.GetName()

def GetVersionNumber():
    r"""GetVersionNumber() -> std::string"""
    return _libBornAgainSim.GetVersionNumber()
class IterationInfo(object):
    r"""Proxy of C++ IterationInfo class."""

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

    def __init__(self):
        r"""__init__(IterationInfo self) -> IterationInfo"""
        _libBornAgainSim.IterationInfo_swiginit(self, _libBornAgainSim.new_IterationInfo())

    def update(self, params, chi2):
        r"""update(IterationInfo self, mumufit::Parameters const & params, double chi2)"""
        return _libBornAgainSim.IterationInfo_update(self, params, chi2)

    def iterationCount(self):
        r"""iterationCount(IterationInfo self) -> unsigned int"""
        return _libBornAgainSim.IterationInfo_iterationCount(self)

    def chi2(self):
        r"""chi2(IterationInfo self) -> double"""
        return _libBornAgainSim.IterationInfo_chi2(self)

    def parameters(self):
        r"""parameters(IterationInfo self) -> mumufit::Parameters"""
        return _libBornAgainSim.IterationInfo_parameters(self)

    def parameterMap(self):
        r"""parameterMap(IterationInfo self) -> map_string_double_t"""
        return _libBornAgainSim.IterationInfo_parameterMap(self)
    __swig_destroy__ = _libBornAgainSim.delete_IterationInfo

# Register IterationInfo in _libBornAgainSim:
_libBornAgainSim.IterationInfo_swigregister(IterationInfo)
cvar = _libBornAgainSim.cvar
major_version_number = cvar.major_version_number
minor_version_number = cvar.minor_version_number

class PyBuilderCallback(object):
    r"""Proxy of C++ PyBuilderCallback class."""

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

    def __init__(self):
        r"""__init__(PyBuilderCallback self) -> PyBuilderCallback"""
        if self.__class__ == PyBuilderCallback:
            _self = None
        else:
            _self = self
        _libBornAgainSim.PyBuilderCallback_swiginit(self, _libBornAgainSim.new_PyBuilderCallback(_self, ))
    __swig_destroy__ = _libBornAgainSim.delete_PyBuilderCallback

    def build_simulation(self, arg0):
        r"""build_simulation(PyBuilderCallback self, mumufit::Parameters const & arg0) -> ISimulation"""
        return _libBornAgainSim.PyBuilderCallback_build_simulation(self, arg0)
    def __disown__(self):
        self.this.disown()
        _libBornAgainSim.disown_PyBuilderCallback(self)
        return weakref.proxy(self)

# Register PyBuilderCallback in _libBornAgainSim:
_libBornAgainSim.PyBuilderCallback_swigregister(PyBuilderCallback)
class PyObserverCallback(object):
    r"""Proxy of C++ PyObserverCallback class."""

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

    def __init__(self):
        r"""__init__(PyObserverCallback self) -> PyObserverCallback"""
        if self.__class__ == PyObserverCallback:
            _self = None
        else:
            _self = self
        _libBornAgainSim.PyObserverCallback_swiginit(self, _libBornAgainSim.new_PyObserverCallback(_self, ))
    __swig_destroy__ = _libBornAgainSim.delete_PyObserverCallback

    def update(self, arg0):
        r"""update(PyObserverCallback self, FitObjective arg0)"""
        return _libBornAgainSim.PyObserverCallback_update(self, arg0)
    def __disown__(self):
        self.this.disown()
        _libBornAgainSim.disown_PyObserverCallback(self)
        return weakref.proxy(self)

# Register PyObserverCallback in _libBornAgainSim:
_libBornAgainSim.PyObserverCallback_swigregister(PyObserverCallback)
class FitObjective(object):
    r"""Proxy of C++ FitObjective class."""

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

    def __init__(self):
        r"""__init__(FitObjective self) -> FitObjective"""
        if self.__class__ == FitObjective:
            _self = None
        else:
            _self = self
        _libBornAgainSim.FitObjective_swiginit(self, _libBornAgainSim.new_FitObjective(_self, ))
    __swig_destroy__ = _libBornAgainSim.delete_FitObjective

    def addFitPair_cpp(self, callback, expData, weight=1.0):
        r"""addFitPair_cpp(FitObjective self, PyBuilderCallback callback, Datafield expData, double weight=1.0)"""
        return _libBornAgainSim.FitObjective_addFitPair_cpp(self, callback, expData, weight)

    def evaluate_cpp(self, params):
        r"""evaluate_cpp(FitObjective self, mumufit::Parameters const & params) -> double"""
        return _libBornAgainSim.FitObjective_evaluate_cpp(self, params)

    def evaluate_residuals_cpp(self, params):
        r"""evaluate_residuals_cpp(FitObjective self, mumufit::Parameters const & params) -> vdouble1d_t"""
        return _libBornAgainSim.FitObjective_evaluate_residuals_cpp(self, params)

    def simulationResult(self, i_item=0):
        r"""simulationResult(FitObjective self, size_t i_item=0) -> Datafield"""
        return _libBornAgainSim.FitObjective_simulationResult(self, i_item)

    def experimentalData(self, i_item=0):
        r"""experimentalData(FitObjective self, size_t i_item=0) -> Datafield"""
        return _libBornAgainSim.FitObjective_experimentalData(self, i_item)

    def relativeDifference(self, i_item=0):
        r"""relativeDifference(FitObjective self, size_t i_item=0) -> Datafield"""
        return _libBornAgainSim.FitObjective_relativeDifference(self, i_item)

    def absoluteDifference(self, i_item=0):
        r"""absoluteDifference(FitObjective self, size_t i_item=0) -> Datafield"""
        return _libBornAgainSim.FitObjective_absoluteDifference(self, i_item)

    def flatExpData(self):
        r"""flatExpData(FitObjective self) -> vdouble1d_t"""
        return _libBornAgainSim.FitObjective_flatExpData(self)

    def flatSimData(self):
        r"""flatSimData(FitObjective self) -> vdouble1d_t"""
        return _libBornAgainSim.FitObjective_flatSimData(self)

    def initPrint(self, every_nth):
        r"""initPrint(FitObjective self, int every_nth)"""
        return _libBornAgainSim.FitObjective_initPrint(self, every_nth)

    def initPlot_cpp(self, every_nth, callback):
        r"""initPlot_cpp(FitObjective self, int every_nth, PyObserverCallback callback)"""
        return _libBornAgainSim.FitObjective_initPlot_cpp(self, every_nth, callback)

    def iterationInfo(self):
        r"""iterationInfo(FitObjective self) -> IterationInfo"""
        return _libBornAgainSim.FitObjective_iterationInfo(self)

    def minimizerResult(self):
        r"""minimizerResult(FitObjective self) -> mumufit::MinimizerResult"""
        return _libBornAgainSim.FitObjective_minimizerResult(self)

    def finalize_cpp(self, result):
        r"""finalize_cpp(FitObjective self, mumufit::MinimizerResult const & result)"""
        return _libBornAgainSim.FitObjective_finalize_cpp(self, result)

    def fitObjectCount(self):
        r"""fitObjectCount(FitObjective self) -> unsigned int"""
        return _libBornAgainSim.FitObjective_fitObjectCount(self)

    def execSimulations(self, params):
        r"""execSimulations(FitObjective self, mumufit::Parameters const & params)"""
        return _libBornAgainSim.FitObjective_execSimulations(self, params)

    def setChiSquaredModule(self, module):
        r"""setChiSquaredModule(FitObjective self, IChiSquaredModule module)"""
        return _libBornAgainSim.FitObjective_setChiSquaredModule(self, module)

    def setObjectiveMetric(self, *args):
        r"""
        setObjectiveMetric(FitObjective self, std::string const & metric)
        setObjectiveMetric(FitObjective self, std::string const & metric, std::string const & norm)
        """
        return _libBornAgainSim.FitObjective_setObjectiveMetric(self, *args)

    def containsUncertainties_cpp(self, i_item):
        r"""containsUncertainties_cpp(FitObjective self, size_t i_item) -> bool"""
        return _libBornAgainSim.FitObjective_containsUncertainties_cpp(self, i_item)

    def allPairsHaveUncertainties_cpp(self):
        r"""allPairsHaveUncertainties_cpp(FitObjective self) -> bool"""
        return _libBornAgainSim.FitObjective_allPairsHaveUncertainties_cpp(self)

    def addSimulationAndData(self, callback, data, *args, **kwargs):
        raise Exception(
              "Function FitObjective.addSimulationAndData has been replaced in BornAgain 22\n"
              "by function FitObjective.addFitPair, which takes experimental data"
              " in form of a Datafield\n"
              "instead of NumPy arrays. For usage, see the fit examples in the online docs.")

    def addFitPair(self, callback, expData, *args):
        """
        Sets simulation and experimental data to the fit objective.
        Optionally accepts experimental data uncertainties and
        user-defined dataset weight.

        Arguments:

        callback -- user-defined function returning fully-defined bornagain.ISimulation object.
        The function must use fit parameter dictionary as its input.

        expData -- Datafield containing experimental data.

        weight -- user-defined weight of the dataset. If not specified, defaults to 1.0.
        """
        if not hasattr(self, 'callback_container'):
            self.callback_container = []
        wrp = SimulationBuilderWrapper(callback)
        self.callback_container.append(wrp) # needed ???
        return self.addFitPair_cpp(wrp, expData, *args)

    def convert_params(self, params):
        """
        Converts parameters to what FitObjective::evaluate expects
        """

        if str(params.__module__) == "lmfit.parameter":
            bapars = libBornAgainFit.Parameters()
            for p in params:
                bapars.add(p, params[p].value)
            return bapars
        else:
            return params

    def evaluate_residuals(self, params):
        return self.evaluate_residuals_cpp(self.convert_params(params))

    def evaluate(self, params):
        return self.evaluate_cpp(self.convert_params(params))

    def convert_result(self, minim_result):
        """
        Converts result reported by arbitrary minimizer to ba.MinimizerResult
        """

        if str(minim_result.__module__) == "lmfit.minimizer":
            return libBornAgainFit.MinimizerResult()
        else:
            return minim_result

    def finalize(self, minimizer_result):
        return self.finalize_cpp(self.convert_result(minimizer_result))

    def initPlot(self, every_nth, callback):
        self.wrp_plot_observer = ObserverCallbackWrapper(callback)
        return self.initPlot_cpp(every_nth, self.wrp_plot_observer)

    def __disown__(self):
        self.this.disown()
        _libBornAgainSim.disown_FitObjective(self)
        return weakref.proxy(self)

# Register FitObjective in _libBornAgainSim:
_libBornAgainSim.FitObjective_swigregister(FitObjective)
class BeamScan(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""Proxy of C++ BeamScan 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_BeamScan

    def clone(self):
        r"""clone(BeamScan self) -> BeamScan"""
        return _libBornAgainSim.BeamScan_clone(self)

    def nodeChildren(self):
        r"""nodeChildren(BeamScan self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSim.BeamScan_nodeChildren(self)

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

    def setIntensityAt(self, i, intensity):
        r"""setIntensityAt(BeamScan self, size_t i, double intensity)"""
        return _libBornAgainSim.BeamScan_setIntensityAt(self, i, intensity)

    def setPolarization(self, bloch_vector):
        r"""setPolarization(BeamScan self, R3 bloch_vector)"""
        return _libBornAgainSim.BeamScan_setPolarization(self, bloch_vector)

    def setPolarizationAt(self, i, bloch_vector):
        r"""setPolarizationAt(BeamScan self, size_t i, R3 bloch_vector)"""
        return _libBornAgainSim.BeamScan_setPolarizationAt(self, i, bloch_vector)

    def setFootprint(self, footprint):
        r"""setFootprint(BeamScan self, IFootprint const * footprint)"""
        return _libBornAgainSim.BeamScan_setFootprint(self, footprint)

    def setFootprintAt(self, i, footprint):
        r"""setFootprintAt(BeamScan self, size_t i, IFootprint const * footprint)"""
        return _libBornAgainSim.BeamScan_setFootprintAt(self, i, footprint)

    def setAnalyzer(self, *args):
        r"""setAnalyzer(BeamScan self, R3 Bloch_vector={}, double mean_transmission=0.5)"""
        return _libBornAgainSim.BeamScan_setAnalyzer(self, *args)

# Register BeamScan in _libBornAgainSim:
_libBornAgainSim.BeamScan_swigregister(BeamScan)
class PhysicalScan(BeamScan):
    r"""Proxy of C++ PhysicalScan 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_PhysicalScan

    def clone(self):
        r"""clone(PhysicalScan self) -> PhysicalScan"""
        return _libBornAgainSim.PhysicalScan_clone(self)

    def nodeChildren(self):
        r"""nodeChildren(PhysicalScan self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSim.PhysicalScan_nodeChildren(self)

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

    def setWavelengthAt(self, i, _lambda):
        r"""setWavelengthAt(PhysicalScan self, size_t i, double _lambda)"""
        return _libBornAgainSim.PhysicalScan_setWavelengthAt(self, i, _lambda)

    def setWavelengthDistribution(self, distr):
        r"""setWavelengthDistribution(PhysicalScan self, IDistribution1D const & distr)"""
        return _libBornAgainSim.PhysicalScan_setWavelengthDistribution(self, distr)

    def setInclination(self, alpha):
        r"""setInclination(PhysicalScan self, double alpha)"""
        return _libBornAgainSim.PhysicalScan_setInclination(self, alpha)

    def setInclinationAt(self, i, alpha):
        r"""setInclinationAt(PhysicalScan self, size_t i, double alpha)"""
        return _libBornAgainSim.PhysicalScan_setInclinationAt(self, i, alpha)

    def setAngleDistribution(self, distr):
        r"""setAngleDistribution(PhysicalScan self, IDistribution1D const & distr)"""
        return _libBornAgainSim.PhysicalScan_setAngleDistribution(self, distr)

# Register PhysicalScan in _libBornAgainSim:
_libBornAgainSim.PhysicalScan_swigregister(PhysicalScan)
class AlphaScan(PhysicalScan):
    r"""Proxy of C++ AlphaScan 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__(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 clone(self):
        r"""clone(AlphaScan self) -> AlphaScan"""
        return _libBornAgainSim.AlphaScan_clone(self)

    def className(self):
        r"""className(AlphaScan self) -> std::string"""
        return _libBornAgainSim.AlphaScan_className(self)

    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"""Proxy of C++ LambdaScan 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__(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

    def clone(self):
        r"""clone(LambdaScan self) -> LambdaScan"""
        return _libBornAgainSim.LambdaScan_clone(self)

    def className(self):
        r"""className(LambdaScan self) -> std::string"""
        return _libBornAgainSim.LambdaScan_className(self)

# Register LambdaScan in _libBornAgainSim:
_libBornAgainSim.LambdaScan_swigregister(LambdaScan)
class QzScan(BeamScan):
    r"""Proxy of C++ QzScan 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__(QzScan self, vdouble1d_t qs_nm) -> QzScan
        __init__(QzScan self, Scale qs_nm) -> QzScan
        __init__(QzScan self, int nbins, double qz_min, double qz_max) -> QzScan
        """
        _libBornAgainSim.QzScan_swiginit(self, _libBornAgainSim.new_QzScan(*args))
    __swig_destroy__ = _libBornAgainSim.delete_QzScan

    def clone(self):
        r"""clone(QzScan self) -> QzScan"""
        return _libBornAgainSim.QzScan_clone(self)

    def className(self):
        r"""className(QzScan self) -> std::string"""
        return _libBornAgainSim.QzScan_className(self)

    def nodeChildren(self):
        r"""nodeChildren(QzScan self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSim.QzScan_nodeChildren(self)

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

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

    def setVectorResolution(self, distr, std_devs):
        r"""setVectorResolution(QzScan self, IDistribution1D const & distr, vdouble1d_t std_devs)"""
        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 ISimulation(libBornAgainParam.INode):
    r"""Proxy of C++ ISimulation 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_ISimulation

    def setBackground(self, bg):
        r"""setBackground(ISimulation self, IBackground bg)"""
        return _libBornAgainSim.ISimulation_setBackground(self, bg)

    def addParameterDistribution(self, whichParameter, distribution):
        r"""addParameterDistribution(ISimulation self, ParameterDistribution::WhichParameter whichParameter, IDistribution1D const & distribution)"""
        return _libBornAgainSim.ISimulation_addParameterDistribution(self, whichParameter, distribution)

    def setTerminalProgressMonitor(self):
        r"""setTerminalProgressMonitor(ISimulation self)"""
        return _libBornAgainSim.ISimulation_setTerminalProgressMonitor(self)

    def options(self):
        r"""options(ISimulation self) -> SimulationOptions &"""
        return _libBornAgainSim.ISimulation_options(self)

    def simulate(self):
        r"""simulate(ISimulation self) -> Datafield"""
        return _libBornAgainSim.ISimulation_simulate(self)

# Register ISimulation in _libBornAgainSim:
_libBornAgainSim.ISimulation_swigregister(ISimulation)
class ScatteringSimulation(ISimulation):
    r"""Proxy of C++ ScatteringSimulation 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, beam, sample, detector):
        r"""__init__(ScatteringSimulation self, Beam const & beam, MultiLayer const & sample, IDetector const & detector) -> ScatteringSimulation"""
        _libBornAgainSim.ScatteringSimulation_swiginit(self, _libBornAgainSim.new_ScatteringSimulation(beam, sample, detector))
    __swig_destroy__ = _libBornAgainSim.delete_ScatteringSimulation

    def className(self):
        r"""className(ScatteringSimulation self) -> std::string"""
        return _libBornAgainSim.ScatteringSimulation_className(self)

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

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

# Register ScatteringSimulation in _libBornAgainSim:
_libBornAgainSim.ScatteringSimulation_swigregister(ScatteringSimulation)
class DepthprobeSimulation(ISimulation):
    r"""Proxy of C++ DepthprobeSimulation 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, scan, sample, zaxis, flags=0):
        r"""__init__(DepthprobeSimulation self, BeamScan scan, MultiLayer 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 className(self):
        r"""className(DepthprobeSimulation self) -> std::string"""
        return _libBornAgainSim.DepthprobeSimulation_className(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(ISimulation):
    r"""Proxy of C++ SpecularSimulation 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, scan, sample):
        r"""__init__(SpecularSimulation self, BeamScan scan, MultiLayer const & sample) -> SpecularSimulation"""
        _libBornAgainSim.SpecularSimulation_swiginit(self, _libBornAgainSim.new_SpecularSimulation(scan, sample))
    __swig_destroy__ = _libBornAgainSim.delete_SpecularSimulation

    def className(self):
        r"""className(SpecularSimulation self) -> std::string"""
        return _libBornAgainSim.SpecularSimulation_className(self)

# Register SpecularSimulation in _libBornAgainSim:
_libBornAgainSim.SpecularSimulation_swigregister(SpecularSimulation)
class OffspecSimulation(ISimulation):
    r"""Proxy of C++ OffspecSimulation 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, scan, sample, detector):
        r"""__init__(OffspecSimulation self, PhysicalScan scan, MultiLayer const & sample, OffspecDetector const & detector) -> OffspecSimulation"""
        _libBornAgainSim.OffspecSimulation_swiginit(self, _libBornAgainSim.new_OffspecSimulation(scan, sample, detector))
    __swig_destroy__ = _libBornAgainSim.delete_OffspecSimulation

    def className(self):
        r"""className(OffspecSimulation self) -> std::string"""
        return _libBornAgainSim.OffspecSimulation_className(self)

# Register OffspecSimulation in _libBornAgainSim:
_libBornAgainSim.OffspecSimulation_swigregister(OffspecSimulation)
class IBackground(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""Proxy of C++ IBackground 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_IBackground

    def clone(self):
        r"""clone(IBackground self) -> IBackground"""
        return _libBornAgainSim.IBackground_clone(self)

    def addBackground(self, element):
        r"""addBackground(IBackground self, double element) -> double"""
        return _libBornAgainSim.IBackground_addBackground(self, element)

# Register IBackground in _libBornAgainSim:
_libBornAgainSim.IBackground_swigregister(IBackground)
class ConstantBackground(IBackground):
    r"""Proxy of C++ ConstantBackground 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__(ConstantBackground self, vdouble1d_t P) -> ConstantBackground
        __init__(ConstantBackground self, double background_value) -> ConstantBackground
        """
        _libBornAgainSim.ConstantBackground_swiginit(self, _libBornAgainSim.new_ConstantBackground(*args))

    def clone(self):
        r"""clone(ConstantBackground self) -> ConstantBackground"""
        return _libBornAgainSim.ConstantBackground_clone(self)

    def className(self):
        r"""className(ConstantBackground self) -> std::string"""
        return _libBornAgainSim.ConstantBackground_className(self)

    def parDefs(self):
        r"""parDefs(ConstantBackground self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSim.ConstantBackground_parDefs(self)

    def backgroundValue(self):
        r"""backgroundValue(ConstantBackground self) -> double"""
        return _libBornAgainSim.ConstantBackground_backgroundValue(self)

    def addBackground(self, intensity):
        r"""addBackground(ConstantBackground self, double intensity) -> double"""
        return _libBornAgainSim.ConstantBackground_addBackground(self, intensity)

    def validate(self):
        r"""validate(ConstantBackground self) -> std::string"""
        return _libBornAgainSim.ConstantBackground_validate(self)
    __swig_destroy__ = _libBornAgainSim.delete_ConstantBackground

# Register ConstantBackground in _libBornAgainSim:
_libBornAgainSim.ConstantBackground_swigregister(ConstantBackground)
class PoissonBackground(IBackground):
    r"""Proxy of C++ PoissonBackground class."""

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

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

    def clone(self):
        r"""clone(PoissonBackground self) -> PoissonBackground"""
        return _libBornAgainSim.PoissonBackground_clone(self)

    def className(self):
        r"""className(PoissonBackground self) -> std::string"""
        return _libBornAgainSim.PoissonBackground_className(self)

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

# Register PoissonBackground in _libBornAgainSim:
_libBornAgainSim.PoissonBackground_swigregister(PoissonBackground)

def sampleCode(sample):
    r"""sampleCode(MultiLayer const & sample) -> std::string"""
    return _libBornAgainSim.sampleCode(sample)

def simulationPlotCode(simulation):
    r"""simulationPlotCode(ISimulation simulation) -> std::string"""
    return _libBornAgainSim.simulationPlotCode(simulation)

def simulationSaveCode(simulation, fname):
    r"""simulationSaveCode(ISimulation simulation, std::string const & fname) -> std::string"""
    return _libBornAgainSim.simulationSaveCode(simulation, fname)
class IIntensityFunction(object):
    r"""Proxy of C++ IIntensityFunction 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_IIntensityFunction

    def clone(self):
        r"""clone(IIntensityFunction self) -> IIntensityFunction"""
        return _libBornAgainSim.IIntensityFunction_clone(self)

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

# Register IIntensityFunction in _libBornAgainSim:
_libBornAgainSim.IIntensityFunction_swigregister(IIntensityFunction)
class IntensityFunctionLog(IIntensityFunction):
    r"""Proxy of C++ IntensityFunctionLog class."""

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

    def clone(self):
        r"""clone(IntensityFunctionLog self) -> IntensityFunctionLog"""
        return _libBornAgainSim.IntensityFunctionLog_clone(self)

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

    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(IIntensityFunction):
    r"""Proxy of C++ IntensityFunctionSqrt class."""

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

    def clone(self):
        r"""clone(IntensityFunctionSqrt self) -> IntensityFunctionSqrt"""
        return _libBornAgainSim.IntensityFunctionSqrt_clone(self)

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

    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 IChiSquaredModule(libBornAgainBase.ICloneable):
    r"""Proxy of C++ IChiSquaredModule 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_IChiSquaredModule

    def clone(self):
        r"""clone(IChiSquaredModule self) -> IChiSquaredModule"""
        return _libBornAgainSim.IChiSquaredModule_clone(self)

    def varianceFunction(self):
        r"""varianceFunction(IChiSquaredModule self) -> IVarianceFunction"""
        return _libBornAgainSim.IChiSquaredModule_varianceFunction(self)

    def setVarianceFunction(self, variance_function):
        r"""setVarianceFunction(IChiSquaredModule self, IVarianceFunction variance_function)"""
        return _libBornAgainSim.IChiSquaredModule_setVarianceFunction(self, variance_function)

    def getIntensityFunction(self):
        r"""getIntensityFunction(IChiSquaredModule self) -> IIntensityFunction"""
        return _libBornAgainSim.IChiSquaredModule_getIntensityFunction(self)

    def setIntensityFunction(self, intensity_function):
        r"""setIntensityFunction(IChiSquaredModule self, IIntensityFunction intensity_function)"""
        return _libBornAgainSim.IChiSquaredModule_setIntensityFunction(self, intensity_function)

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

# Register IChiSquaredModule in _libBornAgainSim:
_libBornAgainSim.IChiSquaredModule_swigregister(IChiSquaredModule)
class ChiSquaredModule(IChiSquaredModule):
    r"""Proxy of C++ ChiSquaredModule 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__(ChiSquaredModule self) -> ChiSquaredModule
        __init__(ChiSquaredModule self, ChiSquaredModule other) -> ChiSquaredModule
        """
        _libBornAgainSim.ChiSquaredModule_swiginit(self, _libBornAgainSim.new_ChiSquaredModule(*args))
    __swig_destroy__ = _libBornAgainSim.delete_ChiSquaredModule

    def clone(self):
        r"""clone(ChiSquaredModule self) -> ChiSquaredModule"""
        return _libBornAgainSim.ChiSquaredModule_clone(self)

    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 IVarianceFunction(object):
    r"""Proxy of C++ IVarianceFunction 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_IVarianceFunction

    def clone(self):
        r"""clone(IVarianceFunction self) -> IVarianceFunction"""
        return _libBornAgainSim.IVarianceFunction_clone(self)

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

# Register IVarianceFunction in _libBornAgainSim:
_libBornAgainSim.IVarianceFunction_swigregister(IVarianceFunction)
class VarianceConstantFunction(IVarianceFunction):
    r"""Proxy of C++ VarianceConstantFunction class."""

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

    def clone(self):
        r"""clone(VarianceConstantFunction self) -> VarianceConstantFunction"""
        return _libBornAgainSim.VarianceConstantFunction_clone(self)

    def variance(self, arg2, arg3):
        r"""variance(VarianceConstantFunction self, double arg2, double arg3) -> double"""
        return _libBornAgainSim.VarianceConstantFunction_variance(self, arg2, arg3)

    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(IVarianceFunction):
    r"""Proxy of C++ VarianceSimFunction 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, epsilon=1.0):
        r"""__init__(VarianceSimFunction self, double epsilon=1.0) -> VarianceSimFunction"""
        _libBornAgainSim.VarianceSimFunction_swiginit(self, _libBornAgainSim.new_VarianceSimFunction(epsilon))

    def clone(self):
        r"""clone(VarianceSimFunction self) -> VarianceSimFunction"""
        return _libBornAgainSim.VarianceSimFunction_clone(self)

    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)

class SimulationBuilderWrapper(PyBuilderCallback):
    def __init__(self, f):
        super(SimulationBuilderWrapper, self).__init__()
        self.f_ = f

    def create_par_dict(self, pars):
        """
        Conversion of ba.Parameters to Python dictionary
        """
        pars_dict = dict()
        for index, p in enumerate(pars):
            pars_dict[p.name()] = p.value
        return pars_dict

    def build_simulation(self, obj):
        simulation = self.f_(self.create_par_dict(obj))
        simulation.__disown__()
        return simulation


class ObserverCallbackWrapper(PyObserverCallback):
    def __init__(self, callback):
        super(ObserverCallbackWrapper, self).__init__()
        self.callback_ = callback

    def update(self, fit_objective):
        return self.callback_(fit_objective)


