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

from sys import version_info as _swig_python_version_info
import _libBornAgainSim

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSim.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _libBornAgainSim:
_libBornAgainSim.SwigPyIterator_swigregister(SwigPyIterator)

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

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

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

    def iterator(self):
        r"""iterator(vdouble1d_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vdouble1d_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vdouble1d_T self)"""
        return _libBornAgainSim.vdouble1d_T_pop_back(self)

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

    def __init__(self, *args):
        r"""
        __init__(vdouble1d_T self) -> vdouble1d_T
        __init__(vdouble1d_T self, vdouble1d_T other) -> vdouble1d_T
        __init__(vdouble1d_T self, std::vector< double >::size_type size) -> vdouble1d_T
        __init__(vdouble1d_T self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vdouble1d_T
        """
        _libBornAgainSim.vdouble1d_T_swiginit(self, _libBornAgainSim.new_vdouble1d_T(*args))

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

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

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

    def assign(self, n, x):
        r"""assign(vdouble1d_T self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _libBornAgainSim.vdouble1d_T_assign(self, n, x)

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

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

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

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

# Register vdouble1d_T in _libBornAgainSim:
_libBornAgainSim.vdouble1d_T_swigregister(vdouble1d_T)
class vdouble2d_T(object):
    r"""Proxy of C++ std::vector< std::vector< double > > class."""

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

    def iterator(self):
        r"""iterator(vdouble2d_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vdouble2d_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

    def __getitem__(self, *args):
        r"""
        __getitem__(vdouble2d_T self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_T
        __getitem__(vdouble2d_T self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_T
        """
        return _libBornAgainSim.vdouble2d_T___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vdouble2d_T self, SWIGPY_SLICEOBJECT * slice, vdouble2d_T v)
        __setitem__(vdouble2d_T self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(vdouble2d_T self, std::vector< std::vector< double > >::difference_type i, vdouble1d_T x)
        """
        return _libBornAgainSim.vdouble2d_T___setitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vdouble2d_T self)"""
        return _libBornAgainSim.vdouble2d_T_pop_back(self)

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

    def __init__(self, *args):
        r"""
        __init__(vdouble2d_T self) -> vdouble2d_T
        __init__(vdouble2d_T self, vdouble2d_T other) -> vdouble2d_T
        __init__(vdouble2d_T self, std::vector< std::vector< double > >::size_type size) -> vdouble2d_T
        __init__(vdouble2d_T self, std::vector< std::vector< double > >::size_type size, vdouble1d_T value) -> vdouble2d_T
        """
        _libBornAgainSim.vdouble2d_T_swiginit(self, _libBornAgainSim.new_vdouble2d_T(*args))

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

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

    def back(self):
        r"""back(vdouble2d_T self) -> vdouble1d_T"""
        return _libBornAgainSim.vdouble2d_T_back(self)

    def assign(self, n, x):
        r"""assign(vdouble2d_T self, std::vector< std::vector< double > >::size_type n, vdouble1d_T x)"""
        return _libBornAgainSim.vdouble2d_T_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vdouble2d_T self, std::vector< std::vector< double > >::size_type new_size)
        resize(vdouble2d_T self, std::vector< std::vector< double > >::size_type new_size, vdouble1d_T x)
        """
        return _libBornAgainSim.vdouble2d_T_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vdouble2d_T self, std::vector< std::vector< double > >::iterator pos, vdouble1d_T x) -> std::vector< std::vector< double > >::iterator
        insert(vdouble2d_T self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, vdouble1d_T x)
        """
        return _libBornAgainSim.vdouble2d_T_insert(self, *args)

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

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

# Register vdouble2d_T in _libBornAgainSim:
_libBornAgainSim.vdouble2d_T_swigregister(vdouble2d_T)
class vector_integer_T(object):
    r"""Proxy of C++ std::vector< int > class."""

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

    def iterator(self):
        r"""iterator(vector_integer_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vector_integer_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __getslice__(self, i, j):
        r"""__getslice__(vector_integer_T self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_T"""
        return _libBornAgainSim.vector_integer_T___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_integer_T self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(vector_integer_T self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_T v)
        """
        return _libBornAgainSim.vector_integer_T___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_integer_T self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _libBornAgainSim.vector_integer_T___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_integer_T self, std::vector< int >::difference_type i)
        __delitem__(vector_integer_T self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.vector_integer_T___delitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_integer_T self)"""
        return _libBornAgainSim.vector_integer_T_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_integer_T self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(vector_integer_T self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _libBornAgainSim.vector_integer_T_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_integer_T self) -> vector_integer_T
        __init__(vector_integer_T self, vector_integer_T other) -> vector_integer_T
        __init__(vector_integer_T self, std::vector< int >::size_type size) -> vector_integer_T
        __init__(vector_integer_T self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> vector_integer_T
        """
        _libBornAgainSim.vector_integer_T_swiginit(self, _libBornAgainSim.new_vector_integer_T(*args))

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

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

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

    def assign(self, n, x):
        r"""assign(vector_integer_T self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _libBornAgainSim.vector_integer_T_assign(self, n, x)

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

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

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

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

# Register vector_integer_T in _libBornAgainSim:
_libBornAgainSim.vector_integer_T_swigregister(vector_integer_T)
class vinteger2d_T(object):
    r"""Proxy of C++ std::vector< std::vector< int > > class."""

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

    def iterator(self):
        r"""iterator(vinteger2d_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vinteger2d_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __getslice__(self, i, j):
        r"""__getslice__(vinteger2d_T self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) -> vinteger2d_T"""
        return _libBornAgainSim.vinteger2d_T___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vinteger2d_T self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)
        __setslice__(vinteger2d_T self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, vinteger2d_T v)
        """
        return _libBornAgainSim.vinteger2d_T___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vinteger2d_T self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"""
        return _libBornAgainSim.vinteger2d_T___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vinteger2d_T self, std::vector< std::vector< int > >::difference_type i)
        __delitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.vinteger2d_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_T
        __getitem__(vinteger2d_T self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_T
        """
        return _libBornAgainSim.vinteger2d_T___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * slice, vinteger2d_T v)
        __setitem__(vinteger2d_T self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(vinteger2d_T self, std::vector< std::vector< int > >::difference_type i, vector_integer_T x)
        """
        return _libBornAgainSim.vinteger2d_T___setitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vinteger2d_T self)"""
        return _libBornAgainSim.vinteger2d_T_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vinteger2d_T self, std::vector< std::vector< int > >::iterator pos) -> std::vector< std::vector< int > >::iterator
        erase(vinteger2d_T self, std::vector< std::vector< int > >::iterator first, std::vector< std::vector< int > >::iterator last) -> std::vector< std::vector< int > >::iterator
        """
        return _libBornAgainSim.vinteger2d_T_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vinteger2d_T self) -> vinteger2d_T
        __init__(vinteger2d_T self, vinteger2d_T other) -> vinteger2d_T
        __init__(vinteger2d_T self, std::vector< std::vector< int > >::size_type size) -> vinteger2d_T
        __init__(vinteger2d_T self, std::vector< std::vector< int > >::size_type size, vector_integer_T value) -> vinteger2d_T
        """
        _libBornAgainSim.vinteger2d_T_swiginit(self, _libBornAgainSim.new_vinteger2d_T(*args))

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

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

    def back(self):
        r"""back(vinteger2d_T self) -> vector_integer_T"""
        return _libBornAgainSim.vinteger2d_T_back(self)

    def assign(self, n, x):
        r"""assign(vinteger2d_T self, std::vector< std::vector< int > >::size_type n, vector_integer_T x)"""
        return _libBornAgainSim.vinteger2d_T_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vinteger2d_T self, std::vector< std::vector< int > >::size_type new_size)
        resize(vinteger2d_T self, std::vector< std::vector< int > >::size_type new_size, vector_integer_T x)
        """
        return _libBornAgainSim.vinteger2d_T_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vinteger2d_T self, std::vector< std::vector< int > >::iterator pos, vector_integer_T x) -> std::vector< std::vector< int > >::iterator
        insert(vinteger2d_T self, std::vector< std::vector< int > >::iterator pos, std::vector< std::vector< int > >::size_type n, vector_integer_T x)
        """
        return _libBornAgainSim.vinteger2d_T_insert(self, *args)

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

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

# Register vinteger2d_T in _libBornAgainSim:
_libBornAgainSim.vinteger2d_T_swigregister(vinteger2d_T)
class vector_longinteger_T(object):
    r"""Proxy of C++ std::vector< unsigned long > class."""

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

    def iterator(self):
        r"""iterator(vector_longinteger_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vector_longinteger_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __getslice__(self, i, j):
        r"""__getslice__(vector_longinteger_T self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_T"""
        return _libBornAgainSim.vector_longinteger_T___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_longinteger_T self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
        __setslice__(vector_longinteger_T self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_T v)
        """
        return _libBornAgainSim.vector_longinteger_T___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_longinteger_T self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"""
        return _libBornAgainSim.vector_longinteger_T___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_longinteger_T self, std::vector< unsigned long >::difference_type i)
        __delitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.vector_longinteger_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_T
        __getitem__(vector_longinteger_T self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
        """
        return _libBornAgainSim.vector_longinteger_T___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_T v)
        __setitem__(vector_longinteger_T self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(vector_longinteger_T self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
        """
        return _libBornAgainSim.vector_longinteger_T___setitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_longinteger_T self)"""
        return _libBornAgainSim.vector_longinteger_T_pop_back(self)

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

    def __init__(self, *args):
        r"""
        __init__(vector_longinteger_T self) -> vector_longinteger_T
        __init__(vector_longinteger_T self, vector_longinteger_T other) -> vector_longinteger_T
        __init__(vector_longinteger_T self, std::vector< unsigned long >::size_type size) -> vector_longinteger_T
        __init__(vector_longinteger_T self, std::vector< unsigned long >::size_type size, std::vector< unsigned long >::value_type const & value) -> vector_longinteger_T
        """
        _libBornAgainSim.vector_longinteger_T_swiginit(self, _libBornAgainSim.new_vector_longinteger_T(*args))

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

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

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

    def assign(self, n, x):
        r"""assign(vector_longinteger_T self, std::vector< unsigned long >::size_type n, std::vector< unsigned long >::value_type const & x)"""
        return _libBornAgainSim.vector_longinteger_T_assign(self, n, x)

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

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

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

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

# Register vector_longinteger_T in _libBornAgainSim:
_libBornAgainSim.vector_longinteger_T_swigregister(vector_longinteger_T)
class vector_complex_T(object):
    r"""Proxy of C++ std::vector< std::complex< double > > class."""

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

    def iterator(self):
        r"""iterator(vector_complex_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vector_complex_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __getslice__(self, i, j):
        r"""__getslice__(vector_complex_T self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_T"""
        return _libBornAgainSim.vector_complex_T___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_complex_T self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
        __setslice__(vector_complex_T self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_T v)
        """
        return _libBornAgainSim.vector_complex_T___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_complex_T self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"""
        return _libBornAgainSim.vector_complex_T___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_complex_T self, std::vector< std::complex< double > >::difference_type i)
        __delitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.vector_complex_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_T
        __getitem__(vector_complex_T self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
        """
        return _libBornAgainSim.vector_complex_T___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * slice, vector_complex_T v)
        __setitem__(vector_complex_T self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(vector_complex_T self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
        """
        return _libBornAgainSim.vector_complex_T___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_complex_T self) -> std::vector< std::complex< double > >::value_type"""
        return _libBornAgainSim.vector_complex_T_pop(self)

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_complex_T self)"""
        return _libBornAgainSim.vector_complex_T_pop_back(self)

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

    def __init__(self, *args):
        r"""
        __init__(vector_complex_T self) -> vector_complex_T
        __init__(vector_complex_T self, vector_complex_T other) -> vector_complex_T
        __init__(vector_complex_T self, std::vector< std::complex< double > >::size_type size) -> vector_complex_T
        __init__(vector_complex_T self, std::vector< std::complex< double > >::size_type size, std::vector< std::complex< double > >::value_type const & value) -> vector_complex_T
        """
        _libBornAgainSim.vector_complex_T_swiginit(self, _libBornAgainSim.new_vector_complex_T(*args))

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

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

    def back(self):
        r"""back(vector_complex_T self) -> std::vector< std::complex< double > >::value_type const &"""
        return _libBornAgainSim.vector_complex_T_back(self)

    def assign(self, n, x):
        r"""assign(vector_complex_T self, std::vector< std::complex< double > >::size_type n, std::vector< std::complex< double > >::value_type const & x)"""
        return _libBornAgainSim.vector_complex_T_assign(self, n, x)

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

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

    def reserve(self, n):
        r"""reserve(vector_complex_T self, std::vector< std::complex< double > >::size_type n)"""
        return _libBornAgainSim.vector_complex_T_reserve(self, n)

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

# Register vector_complex_T in _libBornAgainSim:
_libBornAgainSim.vector_complex_T_swigregister(vector_complex_T)
class vector_string_T(object):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self):
        r"""iterator(vector_string_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vector_string_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

    def __getslice__(self, i, j):
        r"""__getslice__(vector_string_T self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_T"""
        return _libBornAgainSim.vector_string_T___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_string_T self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(vector_string_T self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_T v)
        """
        return _libBornAgainSim.vector_string_T___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_string_T self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _libBornAgainSim.vector_string_T___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_string_T self, std::vector< std::string >::difference_type i)
        __delitem__(vector_string_T self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.vector_string_T___delitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_string_T self)"""
        return _libBornAgainSim.vector_string_T_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_string_T self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(vector_string_T self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _libBornAgainSim.vector_string_T_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_string_T self) -> vector_string_T
        __init__(vector_string_T self, vector_string_T other) -> vector_string_T
        __init__(vector_string_T self, std::vector< std::string >::size_type size) -> vector_string_T
        __init__(vector_string_T self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> vector_string_T
        """
        _libBornAgainSim.vector_string_T_swiginit(self, _libBornAgainSim.new_vector_string_T(*args))

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

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

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

    def assign(self, n, x):
        r"""assign(vector_string_T self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _libBornAgainSim.vector_string_T_assign(self, n, x)

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

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

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

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

# Register vector_string_T in _libBornAgainSim:
_libBornAgainSim.vector_string_T_swigregister(vector_string_T)
class map_string_double_T(object):
    r"""Proxy of C++ std::map< std::string,double > class."""

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

    def iterator(self):
        r"""iterator(map_string_double_T self) -> SwigPyIterator"""
        return _libBornAgainSim.map_string_double_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(map_string_double_T self) -> std::map< std::string,double >::size_type"""
        return _libBornAgainSim.map_string_double_T___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""__getitem__(map_string_double_T self, std::map< std::string,double >::key_type const & key) -> std::map< std::string,double >::mapped_type const &"""
        return _libBornAgainSim.map_string_double_T___getitem__(self, key)

    def __delitem__(self, key):
        r"""__delitem__(map_string_double_T self, std::map< std::string,double >::key_type const & key)"""
        return _libBornAgainSim.map_string_double_T___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(map_string_double_T self, std::map< std::string,double >::key_type const & key) -> bool"""
        return _libBornAgainSim.map_string_double_T_has_key(self, key)

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

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

    def items(self):
        r"""items(map_string_double_T self) -> PyObject *"""
        return _libBornAgainSim.map_string_double_T_items(self)

    def __contains__(self, key):
        r"""__contains__(map_string_double_T self, std::map< std::string,double >::key_type const & key) -> bool"""
        return _libBornAgainSim.map_string_double_T___contains__(self, key)

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

    def value_iterator(self):
        r"""value_iterator(map_string_double_T self) -> SwigPyIterator"""
        return _libBornAgainSim.map_string_double_T_value_iterator(self)

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

    def asdict(self):
        r"""asdict(map_string_double_T self) -> PyObject *"""
        return _libBornAgainSim.map_string_double_T_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(map_string_double_T self, std::less< std::string > const & other) -> map_string_double_T
        __init__(map_string_double_T self) -> map_string_double_T
        __init__(map_string_double_T self, map_string_double_T other) -> map_string_double_T
        """
        _libBornAgainSim.map_string_double_T_swiginit(self, _libBornAgainSim.new_map_string_double_T(*args))

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

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

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

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

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

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

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

    def clear(self):
        r"""clear(map_string_double_T self)"""
        return _libBornAgainSim.map_string_double_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(map_string_double_T self) -> std::map< std::string,double >::allocator_type"""
        return _libBornAgainSim.map_string_double_T_get_allocator(self)

    def count(self, x):
        r"""count(map_string_double_T self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::size_type"""
        return _libBornAgainSim.map_string_double_T_count(self, x)

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

    def find(self, x):
        r"""find(map_string_double_T self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
        return _libBornAgainSim.map_string_double_T_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(map_string_double_T self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
        return _libBornAgainSim.map_string_double_T_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(map_string_double_T self, std::map< std::string,double >::key_type const & x) -> std::map< std::string,double >::iterator"""
        return _libBornAgainSim.map_string_double_T_upper_bound(self, x)
    __swig_destroy__ = _libBornAgainSim.delete_map_string_double_T

# Register map_string_double_T in _libBornAgainSim:
_libBornAgainSim.map_string_double_T_swigregister(map_string_double_T)
class pvacuum_double_T(object):
    r"""Proxy of C++ std::pair< double,double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(pvacuum_double_T self) -> pvacuum_double_T
        __init__(pvacuum_double_T self, double first, double second) -> pvacuum_double_T
        __init__(pvacuum_double_T self, pvacuum_double_T other) -> pvacuum_double_T
        """
        _libBornAgainSim.pvacuum_double_T_swiginit(self, _libBornAgainSim.new_pvacuum_double_T(*args))
    first = property(_libBornAgainSim.pvacuum_double_T_first_get, _libBornAgainSim.pvacuum_double_T_first_set, doc=r"""first : double""")
    second = property(_libBornAgainSim.pvacuum_double_T_second_get, _libBornAgainSim.pvacuum_double_T_second_set, doc=r"""second : double""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _libBornAgainSim.delete_pvacuum_double_T

# Register pvacuum_double_T in _libBornAgainSim:
_libBornAgainSim.pvacuum_double_T_swigregister(pvacuum_double_T)
class vector_pvacuum_double_T(object):
    r"""Proxy of C++ std::vector< std::pair< double,double > > class."""

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

    def iterator(self):
        r"""iterator(vector_pvacuum_double_T self) -> SwigPyIterator"""
        return _libBornAgainSim.vector_pvacuum_double_T_iterator(self)
    def __iter__(self):
        return self.iterator()

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

    def __bool__(self):
        r"""__bool__(vector_pvacuum_double_T self) -> bool"""
        return _libBornAgainSim.vector_pvacuum_double_T___bool__(self)

    def __len__(self):
        r"""__len__(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::size_type"""
        return _libBornAgainSim.vector_pvacuum_double_T___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j) -> vector_pvacuum_double_T"""
        return _libBornAgainSim.vector_pvacuum_double_T___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)
        __setslice__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j, vector_pvacuum_double_T v)
        """
        return _libBornAgainSim.vector_pvacuum_double_T___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"""
        return _libBornAgainSim.vector_pvacuum_double_T___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::difference_type i)
        __delitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * slice)
        """
        return _libBornAgainSim.vector_pvacuum_double_T___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_T
        __getitem__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_T
        """
        return _libBornAgainSim.vector_pvacuum_double_T___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_T v)
        __setitem__(vector_pvacuum_double_T self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_T x)
        """
        return _libBornAgainSim.vector_pvacuum_double_T___setitem__(self, *args)

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

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

    def empty(self):
        r"""empty(vector_pvacuum_double_T self) -> bool"""
        return _libBornAgainSim.vector_pvacuum_double_T_empty(self)

    def size(self):
        r"""size(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::size_type"""
        return _libBornAgainSim.vector_pvacuum_double_T_size(self)

    def swap(self, v):
        r"""swap(vector_pvacuum_double_T self, vector_pvacuum_double_T v)"""
        return _libBornAgainSim.vector_pvacuum_double_T_swap(self, v)

    def begin(self):
        r"""begin(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::iterator"""
        return _libBornAgainSim.vector_pvacuum_double_T_begin(self)

    def end(self):
        r"""end(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::iterator"""
        return _libBornAgainSim.vector_pvacuum_double_T_end(self)

    def rbegin(self):
        r"""rbegin(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
        return _libBornAgainSim.vector_pvacuum_double_T_rbegin(self)

    def rend(self):
        r"""rend(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::reverse_iterator"""
        return _libBornAgainSim.vector_pvacuum_double_T_rend(self)

    def clear(self):
        r"""clear(vector_pvacuum_double_T self)"""
        return _libBornAgainSim.vector_pvacuum_double_T_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::allocator_type"""
        return _libBornAgainSim.vector_pvacuum_double_T_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_pvacuum_double_T self)"""
        return _libBornAgainSim.vector_pvacuum_double_T_pop_back(self)

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

    def __init__(self, *args):
        r"""
        __init__(vector_pvacuum_double_T self) -> vector_pvacuum_double_T
        __init__(vector_pvacuum_double_T self, vector_pvacuum_double_T other) -> vector_pvacuum_double_T
        __init__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::size_type size) -> vector_pvacuum_double_T
        __init__(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::size_type size, pvacuum_double_T value) -> vector_pvacuum_double_T
        """
        _libBornAgainSim.vector_pvacuum_double_T_swiginit(self, _libBornAgainSim.new_vector_pvacuum_double_T(*args))

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

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

    def back(self):
        r"""back(vector_pvacuum_double_T self) -> pvacuum_double_T"""
        return _libBornAgainSim.vector_pvacuum_double_T_back(self)

    def assign(self, n, x):
        r"""assign(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_T x)"""
        return _libBornAgainSim.vector_pvacuum_double_T_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::size_type new_size)
        resize(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::size_type new_size, pvacuum_double_T x)
        """
        return _libBornAgainSim.vector_pvacuum_double_T_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::iterator pos, pvacuum_double_T x) -> std::vector< std::pair< double,double > >::iterator
        insert(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::iterator pos, std::vector< std::pair< double,double > >::size_type n, pvacuum_double_T x)
        """
        return _libBornAgainSim.vector_pvacuum_double_T_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_pvacuum_double_T self, std::vector< std::pair< double,double > >::size_type n)"""
        return _libBornAgainSim.vector_pvacuum_double_T_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_pvacuum_double_T self) -> std::vector< std::pair< double,double > >::size_type"""
        return _libBornAgainSim.vector_pvacuum_double_T_capacity(self)
    __swig_destroy__ = _libBornAgainSim.delete_vector_pvacuum_double_T

# Register vector_pvacuum_double_T in _libBornAgainSim:
_libBornAgainSim.vector_pvacuum_double_T_swigregister(vector_pvacuum_double_T)
import 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 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
version = cvar.version

class BeamScan(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 setIntensity(self, intensity):
        r"""setIntensity(BeamScan self, double intensity)"""
        return _libBornAgainSim.BeamScan_setIntensity(self, intensity)

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

    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 setWavelength(self, _lambda):
        r"""setWavelength(PhysicalScan self, double _lambda)"""
        return _libBornAgainSim.PhysicalScan_setWavelength(self, _lambda)

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

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

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

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

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

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

# 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 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 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 className(self):
        r"""className(QzScan self) -> std::string"""
        return _libBornAgainSim.QzScan_className(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 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, Sample 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)

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

# 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, Sample const & sample, Scale zaxis, int flags=0) -> DepthprobeSimulation"""
        _libBornAgainSim.DepthprobeSimulation_swiginit(self, _libBornAgainSim.new_DepthprobeSimulation(scan, sample, zaxis, flags))
    __swig_destroy__ = _libBornAgainSim.delete_DepthprobeSimulation

    def 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, Sample 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, Sample 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(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 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 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 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(Sample 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 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 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 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(object):
    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 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 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 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 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 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 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"""
        _libBornAgainSim.FitObjective_swiginit(self, _libBornAgainSim.new_FitObjective())
    __swig_destroy__ = _libBornAgainSim.delete_FitObjective

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

    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 initPrint(self, every_nth):
        r"""initPrint(FitObjective self, int every_nth)"""
        return _libBornAgainSim.FitObjective_initPrint(self, every_nth)

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

    def evaluate_residuals(self, params):
        r"""evaluate_residuals(FitObjective self, mumufit::Parameters const & params) -> vdouble1d_T"""
        return _libBornAgainSim.FitObjective_evaluate_residuals(self, params)

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

    def initPlot(self, every_nth, pCallable, pCall):
        r"""initPlot(FitObjective self, int every_nth, void * pCallable, PyCaller_t pCall)"""
        return _libBornAgainSim.FitObjective_initPlot(self, every_nth, pCallable, pCall)

    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 nPairs(self):
        r"""nPairs(FitObjective self) -> size_t"""
        return _libBornAgainSim.FitObjective_nPairs(self)

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

    def addPyFitPair(self, pSimulationCallable, expData, weight):
        r"""addPyFitPair(FitObjective self, PyObject * pSimulationCallable, Datafield expData, double const weight)"""
        return _libBornAgainSim.FitObjective_addPyFitPair(self, pSimulationCallable, expData, weight)

    def _initPyPlot(self, every_nth, pUpdateCallable):
        r"""_initPyPlot(FitObjective self, int every_nth, PyObject * pUpdateCallable)"""
        return _libBornAgainSim.FitObjective__initPyPlot(self, every_nth, pUpdateCallable)

# Register FitObjective in _libBornAgainSim:
_libBornAgainSim.FitObjective_swigregister(FitObjective)


class FitObjective(FitObjective):
    """ Python extention to C++ class FitObjective

        NOTE: The module requires libBornAgainFit.
    """
    def __init__(self):
        super().__init__()
# NOTE: Callback functions must be available during the lifetime of
# the FitObjective instance; therefore, they are stored internally.
        self._sim_fs = []
        self._plot_fs = []

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

        Arguments:

        pySimulationFn: a user-defined function that takes a fit-parameter
             dict as input, and returns a BornAgain.ISimulation object.

        expData: a Datafield containing experimental data.

        weight: user-defined weight of the dataset.
        """

        self._sim_fs.append(pySimulationFn)
        super().addPyFitPair(pySimulationFn, expData, weight) # calls the extension function defined above

    def evaluate(self, params):
        return super().evaluate(FitObjective._convert_params(params))

    def evaluate_residuals(self, params):
        return super().evaluate_residuals(FitObjective._convert_params(params))

    def finalize(self, minimizer_result):
        return super().finalize(FitObjective._convert_result(minimizer_result))

    @staticmethod
    def _convert_params(params):
        """
        Converts parameters to what FitObjective::evaluate expects
        """
        if str(params.__module__) != "lmfit.parameter":
            return params

        bapars = libBornAgainFit.Parameters()
        for p in params:
            bapars.add(p, params[p].value)
        return bapars

    @staticmethod
    def _convert_result(minim_result):
        """
        Converts result reported by arbitrary minimizer to ba.MinimizerResult
        """

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

    def initPlot(self, every_nth, plot_callback):
        self._plot_fs.append(plot_callback)
        return self._initPyPlot(every_nth, plot_callback)