# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

import _libBornAgainCore

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 == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


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


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


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


import weakref

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SHARED_PTR_DISOWN = _libBornAgainCore.SHARED_PTR_DISOWN


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

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

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

    def iterator(self):
        r"""iterator(vdouble1d_t self) -> SwigPyIterator"""
        return _libBornAgainCore.vdouble1d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vdouble1d_t self) -> std::vector< double >::size_type"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vdouble1d_t___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vdouble1d_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vdouble1d_t_swiginit(self, _libBornAgainCore.new_vdouble1d_t(*args))

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

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

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

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

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

# Register vdouble1d_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.vdouble2d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vdouble2d_t___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vdouble2d_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vdouble2d_t_swiginit(self, _libBornAgainCore.new_vdouble2d_t(*args))

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

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

    def back(self):
        r"""back(vdouble2d_t self) -> vdouble1d_t"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vdouble2d_t_insert(self, *args)

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

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

# Register vdouble2d_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.vector_integer_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vector_integer_t self) -> std::vector< int >::size_type"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vector_integer_t___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_integer_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vector_integer_t_swiginit(self, _libBornAgainCore.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 _libBornAgainCore.vector_integer_t_push_back(self, x)

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

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

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

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

# Register vector_integer_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.vinteger2d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vinteger2d_t self) -> std::vector< std::vector< int > >::size_type"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vinteger2d_t___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vinteger2d_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vinteger2d_t_swiginit(self, _libBornAgainCore.new_vinteger2d_t(*args))

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

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

    def back(self):
        r"""back(vinteger2d_t self) -> vector_integer_t"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vinteger2d_t_insert(self, *args)

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

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

# Register vinteger2d_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.vector_longinteger_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vector_longinteger_t___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_longinteger_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vector_longinteger_t_swiginit(self, _libBornAgainCore.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 _libBornAgainCore.vector_longinteger_t_push_back(self, x)

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

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

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

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

# Register vector_longinteger_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.vector_complex_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vector_complex_t___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_complex_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vector_complex_t_swiginit(self, _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vector_complex_t_front(self)

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

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

# Register vector_complex_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.vector_string_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vector_string_t self) -> std::vector< std::string >::size_type"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vector_string_t___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_string_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vector_string_t_swiginit(self, _libBornAgainCore.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 _libBornAgainCore.vector_string_t_push_back(self, x)

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

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

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

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

# Register vector_string_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.map_string_double_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

    def items(self):
        r"""items(map_string_double_t self) -> PyObject *"""
        return _libBornAgainCore.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 _libBornAgainCore.map_string_double_t___contains__(self, key)

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

    def value_iterator(self):
        r"""value_iterator(map_string_double_t self) -> SwigPyIterator"""
        return _libBornAgainCore.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 _libBornAgainCore.map_string_double_t___setitem__(self, *args)

    def asdict(self):
        r"""asdict(map_string_double_t self) -> PyObject *"""
        return _libBornAgainCore.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
        """
        _libBornAgainCore.map_string_double_t_swiginit(self, _libBornAgainCore.new_map_string_double_t(*args))

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

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

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

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

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

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

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

    def clear(self):
        r"""clear(map_string_double_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.map_string_double_t_upper_bound(self, x)
    __swig_destroy__ = _libBornAgainCore.delete_map_string_double_t

# Register map_string_double_t in _libBornAgainCore:
_libBornAgainCore.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
        """
        _libBornAgainCore.pvacuum_double_t_swiginit(self, _libBornAgainCore.new_pvacuum_double_t(*args))
    first = property(_libBornAgainCore.pvacuum_double_t_first_get, _libBornAgainCore.pvacuum_double_t_first_set, doc=r"""first : double""")
    second = property(_libBornAgainCore.pvacuum_double_t_second_get, _libBornAgainCore.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__ = _libBornAgainCore.delete_pvacuum_double_t

# Register pvacuum_double_t in _libBornAgainCore:
_libBornAgainCore.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 _libBornAgainCore.vector_pvacuum_double_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

    def __bool__(self):
        r"""__bool__(vector_pvacuum_double_t self) -> bool"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vector_pvacuum_double_t___delslice__(self, i, j)

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

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

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

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

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

    def empty(self):
        r"""empty(vector_pvacuum_double_t self) -> bool"""
        return _libBornAgainCore.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 _libBornAgainCore.vector_pvacuum_double_t_size(self)

    def swap(self, v):
        r"""swap(vector_pvacuum_double_t self, vector_pvacuum_double_t v)"""
        return _libBornAgainCore.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 _libBornAgainCore.vector_pvacuum_double_t_begin(self)

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

    def clear(self):
        r"""clear(vector_pvacuum_double_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.vector_pvacuum_double_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_pvacuum_double_t self)"""
        return _libBornAgainCore.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 _libBornAgainCore.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
        """
        _libBornAgainCore.vector_pvacuum_double_t_swiginit(self, _libBornAgainCore.new_vector_pvacuum_double_t(*args))

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

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

    def back(self):
        r"""back(vector_pvacuum_double_t self) -> pvacuum_double_t"""
        return _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.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 _libBornAgainCore.vector_pvacuum_double_t_capacity(self)
    __swig_destroy__ = _libBornAgainCore.delete_vector_pvacuum_double_t

# Register vector_pvacuum_double_t in _libBornAgainCore:
_libBornAgainCore.vector_pvacuum_double_t_swigregister(vector_pvacuum_double_t)

import libBornAgainFit
import libBornAgainBase
class kvector_t(object):
    r"""Proxy of C++ BasicVector3D< 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__(kvector_t self) -> kvector_t
        __init__(kvector_t self, double const x1, double const y1, double const z1) -> kvector_t
        """
        _libBornAgainCore.kvector_t_swiginit(self, _libBornAgainCore.new_kvector_t(*args))

    def x(self):
        r"""x(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_x(self)

    def y(self):
        r"""y(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_y(self)

    def z(self):
        r"""z(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_z(self)

    def setX(self, a):
        r"""setX(kvector_t self, double const & a)"""
        return _libBornAgainCore.kvector_t_setX(self, a)

    def setY(self, a):
        r"""setY(kvector_t self, double const & a)"""
        return _libBornAgainCore.kvector_t_setY(self, a)

    def setZ(self, a):
        r"""setZ(kvector_t self, double const & a)"""
        return _libBornAgainCore.kvector_t_setZ(self, a)

    def __iadd__(self, v):
        r"""__iadd__(kvector_t self, kvector_t v) -> kvector_t"""
        return _libBornAgainCore.kvector_t___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(kvector_t self, kvector_t v) -> kvector_t"""
        return _libBornAgainCore.kvector_t___isub__(self, v)

    def conj(self):
        r"""conj(kvector_t self) -> kvector_t"""
        return _libBornAgainCore.kvector_t_conj(self)

    def mag2(self):
        r"""mag2(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_mag2(self)

    def mag(self):
        r"""mag(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_mag(self)

    def magxy2(self):
        r"""magxy2(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_magxy2(self)

    def magxy(self):
        r"""magxy(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_magxy(self)

    def phi(self):
        r"""phi(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_phi(self)

    def theta(self):
        r"""theta(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_theta(self)

    def cosTheta(self):
        r"""cosTheta(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_cosTheta(self)

    def sin2Theta(self):
        r"""sin2Theta(kvector_t self) -> double"""
        return _libBornAgainCore.kvector_t_sin2Theta(self)

    def unit(self):
        r"""unit(kvector_t self) -> kvector_t"""
        return _libBornAgainCore.kvector_t_unit(self)

    def complex(self):
        r"""complex(kvector_t self) -> cvector_t"""
        return _libBornAgainCore.kvector_t_complex(self)

    def real(self):
        r"""real(kvector_t self) -> kvector_t"""
        return _libBornAgainCore.kvector_t_real(self)

    def angle(self, v):
        r"""angle(kvector_t self, kvector_t v) -> double"""
        return _libBornAgainCore.kvector_t_angle(self, v)

    def project(self, v):
        r"""project(kvector_t self, kvector_t v) -> kvector_t"""
        return _libBornAgainCore.kvector_t_project(self, v)

    def __add__(self, rhs):
        r"""__add__(kvector_t self, kvector_t rhs) -> kvector_t"""
        return _libBornAgainCore.kvector_t___add__(self, rhs)

    def __mul__(self, c):
        r"""__mul__(kvector_t self, double c) -> kvector_t"""
        return _libBornAgainCore.kvector_t___mul__(self, c)

    def __rmul__(self, c):
        r"""__rmul__(kvector_t self, double c) -> kvector_t"""
        return _libBornAgainCore.kvector_t___rmul__(self, c)

    def __neg__(self):
        r"""__neg__(kvector_t self) -> kvector_t"""
        return _libBornAgainCore.kvector_t___neg__(self)
    __swig_destroy__ = _libBornAgainCore.delete_kvector_t

# Register kvector_t in _libBornAgainCore:
_libBornAgainCore.kvector_t_swigregister(kvector_t)

class vector_kvector_t(object):
    r"""Proxy of C++ std::vector< BasicVector3D< 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_kvector_t self) -> SwigPyIterator"""
        return _libBornAgainCore.vector_kvector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_kvector_t self) -> bool"""
        return _libBornAgainCore.vector_kvector_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_kvector_t self) -> bool"""
        return _libBornAgainCore.vector_kvector_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::size_type"""
        return _libBornAgainCore.vector_kvector_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_kvector_t self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j) -> vector_kvector_t"""
        return _libBornAgainCore.vector_kvector_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_kvector_t self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j)
        __setslice__(vector_kvector_t self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j, vector_kvector_t v)
        """
        return _libBornAgainCore.vector_kvector_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_kvector_t self, std::vector< BasicVector3D< double > >::difference_type i, std::vector< BasicVector3D< double > >::difference_type j)"""
        return _libBornAgainCore.vector_kvector_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_kvector_t self, std::vector< BasicVector3D< double > >::difference_type i)
        __delitem__(vector_kvector_t self, PySliceObject * slice)
        """
        return _libBornAgainCore.vector_kvector_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_kvector_t self, PySliceObject * slice) -> vector_kvector_t
        __getitem__(vector_kvector_t self, std::vector< BasicVector3D< double > >::difference_type i) -> kvector_t
        """
        return _libBornAgainCore.vector_kvector_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_kvector_t self, PySliceObject * slice, vector_kvector_t v)
        __setitem__(vector_kvector_t self, PySliceObject * slice)
        __setitem__(vector_kvector_t self, std::vector< BasicVector3D< double > >::difference_type i, kvector_t x)
        """
        return _libBornAgainCore.vector_kvector_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_kvector_t self) -> kvector_t"""
        return _libBornAgainCore.vector_kvector_t_pop(self)

    def append(self, x):
        r"""append(vector_kvector_t self, kvector_t x)"""
        return _libBornAgainCore.vector_kvector_t_append(self, x)

    def empty(self):
        r"""empty(vector_kvector_t self) -> bool"""
        return _libBornAgainCore.vector_kvector_t_empty(self)

    def size(self):
        r"""size(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::size_type"""
        return _libBornAgainCore.vector_kvector_t_size(self)

    def swap(self, v):
        r"""swap(vector_kvector_t self, vector_kvector_t v)"""
        return _libBornAgainCore.vector_kvector_t_swap(self, v)

    def begin(self):
        r"""begin(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::iterator"""
        return _libBornAgainCore.vector_kvector_t_begin(self)

    def end(self):
        r"""end(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::iterator"""
        return _libBornAgainCore.vector_kvector_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::reverse_iterator"""
        return _libBornAgainCore.vector_kvector_t_rbegin(self)

    def rend(self):
        r"""rend(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::reverse_iterator"""
        return _libBornAgainCore.vector_kvector_t_rend(self)

    def clear(self):
        r"""clear(vector_kvector_t self)"""
        return _libBornAgainCore.vector_kvector_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::allocator_type"""
        return _libBornAgainCore.vector_kvector_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_kvector_t self)"""
        return _libBornAgainCore.vector_kvector_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_kvector_t self, std::vector< BasicVector3D< double > >::iterator pos) -> std::vector< BasicVector3D< double > >::iterator
        erase(vector_kvector_t self, std::vector< BasicVector3D< double > >::iterator first, std::vector< BasicVector3D< double > >::iterator last) -> std::vector< BasicVector3D< double > >::iterator
        """
        return _libBornAgainCore.vector_kvector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_kvector_t self) -> vector_kvector_t
        __init__(vector_kvector_t self, vector_kvector_t other) -> vector_kvector_t
        __init__(vector_kvector_t self, std::vector< BasicVector3D< double > >::size_type size) -> vector_kvector_t
        __init__(vector_kvector_t self, std::vector< BasicVector3D< double > >::size_type size, kvector_t value) -> vector_kvector_t
        """
        _libBornAgainCore.vector_kvector_t_swiginit(self, _libBornAgainCore.new_vector_kvector_t(*args))

    def push_back(self, x):
        r"""push_back(vector_kvector_t self, kvector_t x)"""
        return _libBornAgainCore.vector_kvector_t_push_back(self, x)

    def front(self):
        r"""front(vector_kvector_t self) -> kvector_t"""
        return _libBornAgainCore.vector_kvector_t_front(self)

    def back(self):
        r"""back(vector_kvector_t self) -> kvector_t"""
        return _libBornAgainCore.vector_kvector_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_kvector_t self, std::vector< BasicVector3D< double > >::size_type n, kvector_t x)"""
        return _libBornAgainCore.vector_kvector_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_kvector_t self, std::vector< BasicVector3D< double > >::size_type new_size)
        resize(vector_kvector_t self, std::vector< BasicVector3D< double > >::size_type new_size, kvector_t x)
        """
        return _libBornAgainCore.vector_kvector_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_kvector_t self, std::vector< BasicVector3D< double > >::iterator pos, kvector_t x) -> std::vector< BasicVector3D< double > >::iterator
        insert(vector_kvector_t self, std::vector< BasicVector3D< double > >::iterator pos, std::vector< BasicVector3D< double > >::size_type n, kvector_t x)
        """
        return _libBornAgainCore.vector_kvector_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_kvector_t self, std::vector< BasicVector3D< double > >::size_type n)"""
        return _libBornAgainCore.vector_kvector_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::size_type"""
        return _libBornAgainCore.vector_kvector_t_capacity(self)
    __swig_destroy__ = _libBornAgainCore.delete_vector_kvector_t

# Register vector_kvector_t in _libBornAgainCore:
_libBornAgainCore.vector_kvector_t_swigregister(vector_kvector_t)

class cvector_t(object):
    r"""Proxy of C++ BasicVector3D< 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__(cvector_t self) -> cvector_t
        __init__(cvector_t self, std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> cvector_t
        """
        _libBornAgainCore.cvector_t_swiginit(self, _libBornAgainCore.new_cvector_t(*args))

    def x(self):
        r"""x(cvector_t self) -> std::complex< double >"""
        return _libBornAgainCore.cvector_t_x(self)

    def y(self):
        r"""y(cvector_t self) -> std::complex< double >"""
        return _libBornAgainCore.cvector_t_y(self)

    def z(self):
        r"""z(cvector_t self) -> std::complex< double >"""
        return _libBornAgainCore.cvector_t_z(self)

    def setX(self, a):
        r"""setX(cvector_t self, std::complex< double > const & a)"""
        return _libBornAgainCore.cvector_t_setX(self, a)

    def setY(self, a):
        r"""setY(cvector_t self, std::complex< double > const & a)"""
        return _libBornAgainCore.cvector_t_setY(self, a)

    def setZ(self, a):
        r"""setZ(cvector_t self, std::complex< double > const & a)"""
        return _libBornAgainCore.cvector_t_setZ(self, a)

    def __iadd__(self, v):
        r"""__iadd__(cvector_t self, cvector_t v) -> cvector_t"""
        return _libBornAgainCore.cvector_t___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(cvector_t self, cvector_t v) -> cvector_t"""
        return _libBornAgainCore.cvector_t___isub__(self, v)

    def conj(self):
        r"""conj(cvector_t self) -> cvector_t"""
        return _libBornAgainCore.cvector_t_conj(self)

    def mag2(self):
        r"""mag2(cvector_t self) -> double"""
        return _libBornAgainCore.cvector_t_mag2(self)

    def mag(self):
        r"""mag(cvector_t self) -> double"""
        return _libBornAgainCore.cvector_t_mag(self)

    def magxy2(self):
        r"""magxy2(cvector_t self) -> double"""
        return _libBornAgainCore.cvector_t_magxy2(self)

    def magxy(self):
        r"""magxy(cvector_t self) -> double"""
        return _libBornAgainCore.cvector_t_magxy(self)

    def unit(self):
        r"""unit(cvector_t self) -> cvector_t"""
        return _libBornAgainCore.cvector_t_unit(self)

    def real(self):
        r"""real(cvector_t self) -> kvector_t"""
        return _libBornAgainCore.cvector_t_real(self)

    def project(self, v):
        r"""project(cvector_t self, cvector_t v) -> cvector_t"""
        return _libBornAgainCore.cvector_t_project(self, v)
    __swig_destroy__ = _libBornAgainCore.delete_cvector_t

# Register cvector_t in _libBornAgainCore:
_libBornAgainCore.cvector_t_swigregister(cvector_t)

class vector_cvector_t(object):
    r"""Proxy of C++ std::vector< BasicVector3D< 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_cvector_t self) -> SwigPyIterator"""
        return _libBornAgainCore.vector_cvector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(vector_cvector_t self) -> bool"""
        return _libBornAgainCore.vector_cvector_t___nonzero__(self)

    def __bool__(self):
        r"""__bool__(vector_cvector_t self) -> bool"""
        return _libBornAgainCore.vector_cvector_t___bool__(self)

    def __len__(self):
        r"""__len__(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
        return _libBornAgainCore.vector_cvector_t___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j) -> vector_cvector_t"""
        return _libBornAgainCore.vector_cvector_t___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j)
        __setslice__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j, vector_cvector_t v)
        """
        return _libBornAgainCore.vector_cvector_t___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, std::vector< BasicVector3D< std::complex< double > > >::difference_type j)"""
        return _libBornAgainCore.vector_cvector_t___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i)
        __delitem__(vector_cvector_t self, PySliceObject * slice)
        """
        return _libBornAgainCore.vector_cvector_t___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(vector_cvector_t self, PySliceObject * slice) -> vector_cvector_t
        __getitem__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i) -> cvector_t
        """
        return _libBornAgainCore.vector_cvector_t___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(vector_cvector_t self, PySliceObject * slice, vector_cvector_t v)
        __setitem__(vector_cvector_t self, PySliceObject * slice)
        __setitem__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::difference_type i, cvector_t x)
        """
        return _libBornAgainCore.vector_cvector_t___setitem__(self, *args)

    def pop(self):
        r"""pop(vector_cvector_t self) -> cvector_t"""
        return _libBornAgainCore.vector_cvector_t_pop(self)

    def append(self, x):
        r"""append(vector_cvector_t self, cvector_t x)"""
        return _libBornAgainCore.vector_cvector_t_append(self, x)

    def empty(self):
        r"""empty(vector_cvector_t self) -> bool"""
        return _libBornAgainCore.vector_cvector_t_empty(self)

    def size(self):
        r"""size(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
        return _libBornAgainCore.vector_cvector_t_size(self)

    def swap(self, v):
        r"""swap(vector_cvector_t self, vector_cvector_t v)"""
        return _libBornAgainCore.vector_cvector_t_swap(self, v)

    def begin(self):
        r"""begin(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::iterator"""
        return _libBornAgainCore.vector_cvector_t_begin(self)

    def end(self):
        r"""end(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::iterator"""
        return _libBornAgainCore.vector_cvector_t_end(self)

    def rbegin(self):
        r"""rbegin(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::reverse_iterator"""
        return _libBornAgainCore.vector_cvector_t_rbegin(self)

    def rend(self):
        r"""rend(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::reverse_iterator"""
        return _libBornAgainCore.vector_cvector_t_rend(self)

    def clear(self):
        r"""clear(vector_cvector_t self)"""
        return _libBornAgainCore.vector_cvector_t_clear(self)

    def get_allocator(self):
        r"""get_allocator(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::allocator_type"""
        return _libBornAgainCore.vector_cvector_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_cvector_t self)"""
        return _libBornAgainCore.vector_cvector_t_pop_back(self)

    def erase(self, *args):
        r"""
        erase(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos) -> std::vector< BasicVector3D< std::complex< double > > >::iterator
        erase(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::iterator first, std::vector< BasicVector3D< std::complex< double > > >::iterator last) -> std::vector< BasicVector3D< std::complex< double > > >::iterator
        """
        return _libBornAgainCore.vector_cvector_t_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(vector_cvector_t self) -> vector_cvector_t
        __init__(vector_cvector_t self, vector_cvector_t other) -> vector_cvector_t
        __init__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::size_type size) -> vector_cvector_t
        __init__(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::size_type size, cvector_t value) -> vector_cvector_t
        """
        _libBornAgainCore.vector_cvector_t_swiginit(self, _libBornAgainCore.new_vector_cvector_t(*args))

    def push_back(self, x):
        r"""push_back(vector_cvector_t self, cvector_t x)"""
        return _libBornAgainCore.vector_cvector_t_push_back(self, x)

    def front(self):
        r"""front(vector_cvector_t self) -> cvector_t"""
        return _libBornAgainCore.vector_cvector_t_front(self)

    def back(self):
        r"""back(vector_cvector_t self) -> cvector_t"""
        return _libBornAgainCore.vector_cvector_t_back(self)

    def assign(self, n, x):
        r"""assign(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::size_type n, cvector_t x)"""
        return _libBornAgainCore.vector_cvector_t_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::size_type new_size)
        resize(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::size_type new_size, cvector_t x)
        """
        return _libBornAgainCore.vector_cvector_t_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos, cvector_t x) -> std::vector< BasicVector3D< std::complex< double > > >::iterator
        insert(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::iterator pos, std::vector< BasicVector3D< std::complex< double > > >::size_type n, cvector_t x)
        """
        return _libBornAgainCore.vector_cvector_t_insert(self, *args)

    def reserve(self, n):
        r"""reserve(vector_cvector_t self, std::vector< BasicVector3D< std::complex< double > > >::size_type n)"""
        return _libBornAgainCore.vector_cvector_t_reserve(self, n)

    def capacity(self):
        r"""capacity(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
        return _libBornAgainCore.vector_cvector_t_capacity(self)
    __swig_destroy__ = _libBornAgainCore.delete_vector_cvector_t

# Register vector_cvector_t in _libBornAgainCore:
_libBornAgainCore.vector_cvector_t_swigregister(vector_cvector_t)

import libBornAgainParam
import libBornAgainSample
class swig_dummy_type_axisinfo_vector(object):
    r"""Proxy of C++ std::vector< AxisInfo > class."""

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

    def iterator(self):
        r"""iterator(swig_dummy_type_axisinfo_vector self) -> SwigPyIterator"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(swig_dummy_type_axisinfo_vector self) -> bool"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(swig_dummy_type_axisinfo_vector self) -> bool"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___bool__(self)

    def __len__(self):
        r"""__len__(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::size_type"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j) -> swig_dummy_type_axisinfo_vector"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j)
        __setslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j, swig_dummy_type_axisinfo_vector v)
        """
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::difference_type j)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i)
        __delitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice)
        """
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice) -> swig_dummy_type_axisinfo_vector
        __getitem__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i) -> std::vector< AxisInfo >::value_type const &
        """
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice, swig_dummy_type_axisinfo_vector v)
        __setitem__(swig_dummy_type_axisinfo_vector self, PySliceObject * slice)
        __setitem__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::difference_type i, std::vector< AxisInfo >::value_type const & x)
        """
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector___setitem__(self, *args)

    def pop(self):
        r"""pop(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::value_type"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_pop(self)

    def append(self, x):
        r"""append(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::value_type const & x)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_append(self, x)

    def empty(self):
        r"""empty(swig_dummy_type_axisinfo_vector self) -> bool"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_empty(self)

    def size(self):
        r"""size(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::size_type"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_size(self)

    def swap(self, v):
        r"""swap(swig_dummy_type_axisinfo_vector self, swig_dummy_type_axisinfo_vector v)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_swap(self, v)

    def begin(self):
        r"""begin(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::iterator"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_begin(self)

    def end(self):
        r"""end(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::iterator"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_end(self)

    def rbegin(self):
        r"""rbegin(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::reverse_iterator"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_rbegin(self)

    def rend(self):
        r"""rend(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::reverse_iterator"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_rend(self)

    def clear(self):
        r"""clear(swig_dummy_type_axisinfo_vector self)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_clear(self)

    def get_allocator(self):
        r"""get_allocator(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::allocator_type"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(swig_dummy_type_axisinfo_vector self)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator pos) -> std::vector< AxisInfo >::iterator
        erase(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator first, std::vector< AxisInfo >::iterator last) -> std::vector< AxisInfo >::iterator
        """
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(swig_dummy_type_axisinfo_vector self) -> swig_dummy_type_axisinfo_vector
        __init__(swig_dummy_type_axisinfo_vector self, swig_dummy_type_axisinfo_vector other) -> swig_dummy_type_axisinfo_vector
        __init__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type size) -> swig_dummy_type_axisinfo_vector
        __init__(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type size, std::vector< AxisInfo >::value_type const & value) -> swig_dummy_type_axisinfo_vector
        """
        _libBornAgainCore.swig_dummy_type_axisinfo_vector_swiginit(self, _libBornAgainCore.new_swig_dummy_type_axisinfo_vector(*args))

    def push_back(self, x):
        r"""push_back(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::value_type const & x)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_push_back(self, x)

    def front(self):
        r"""front(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::value_type const &"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_front(self)

    def back(self):
        r"""back(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::value_type const &"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_back(self)

    def assign(self, n, x):
        r"""assign(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type n, std::vector< AxisInfo >::value_type const & x)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type new_size)
        resize(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type new_size, std::vector< AxisInfo >::value_type const & x)
        """
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator pos, std::vector< AxisInfo >::value_type const & x) -> std::vector< AxisInfo >::iterator
        insert(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::iterator pos, std::vector< AxisInfo >::size_type n, std::vector< AxisInfo >::value_type const & x)
        """
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(swig_dummy_type_axisinfo_vector self, std::vector< AxisInfo >::size_type n)"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_reserve(self, n)

    def capacity(self):
        r"""capacity(swig_dummy_type_axisinfo_vector self) -> std::vector< AxisInfo >::size_type"""
        return _libBornAgainCore.swig_dummy_type_axisinfo_vector_capacity(self)
    __swig_destroy__ = _libBornAgainCore.delete_swig_dummy_type_axisinfo_vector

# Register swig_dummy_type_axisinfo_vector in _libBornAgainCore:
_libBornAgainCore.swig_dummy_type_axisinfo_vector_swigregister(swig_dummy_type_axisinfo_vector)

class swig_dummy_type_inode_vector(object):
    r"""Proxy of C++ std::vector< INode * > class."""

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

    def iterator(self):
        r"""iterator(swig_dummy_type_inode_vector self) -> SwigPyIterator"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(swig_dummy_type_inode_vector self) -> bool"""
        return _libBornAgainCore.swig_dummy_type_inode_vector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(swig_dummy_type_inode_vector self) -> bool"""
        return _libBornAgainCore.swig_dummy_type_inode_vector___bool__(self)

    def __len__(self):
        r"""__len__(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
        return _libBornAgainCore.swig_dummy_type_inode_vector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j) -> swig_dummy_type_inode_vector"""
        return _libBornAgainCore.swig_dummy_type_inode_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j)
        __setslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j, swig_dummy_type_inode_vector v)
        """
        return _libBornAgainCore.swig_dummy_type_inode_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, std::vector< INode * >::difference_type j)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i)
        __delitem__(swig_dummy_type_inode_vector self, PySliceObject * slice)
        """
        return _libBornAgainCore.swig_dummy_type_inode_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(swig_dummy_type_inode_vector self, PySliceObject * slice) -> swig_dummy_type_inode_vector
        __getitem__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i) -> INode
        """
        return _libBornAgainCore.swig_dummy_type_inode_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(swig_dummy_type_inode_vector self, PySliceObject * slice, swig_dummy_type_inode_vector v)
        __setitem__(swig_dummy_type_inode_vector self, PySliceObject * slice)
        __setitem__(swig_dummy_type_inode_vector self, std::vector< INode * >::difference_type i, INode x)
        """
        return _libBornAgainCore.swig_dummy_type_inode_vector___setitem__(self, *args)

    def pop(self):
        r"""pop(swig_dummy_type_inode_vector self) -> INode"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_pop(self)

    def append(self, x):
        r"""append(swig_dummy_type_inode_vector self, INode x)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_append(self, x)

    def empty(self):
        r"""empty(swig_dummy_type_inode_vector self) -> bool"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_empty(self)

    def size(self):
        r"""size(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_size(self)

    def swap(self, v):
        r"""swap(swig_dummy_type_inode_vector self, swig_dummy_type_inode_vector v)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_swap(self, v)

    def begin(self):
        r"""begin(swig_dummy_type_inode_vector self) -> std::vector< INode * >::iterator"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_begin(self)

    def end(self):
        r"""end(swig_dummy_type_inode_vector self) -> std::vector< INode * >::iterator"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_end(self)

    def rbegin(self):
        r"""rbegin(swig_dummy_type_inode_vector self) -> std::vector< INode * >::reverse_iterator"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_rbegin(self)

    def rend(self):
        r"""rend(swig_dummy_type_inode_vector self) -> std::vector< INode * >::reverse_iterator"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_rend(self)

    def clear(self):
        r"""clear(swig_dummy_type_inode_vector self)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_clear(self)

    def get_allocator(self):
        r"""get_allocator(swig_dummy_type_inode_vector self) -> std::vector< INode * >::allocator_type"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(swig_dummy_type_inode_vector self)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator pos) -> std::vector< INode * >::iterator
        erase(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator first, std::vector< INode * >::iterator last) -> std::vector< INode * >::iterator
        """
        return _libBornAgainCore.swig_dummy_type_inode_vector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(swig_dummy_type_inode_vector self) -> swig_dummy_type_inode_vector
        __init__(swig_dummy_type_inode_vector self, swig_dummy_type_inode_vector other) -> swig_dummy_type_inode_vector
        __init__(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type size) -> swig_dummy_type_inode_vector
        __init__(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type size, INode value) -> swig_dummy_type_inode_vector
        """
        _libBornAgainCore.swig_dummy_type_inode_vector_swiginit(self, _libBornAgainCore.new_swig_dummy_type_inode_vector(*args))

    def push_back(self, x):
        r"""push_back(swig_dummy_type_inode_vector self, INode x)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_push_back(self, x)

    def front(self):
        r"""front(swig_dummy_type_inode_vector self) -> INode"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_front(self)

    def back(self):
        r"""back(swig_dummy_type_inode_vector self) -> INode"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_back(self)

    def assign(self, n, x):
        r"""assign(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type n, INode x)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type new_size)
        resize(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type new_size, INode x)
        """
        return _libBornAgainCore.swig_dummy_type_inode_vector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator pos, INode x) -> std::vector< INode * >::iterator
        insert(swig_dummy_type_inode_vector self, std::vector< INode * >::iterator pos, std::vector< INode * >::size_type n, INode x)
        """
        return _libBornAgainCore.swig_dummy_type_inode_vector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(swig_dummy_type_inode_vector self, std::vector< INode * >::size_type n)"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_reserve(self, n)

    def capacity(self):
        r"""capacity(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
        return _libBornAgainCore.swig_dummy_type_inode_vector_capacity(self)
    __swig_destroy__ = _libBornAgainCore.delete_swig_dummy_type_inode_vector

# Register swig_dummy_type_inode_vector in _libBornAgainCore:
_libBornAgainCore.swig_dummy_type_inode_vector_swigregister(swig_dummy_type_inode_vector)

class swig_dummy_type_const_inode_vector(object):
    r"""Proxy of C++ std::vector< INode const * > class."""

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

    def iterator(self):
        r"""iterator(swig_dummy_type_const_inode_vector self) -> SwigPyIterator"""
        return _libBornAgainCore.swig_dummy_type_const_inode_vector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class FitObjective(object):
    r"""


    Holds vector of   SimDataPairs (experimental data and simulation results) for use in fitting.

    C++ includes: FitObjective.h

    """

    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
        FitObjective::FitObjective()

        """
        if self.__class__ == FitObjective:
            _self = None
        else:
            _self = self
        _libBornAgainCore.FitObjective_swiginit(self, _libBornAgainCore.new_FitObjective(_self, ))
    __swig_destroy__ = _libBornAgainCore.delete_FitObjective

    def evaluate_cpp(self, params):
        r"""
        evaluate_cpp(FitObjective self, mumufit::Parameters const & params) -> double
        double FitObjective::evaluate(const mumufit::Parameters &params)

        """
        return _libBornAgainCore.FitObjective_evaluate_cpp(self, params)

    def evaluate_residuals_cpp(self, params):
        r"""
        evaluate_residuals_cpp(FitObjective self, mumufit::Parameters const & params) -> vdouble1d_t
        std::vector< double > FitObjective::evaluate_residuals(const mumufit::Parameters &params)

        """
        return _libBornAgainCore.FitObjective_evaluate_residuals_cpp(self, params)

    def numberOfFitElements(self):
        r"""
        numberOfFitElements(FitObjective self) -> size_t
        size_t FitObjective::numberOfFitElements() const

        """
        return _libBornAgainCore.FitObjective_numberOfFitElements(self)

    def simulationResult(self, i_item=0):
        r"""
        simulationResult(FitObjective self, size_t i_item=0) -> SimulationResult
        SimulationResult FitObjective::simulationResult(size_t i_item=0) const

        Returns simulation result in the form of SimulationResult. 

        """
        return _libBornAgainCore.FitObjective_simulationResult(self, i_item)

    def experimentalData(self, i_item=0):
        r"""
        experimentalData(FitObjective self, size_t i_item=0) -> SimulationResult
        SimulationResult FitObjective::experimentalData(size_t i_item=0) const

        Returns experimental data in the form of SimulationResult. 

        """
        return _libBornAgainCore.FitObjective_experimentalData(self, i_item)

    def uncertaintyData_cpp(self, i_item=0):
        r"""
        uncertaintyData_cpp(FitObjective self, size_t i_item=0) -> SimulationResult
        SimulationResult FitObjective::uncertaintyData(size_t i_item=0) const

        Returns experimental data uncertainties in the form of SimulationResult. 

        """
        return _libBornAgainCore.FitObjective_uncertaintyData_cpp(self, i_item)

    def relativeDifference(self, i_item=0):
        r"""
        relativeDifference(FitObjective self, size_t i_item=0) -> SimulationResult
        SimulationResult FitObjective::relativeDifference(size_t i_item=0) const

        Returns relative difference between simulation and experimental data in the form of SimulationResult. 

        """
        return _libBornAgainCore.FitObjective_relativeDifference(self, i_item)

    def absoluteDifference(self, i_item=0):
        r"""
        absoluteDifference(FitObjective self, size_t i_item=0) -> SimulationResult
        SimulationResult FitObjective::absoluteDifference(size_t i_item=0) const

        Returns absolute value of difference between simulation and experimental data in the form of SimulationResult. 

        """
        return _libBornAgainCore.FitObjective_absoluteDifference(self, i_item)

    def experimental_array(self):
        r"""
        experimental_array(FitObjective self) -> vdouble1d_t
        std::vector< double > FitObjective::experimental_array() const

        Returns one dimensional array representing merged experimental data. The area outside of the region of interest is not included, masked data is nullified. 

        """
        return _libBornAgainCore.FitObjective_experimental_array(self)

    def simulation_array(self):
        r"""
        simulation_array(FitObjective self) -> vdouble1d_t
        std::vector< double > FitObjective::simulation_array() const

        Returns one dimensional array representing merged simulated intensities data. The area outside of the region of interest is not included, masked data is nullified. 

        """
        return _libBornAgainCore.FitObjective_simulation_array(self)

    def uncertainties_cpp(self):
        r"""
        uncertainties_cpp(FitObjective self) -> vdouble1d_t
        std::vector< double > FitObjective::uncertainties() const

        Returns one-dimensional array representing merged data uncertainties. The area outside of the region of interest is not included, masked data is nullified. 

        """
        return _libBornAgainCore.FitObjective_uncertainties_cpp(self)

    def weights_array(self):
        r"""
        weights_array(FitObjective self) -> vdouble1d_t
        std::vector< double > FitObjective::weights_array() const

        Returns one-dimensional array representing merged user weights. The area outside of the region of interest is not included, masked data is nullified. 

        """
        return _libBornAgainCore.FitObjective_weights_array(self)

    def initPrint(self, every_nth):
        r"""
        initPrint(FitObjective self, int every_nth)
        void FitObjective::initPrint(int every_nth)

        Initializes printing to standard output on every_nth fit iteration. 

        """
        return _libBornAgainCore.FitObjective_initPrint(self, every_nth)

    def initPlot_cpp(self, every_nth, callback):
        r"""
        initPlot_cpp(FitObjective self, int every_nth, PyObserverCallback callback)
        void FitObjective::initPlot(int every_nth, fit_observer_t observer)

        """
        return _libBornAgainCore.FitObjective_initPlot_cpp(self, every_nth, callback)

    def iterationInfo(self):
        r"""
        iterationInfo(FitObjective self) -> IterationInfo
        IterationInfo FitObjective::iterationInfo() const

        """
        return _libBornAgainCore.FitObjective_iterationInfo(self)

    def minimizerResult(self):
        r"""
        minimizerResult(FitObjective self) -> mumufit::MinimizerResult
        mumufit::MinimizerResult FitObjective::minimizerResult() const

        """
        return _libBornAgainCore.FitObjective_minimizerResult(self)

    def finalize_cpp(self, result):
        r"""
        finalize_cpp(FitObjective self, mumufit::MinimizerResult const & result)
        void FitObjective::finalize(const mumufit::MinimizerResult &result)

        Should be explicitely called on last iteration to notify all observers. 

        """
        return _libBornAgainCore.FitObjective_finalize_cpp(self, result)

    def fitObjectCount(self):
        r"""
        fitObjectCount(FitObjective self) -> unsigned int
        unsigned FitObjective::fitObjectCount() const

        """
        return _libBornAgainCore.FitObjective_fitObjectCount(self)

    def run_simulations(self, params):
        r"""
        run_simulations(FitObjective self, mumufit::Parameters const & params)
        void FitObjective::run_simulations(const mumufit::Parameters &params)

        """
        return _libBornAgainCore.FitObjective_run_simulations(self, params)

    def setChiSquaredModule(self, module):
        r"""
        setChiSquaredModule(FitObjective self, IChiSquaredModule module)
        void FitObjective::setChiSquaredModule(const IChiSquaredModule &module)

        """
        return _libBornAgainCore.FitObjective_setChiSquaredModule(self, module)

    def setObjectiveMetric(self, *args):
        r"""
        setObjectiveMetric(FitObjective self, std::string const & metric)
        setObjectiveMetric(FitObjective self, std::string const & metric, std::string const & norm)
        void FitObjective::setObjectiveMetric(std::unique_ptr< ObjectiveMetric > metric)

        """
        return _libBornAgainCore.FitObjective_setObjectiveMetric(self, *args)

    def containsUncertainties_cpp(self, i_item):
        r"""
        containsUncertainties_cpp(FitObjective self, size_t i_item) -> bool
        bool FitObjective::containsUncertainties(size_t i_item) const

        Returns true if the specified DataPair element contains uncertainties. 

        """
        return _libBornAgainCore.FitObjective_containsUncertainties_cpp(self, i_item)

    def allPairsHaveUncertainties_cpp(self):
        r"""
        allPairsHaveUncertainties_cpp(FitObjective self) -> bool
        bool FitObjective::allPairsHaveUncertainties() const

        Returns true if all the data pairs in  FitObjective instance contain uncertainties. 

        """
        return _libBornAgainCore.FitObjective_allPairsHaveUncertainties_cpp(self)

    @staticmethod
    def availableMetricOptions():
        r"""availableMetricOptions() -> std::string"""
        return _libBornAgainCore.FitObjective_availableMetricOptions()

    def addSimulationAndData_cpp(self, *args):
        r"""
        addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble1d_t data, double weight=1.0)
        addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble1d_t data, vdouble1d_t uncertainties, double weight=1.0)
        addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble2d_t data, double weight=1.0)
        addSimulationAndData_cpp(FitObjective self, PyBuilderCallback callback, vdouble2d_t data, vdouble2d_t uncertainties, double weight=1.0)
        void FitObjective::addSimulationAndData(PyBuilderCallback &callback, const T &data, const T &uncertainties, double weight=1.0)

        Constructs simulation/data pair for later fit.

        Parameters:
        -----------

        callback: 
        simulation builder capable of producing simulations

        data: 
        experimental data array

        uncertainties: 
        data uncertainties array

        weight: 
        weight of dataset in metric calculations 

        """
        return _libBornAgainCore.FitObjective_addSimulationAndData_cpp(self, *args)

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

        Arguments:

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

        data -- numpy array with experimental data.

        uncertainties -- numpy array with experimental data uncertainties.
        Array shape must correspond to the shape of data. Optional argument.

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

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

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

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

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

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

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

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

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

    def uncertainties(self):
        """
        Returns one-dimensional array representing merged data uncertainties.
        If any of the associated data pairs lack uncertainties, returns None.
        """
        if self.allPairsHaveUncertainties_cpp():
            return self.uncertainties_cpp()
        return None

    def uncertaintyData(self, i=0):
        """
        Returns uncertainties for i-th simulation-data pair. If
        no uncertainties are assigned to the data pair, returns
        None.
        """
        if self.containsUncertainties_cpp(i):
            return self.uncertaintyData_cpp(i)
        return None

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

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

def FitObjective_availableMetricOptions():
    r"""FitObjective_availableMetricOptions() -> std::string"""
    return _libBornAgainCore.FitObjective_availableMetricOptions()


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

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

def GetPatchVersionNumber():
    r"""GetPatchVersionNumber() -> int"""
    return _libBornAgainCore.GetPatchVersionNumber()

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

def GetVersionNumber():
    r"""GetVersionNumber() -> std::string"""
    return _libBornAgainCore.GetVersionNumber()
class IterationInfo(object):
    r"""


    Stores fit iteration info to track fit flow from various observers. Used in context of  FitObjective.

    C++ includes: IterationInfo.h

    """

    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
        IterationInfo::IterationInfo()

        """
        _libBornAgainCore.IterationInfo_swiginit(self, _libBornAgainCore.new_IterationInfo())

    def update(self, params, chi2):
        r"""
        update(IterationInfo self, mumufit::Parameters const & params, double chi2)
        void IterationInfo::update(const mumufit::Parameters &params, double chi2)

        """
        return _libBornAgainCore.IterationInfo_update(self, params, chi2)

    def iterationCount(self):
        r"""
        iterationCount(IterationInfo self) -> unsigned int
        unsigned IterationInfo::iterationCount() const

        Returns current number of minimizer iterations. 

        """
        return _libBornAgainCore.IterationInfo_iterationCount(self)

    def chi2(self):
        r"""
        chi2(IterationInfo self) -> double
        double IterationInfo::chi2() const

        """
        return _libBornAgainCore.IterationInfo_chi2(self)

    def parameters(self):
        r"""
        parameters(IterationInfo self) -> mumufit::Parameters
        mumufit::Parameters IterationInfo::parameters() const

        """
        return _libBornAgainCore.IterationInfo_parameters(self)

    def parameterMap(self):
        r"""
        parameterMap(IterationInfo self) -> map_string_double_t
        std::map< std::string, double > IterationInfo::parameterMap() const

        Returns map of fit parameter names and its current values. 

        """
        return _libBornAgainCore.IterationInfo_parameterMap(self)
    __swig_destroy__ = _libBornAgainCore.delete_IterationInfo

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

class PyBuilderCallback(object):
    r"""


    Builds simulation object using a Python callable. Base class to wrap Python callable and pass it to C++. Used in swig interface file, intended to be overloaded from Python.

    C++ includes: PyFittingCallbacks.h

    """

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

    def __init__(self):
        r"""
        __init__(PyBuilderCallback self) -> PyBuilderCallback
        PyBuilderCallback::PyBuilderCallback()

        """
        if self.__class__ == PyBuilderCallback:
            _self = None
        else:
            _self = self
        _libBornAgainCore.PyBuilderCallback_swiginit(self, _libBornAgainCore.new_PyBuilderCallback(_self, ))
    __swig_destroy__ = _libBornAgainCore.delete_PyBuilderCallback

    def build_simulation(self, arg0):
        r"""
        build_simulation(PyBuilderCallback self, mumufit::Parameters arg0) -> ISimulation
        ISimulation * PyBuilderCallback::build_simulation(mumufit::Parameters)

        """
        return _libBornAgainCore.PyBuilderCallback_build_simulation(self, arg0)
    def __disown__(self):
        self.this.disown()
        _libBornAgainCore.disown_PyBuilderCallback(self)
        return weakref.proxy(self)

# Register PyBuilderCallback in _libBornAgainCore:
_libBornAgainCore.PyBuilderCallback_swigregister(PyBuilderCallback)

class PyObserverCallback(object):
    r"""


    Observer for  FitObjective based on Python callable. Base class to wrap Python callable and pass it to C++. Used in swig interface file, intended to be overloaded from Python.

    C++ includes: PyFittingCallbacks.h

    """

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

    def __init__(self):
        r"""
        __init__(PyObserverCallback self) -> PyObserverCallback
        PyObserverCallback::PyObserverCallback()

        """
        if self.__class__ == PyObserverCallback:
            _self = None
        else:
            _self = self
        _libBornAgainCore.PyObserverCallback_swiginit(self, _libBornAgainCore.new_PyObserverCallback(_self, ))
    __swig_destroy__ = _libBornAgainCore.delete_PyObserverCallback

    def update(self, arg0):
        r"""
        update(PyObserverCallback self, FitObjective arg0)
        void PyObserverCallback::update(const FitObjective &)

        """
        return _libBornAgainCore.PyObserverCallback_update(self, arg0)
    def __disown__(self):
        self.this.disown()
        _libBornAgainCore.disown_PyObserverCallback(self)
        return weakref.proxy(self)

# Register PyObserverCallback in _libBornAgainCore:
_libBornAgainCore.PyObserverCallback_swigregister(PyObserverCallback)

class AngularSpecScan(object):
    r"""


    Scan type with inclination angles as coordinate values and a unique wavelength. Features footprint correction.

    C++ includes: AngularSpecScan.h

    """

    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__(AngularSpecScan self, double wl, vdouble1d_t inc_angle) -> AngularSpecScan
        __init__(AngularSpecScan self, double wl, IAxis inc_angle) -> AngularSpecScan
        __init__(AngularSpecScan self, double wl, int nbins, double alpha_i_min, double alpha_i_max) -> AngularSpecScan
        AngularSpecScan::AngularSpecScan(double wl, int nbins, double alpha_i_min, double alpha_i_max)

        Sets angle-defined specular scan. The first parameter is always a wavelength in nm. Second parameter is either a numpy array of incident angles in radians or an IAxis object with angle values. Alternatively an axis can be defined in-place, then the second passed parameter is the number of bins, third - minimum on-axis angle value, fourth - maximum on-axis angle value. 

        """
        _libBornAgainCore.AngularSpecScan_swiginit(self, _libBornAgainCore.new_AngularSpecScan(*args))
    __swig_destroy__ = _libBornAgainCore.delete_AngularSpecScan

    def clone(self):
        r"""
        clone(AngularSpecScan self) -> AngularSpecScan
        AngularSpecScan * AngularSpecScan::clone() const override

        """
        return _libBornAgainCore.AngularSpecScan_clone(self)

    def setFootprintFactor(self, f_factor):
        r"""
        setFootprintFactor(AngularSpecScan self, IFootprintFactor const * f_factor)
        void AngularSpecScan::setFootprintFactor(const IFootprintFactor *f_factor)

        Sets footprint correction factor. 

        """
        return _libBornAgainCore.AngularSpecScan_setFootprintFactor(self, f_factor)

    def setWavelengthResolution(self, resolution):
        r"""
        setWavelengthResolution(AngularSpecScan self, ScanResolution const & resolution)
        void AngularSpecScan::setWavelengthResolution(const ScanResolution &resolution)

        Sets wavelength resolution values via ScanResolution object. 

        """
        return _libBornAgainCore.AngularSpecScan_setWavelengthResolution(self, resolution)

    def setRelativeWavelengthResolution(self, *args):
        r"""
        setRelativeWavelengthResolution(AngularSpecScan self, IRangedDistribution const & distr, double rel_dev)
        setRelativeWavelengthResolution(AngularSpecScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
        void AngularSpecScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)

        Sets wavelength resolution values via IRangedDistribution and values of relative deviations (that is,  rel_dev equals standard deviation divided by the mean value).  rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. 

        """
        return _libBornAgainCore.AngularSpecScan_setRelativeWavelengthResolution(self, *args)

    def setAbsoluteWavelengthResolution(self, *args):
        r"""
        setAbsoluteWavelengthResolution(AngularSpecScan self, IRangedDistribution const & distr, double std_dev)
        setAbsoluteWavelengthResolution(AngularSpecScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
        void AngularSpecScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)

        Sets wavelength resolution values via IRangedDistribution and values of standard deviations.  std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. 

        """
        return _libBornAgainCore.AngularSpecScan_setAbsoluteWavelengthResolution(self, *args)

    def setAngleResolution(self, resolution):
        r"""
        setAngleResolution(AngularSpecScan self, ScanResolution const & resolution)
        void AngularSpecScan::setAngleResolution(const ScanResolution &resolution)

        Sets angle resolution values via ScanResolution object. 

        """
        return _libBornAgainCore.AngularSpecScan_setAngleResolution(self, resolution)

    def setRelativeAngularResolution(self, *args):
        r"""
        setRelativeAngularResolution(AngularSpecScan self, IRangedDistribution const & distr, double rel_dev)
        setRelativeAngularResolution(AngularSpecScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
        void AngularSpecScan::setRelativeAngularResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)

        Sets angular resolution values via IRangedDistribution and values of relative deviations (that is,  rel_dev equals standard deviation divided by the mean value).  rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. 

        """
        return _libBornAgainCore.AngularSpecScan_setRelativeAngularResolution(self, *args)

    def setAbsoluteAngularResolution(self, *args):
        r"""
        setAbsoluteAngularResolution(AngularSpecScan self, IRangedDistribution const & distr, double std_dev)
        setAbsoluteAngularResolution(AngularSpecScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
        void AngularSpecScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)

        Sets angular resolution values via IRangedDistribution and values of standard deviations.  std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. 

        """
        return _libBornAgainCore.AngularSpecScan_setAbsoluteAngularResolution(self, *args)

# Register AngularSpecScan in _libBornAgainCore:
_libBornAgainCore.AngularSpecScan_swigregister(AngularSpecScan)

class QSpecScan(object):
    r"""


    Scan type with z-components of scattering vector as coordinate values. Wavelength and incident angles are not accessible separately.

    C++ includes: QSpecScan.h

    """

    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__(QSpecScan self, vdouble1d_t qs_nm) -> QSpecScan
        __init__(QSpecScan self, IAxis qs_nm) -> QSpecScan
        __init__(QSpecScan self, int nbins, double qz_min, double qz_max) -> QSpecScan
        QSpecScan::QSpecScan(int nbins, double qz_min, double qz_max)

        Sets q-defined specular scan. Accepts either numpy array of q-values sorted in ascending order or an IAxis object with q-values. Alternatively an axis can be defined in-place, then the first passed parameter is the number of bins, second - minimum on-axis q-value, third - maximum on-axis q_value. 

        """
        _libBornAgainCore.QSpecScan_swiginit(self, _libBornAgainCore.new_QSpecScan(*args))
    __swig_destroy__ = _libBornAgainCore.delete_QSpecScan

    def clone(self):
        r"""
        clone(QSpecScan self) -> QSpecScan
        QSpecScan * QSpecScan::clone() const override

        """
        return _libBornAgainCore.QSpecScan_clone(self)

    def resolution(self):
        r"""
        resolution(QSpecScan self) -> ScanResolution const *
        const ScanResolution* QSpecScan::resolution() const

        """
        return _libBornAgainCore.QSpecScan_resolution(self)

    def setQResolution(self, resolution):
        r"""
        setQResolution(QSpecScan self, ScanResolution const & resolution)
        void QSpecScan::setQResolution(const ScanResolution &resolution)

        Sets q resolution values via ScanResolution object. 

        """
        return _libBornAgainCore.QSpecScan_setQResolution(self, resolution)

    def setRelativeQResolution(self, *args):
        r"""
        setRelativeQResolution(QSpecScan self, IRangedDistribution const & distr, double rel_dev)
        setRelativeQResolution(QSpecScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
        void QSpecScan::setRelativeQResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)

        Sets qz resolution values via IRangedDistribution and values of relative deviations (that is,  rel_dev equals standard deviation divided by the mean value).  rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis. 

        """
        return _libBornAgainCore.QSpecScan_setRelativeQResolution(self, *args)

    def setAbsoluteQResolution(self, *args):
        r"""
        setAbsoluteQResolution(QSpecScan self, IRangedDistribution const & distr, double std_dev)
        setAbsoluteQResolution(QSpecScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
        void QSpecScan::setAbsoluteQResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)

        Sets qz resolution values via IRangedDistribution and values of standard deviations.  std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis. 

        """
        return _libBornAgainCore.QSpecScan_setAbsoluteQResolution(self, *args)

    def setOffset(self, offset):
        r"""
        setOffset(QSpecScan self, double offset)
        void QSpecScan::setOffset(double offset)

        """
        return _libBornAgainCore.QSpecScan_setOffset(self, offset)

    def offset(self):
        r"""
        offset(QSpecScan self) -> double
        double QSpecScan::offset() const

        """
        return _libBornAgainCore.QSpecScan_offset(self)

# Register QSpecScan in _libBornAgainCore:
_libBornAgainCore.QSpecScan_swigregister(QSpecScan)

class ISimulation(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""


    Abstract base class of  OffSpecularSimulation,  GISASSimulation and  SpecularSimulation. Holds the common infrastructure to run a simulation: multithreading, batch processing, weighting over parameter distributions, ...

    C++ includes: ISimulation.h

    """

    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__ = _libBornAgainCore.delete_ISimulation

    def clone(self):
        r"""
        clone(ISimulation self) -> ISimulation
        virtual ISimulation* ISimulation::clone() const =0

        """
        return _libBornAgainCore.ISimulation_clone(self)

    def prepareSimulation(self):
        r"""
        prepareSimulation(ISimulation self)
        void ISimulation::prepareSimulation()

        Put into a clean state for running a simulation. 

        """
        return _libBornAgainCore.ISimulation_prepareSimulation(self)

    def runSimulation(self):
        r"""
        runSimulation(ISimulation self)
        void ISimulation::runSimulation()

        Run a simulation, possibly averaged over parameter distributions.

        Run simulation with possible averaging over parameter distributions. 

        """
        return _libBornAgainCore.ISimulation_runSimulation(self)

    def runMPISimulation(self):
        r"""
        runMPISimulation(ISimulation self)
        void ISimulation::runMPISimulation()

        Run a simulation in a MPI environment. 

        """
        return _libBornAgainCore.ISimulation_runMPISimulation(self)

    def instrument(self, *args):
        r"""
        instrument(ISimulation self) -> Instrument const
        instrument(ISimulation self) -> Instrument &
        Instrument& ISimulation::instrument()

        """
        return _libBornAgainCore.ISimulation_instrument(self, *args)

    def beam(self, *args):
        r"""
        beam(ISimulation self) -> Beam
        beam(ISimulation self) -> Beam const &
        const Beam& ISimulation::beam() const

        """
        return _libBornAgainCore.ISimulation_beam(self, *args)

    def getDetector(self, *args):
        r"""
        getDetector(ISimulation self) -> IDetector
        getDetector(ISimulation self) -> IDetector const *
        const IDetector* ISimulation::getDetector() const

        """
        return _libBornAgainCore.ISimulation_getDetector(self, *args)

    def detector(self, *args):
        r"""
        detector(ISimulation self) -> IDetector
        detector(ISimulation self) -> IDetector const &
        const IDetector& ISimulation::detector() const

        """
        return _libBornAgainCore.ISimulation_detector(self, *args)

    def setDetectorResolutionFunction(self, resolution_function):
        r"""
        setDetectorResolutionFunction(ISimulation self, IResolutionFunction2D const & resolution_function)
        void ISimulation::setDetectorResolutionFunction(const IResolutionFunction2D &resolution_function)

        """
        return _libBornAgainCore.ISimulation_setDetectorResolutionFunction(self, resolution_function)

    def setSample(self, sample):
        r"""
        setSample(ISimulation self, MultiLayer const & sample)
        void ISimulation::setSample(const MultiLayer &sample)

        The MultiLayer object will not be owned by the  ISimulation object. 

        """
        return _libBornAgainCore.ISimulation_setSample(self, sample)

    def sample(self):
        r"""
        sample(ISimulation self) -> MultiLayer const *
        const MultiLayer * ISimulation::sample() const

        """
        return _libBornAgainCore.ISimulation_sample(self)

    def setSampleBuilderCpp(self, sample_builder):
        r"""
        setSampleBuilderCpp(ISimulation self, std::shared_ptr< ISampleBuilder > const & sample_builder)
        void ISimulation::setSampleBuilder(const std::shared_ptr< ISampleBuilder > &sample_builder)

        """
        return _libBornAgainCore.ISimulation_setSampleBuilderCpp(self, sample_builder)

    def setBackground(self, bg):
        r"""
        setBackground(ISimulation self, IBackground bg)
        void ISimulation::setBackground(const IBackground &bg)

        """
        return _libBornAgainCore.ISimulation_setBackground(self, bg)

    def background(self):
        r"""
        background(ISimulation self) -> IBackground
        const IBackground* ISimulation::background() const

        """
        return _libBornAgainCore.ISimulation_background(self)

    def intensityMapSize(self):
        r"""
        intensityMapSize(ISimulation self) -> size_t
        virtual size_t ISimulation::intensityMapSize() const =0

        Returns the total number of the intensity values in the simulation result. 

        """
        return _libBornAgainCore.ISimulation_intensityMapSize(self)

    def result(self):
        r"""
        result(ISimulation self) -> SimulationResult
        virtual SimulationResult ISimulation::result() const =0

        Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays 

        """
        return _libBornAgainCore.ISimulation_result(self)

    def addParameterDistribution(self, *args):
        r"""
        addParameterDistribution(ISimulation self, std::string const & param_name, IDistribution1D const & distribution, size_t nbr_samples, double sigma_factor=0.0, RealLimits const & limits=RealLimits())
        addParameterDistribution(ISimulation self, ParameterDistribution par_distr)
        void ISimulation::addParameterDistribution(const ParameterDistribution &par_distr)

        """
        return _libBornAgainCore.ISimulation_addParameterDistribution(self, *args)

    def getDistributionHandler(self):
        r"""
        getDistributionHandler(ISimulation self) -> DistributionHandler const &
        const DistributionHandler& ISimulation::getDistributionHandler() const

        """
        return _libBornAgainCore.ISimulation_getDistributionHandler(self)

    def setOptions(self, options):
        r"""
        setOptions(ISimulation self, SimulationOptions const & options)
        void ISimulation::setOptions(const SimulationOptions &options)

        """
        return _libBornAgainCore.ISimulation_setOptions(self, options)

    def getOptions(self, *args):
        r"""
        getOptions(ISimulation self) -> SimulationOptions const
        getOptions(ISimulation self) -> SimulationOptions &
        SimulationOptions& ISimulation::getOptions()

        """
        return _libBornAgainCore.ISimulation_getOptions(self, *args)

    def subscribe(self, inform):
        r"""
        subscribe(ISimulation self, ProgressHandler::Callback_t inform)
        void ISimulation::subscribe(ProgressHandler::Callback_t inform)

        """
        return _libBornAgainCore.ISimulation_subscribe(self, inform)

    def setTerminalProgressMonitor(self):
        r"""
        setTerminalProgressMonitor(ISimulation self)
        void ISimulation::setTerminalProgressMonitor()

        Initializes a progress monitor that prints to stdout. 

        """
        return _libBornAgainCore.ISimulation_setTerminalProgressMonitor(self)

    def getChildren(self):
        r"""
        getChildren(ISimulation self) -> swig_dummy_type_const_inode_vector
        std::vector< const INode * > ISimulation::getChildren() const

        """
        return _libBornAgainCore.ISimulation_getChildren(self)

    def convertData(self, data, put_masked_areas_to_zero=True):
        r"""
        convertData(ISimulation self, OutputData< double > const & data, bool put_masked_areas_to_zero=True) -> SimulationResult
        SimulationResult ISimulation::convertData(const OutputData< double > &data, bool put_masked_areas_to_zero=true)

        Convert user data to SimulationResult object for later drawing in various axes units. User data will be cropped to the ROI defined in the simulation, amplitudes in areas corresponding to the masked areas of the detector will be set to zero. 

        """
        return _libBornAgainCore.ISimulation_convertData(self, data, put_masked_areas_to_zero)

    def setSampleBuilder(self, ptr):
        self.samplebuilder = ptr
        self.setSampleBuilderCpp(ptr)


# Register ISimulation in _libBornAgainCore:
_libBornAgainCore.ISimulation_swigregister(ISimulation)

class ISimulation2D(ISimulation):
    r"""


    Abstract base class of  OffSpecularSimulation and  GISASSimulation. Holds the common implementations for simulations with a 2D detector

    C++ includes: ISimulation2D.h

    """

    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__ = _libBornAgainCore.delete_ISimulation2D

    def clone(self):
        r"""
        clone(ISimulation2D self) -> ISimulation2D
        ISimulation2D* ISimulation2D::clone() const override=0

        """
        return _libBornAgainCore.ISimulation2D_clone(self)

    def detector2D(self, *args):
        r"""
        detector2D(ISimulation2D self) -> IDetector2D
        detector2D(ISimulation2D self) -> IDetector2D const &
        const IDetector2D & ISimulation2D::detector2D() const

        """
        return _libBornAgainCore.ISimulation2D_detector2D(self, *args)

    def prepareSimulation(self):
        r"""
        prepareSimulation(ISimulation2D self)
        void ISimulation2D::prepareSimulation() override

        Put into a clean state for running a simulation. 

        """
        return _libBornAgainCore.ISimulation2D_prepareSimulation(self)

    def setDetectorParameters(self, n_phi, phi_min, phi_max, n_alpha, alpha_min, alpha_max):
        r"""
        setDetectorParameters(ISimulation2D self, size_t n_phi, double phi_min, double phi_max, size_t n_alpha, double alpha_min, double alpha_max)
        void ISimulation2D::setDetectorParameters(size_t n_phi, double phi_min, double phi_max, size_t n_alpha, double alpha_min, double alpha_max)

        Sets spherical detector parameters using angle ranges

        Parameters:
        -----------

        n_phi: 
        number of phi-axis bins

        phi_min: 
        low edge of first phi-bin

        phi_max: 
        upper edge of last phi-bin

        n_alpha: 
        number of alpha-axis bins

        alpha_min: 
        low edge of first alpha-bin

        alpha_max: 
        upper edge of last alpha-bin 

        """
        return _libBornAgainCore.ISimulation2D_setDetectorParameters(self, n_phi, phi_min, phi_max, n_alpha, alpha_min, alpha_max)

    def setDetector(self, detector):
        r"""
        setDetector(ISimulation2D self, IDetector2D const & detector)
        void ISimulation2D::setDetector(const IDetector2D &detector)

        Sets the detector (axes can be overwritten later) 

        """
        return _libBornAgainCore.ISimulation2D_setDetector(self, detector)

    def addMask(self, shape, mask_value=True):
        r"""
        addMask(ISimulation2D self, IShape2D const & shape, bool mask_value=True)
        void ISimulation2D::addMask(const IShape2D &shape, bool mask_value=true)

        Adds mask of given shape to the stack of detector masks. The mask value 'true' means that the channel will be excluded from the simulation. The mask which is added last has priority.

        Parameters:
        -----------

        shape: 
        The shape of mask (Rectangle, Polygon, Line, Ellipse)

        mask_value: 
        The value of mask 

        """
        return _libBornAgainCore.ISimulation2D_addMask(self, shape, mask_value)

    def maskAll(self):
        r"""
        maskAll(ISimulation2D self)
        void ISimulation2D::maskAll()

        Put the mask for all detector channels (i.e. exclude whole detector from the analysis) 

        """
        return _libBornAgainCore.ISimulation2D_maskAll(self)

    def setRegionOfInterest(self, xlow, ylow, xup, yup):
        r"""
        setRegionOfInterest(ISimulation2D self, double xlow, double ylow, double xup, double yup)
        void ISimulation2D::setRegionOfInterest(double xlow, double ylow, double xup, double yup)

        Sets rectangular region of interest with lower left and upper right corners defined. 

        """
        return _libBornAgainCore.ISimulation2D_setRegionOfInterest(self, xlow, ylow, xup, yup)

# Register ISimulation2D in _libBornAgainCore:
_libBornAgainCore.ISimulation2D_swigregister(ISimulation2D)

class GISASSimulation(ISimulation2D):
    r"""


    Main class to run a Grazing-Incidence Small-Angle Scattering simulation.

    C++ includes: GISASSimulation.h

    """

    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__(GISASSimulation self, Beam const & beam, MultiLayer const & sample, IDetector const & detector) -> GISASSimulation
        __init__(GISASSimulation self) -> GISASSimulation
        GISASSimulation::GISASSimulation()

        """
        _libBornAgainCore.GISASSimulation_swiginit(self, _libBornAgainCore.new_GISASSimulation(*args))
    __swig_destroy__ = _libBornAgainCore.delete_GISASSimulation

    def clone(self):
        r"""
        clone(GISASSimulation self) -> GISASSimulation
        GISASSimulation* GISASSimulation::clone() const override

        """
        return _libBornAgainCore.GISASSimulation_clone(self)

    def accept(self, visitor):
        r"""
        accept(GISASSimulation self, INodeVisitor * visitor)
        void GISASSimulation::accept(INodeVisitor *visitor) const override

        """
        return _libBornAgainCore.GISASSimulation_accept(self, visitor)

    def prepareSimulation(self):
        r"""
        prepareSimulation(GISASSimulation self)
        void GISASSimulation::prepareSimulation() override

        Put into a clean state for running a simulation. 

        """
        return _libBornAgainCore.GISASSimulation_prepareSimulation(self)

    def result(self):
        r"""
        result(GISASSimulation self) -> SimulationResult
        SimulationResult GISASSimulation::result() const override

        Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays 

        """
        return _libBornAgainCore.GISASSimulation_result(self)

    def setBeamParameters(self, wavelength, alpha_i, phi_i):
        r"""
        setBeamParameters(GISASSimulation self, double wavelength, double alpha_i, double phi_i)
        void GISASSimulation::setBeamParameters(double wavelength, double alpha_i, double phi_i)

        Sets beam parameters from here (forwarded to Instrument) 

        """
        return _libBornAgainCore.GISASSimulation_setBeamParameters(self, wavelength, alpha_i, phi_i)

    def intensityMapSize(self):
        r"""
        intensityMapSize(GISASSimulation self) -> size_t
        size_t GISASSimulation::intensityMapSize() const override

        Returns the total number of the intensity values in the simulation result. 

        """
        return _libBornAgainCore.GISASSimulation_intensityMapSize(self)

# Register GISASSimulation in _libBornAgainCore:
_libBornAgainCore.GISASSimulation_swigregister(GISASSimulation)

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):
        r"""
        __init__(DepthProbeSimulation self) -> DepthProbeSimulation
        DepthProbeSimulation::DepthProbeSimulation()

        """
        _libBornAgainCore.DepthProbeSimulation_swiginit(self, _libBornAgainCore.new_DepthProbeSimulation())
    __swig_destroy__ = _libBornAgainCore.delete_DepthProbeSimulation

    def clone(self):
        r"""
        clone(DepthProbeSimulation self) -> DepthProbeSimulation
        DepthProbeSimulation * DepthProbeSimulation::clone() const override

        """
        return _libBornAgainCore.DepthProbeSimulation_clone(self)

    def accept(self, visitor):
        r"""
        accept(DepthProbeSimulation self, INodeVisitor * visitor)
        void DepthProbeSimulation::accept(INodeVisitor *visitor) const final

        """
        return _libBornAgainCore.DepthProbeSimulation_accept(self, visitor)

    def result(self):
        r"""
        result(DepthProbeSimulation self) -> SimulationResult
        SimulationResult DepthProbeSimulation::result() const override

        Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays 

        """
        return _libBornAgainCore.DepthProbeSimulation_result(self)

    def setBeamParameters(self, _lambda, nbins, alpha_i_min, alpha_i_max, beam_shape=None):
        r"""
        setBeamParameters(DepthProbeSimulation self, double _lambda, int nbins, double alpha_i_min, double alpha_i_max, IFootprintFactor const * beam_shape=None)
        void DepthProbeSimulation::setBeamParameters(double lambda, int nbins, double alpha_i_min, double alpha_i_max, const IFootprintFactor *beam_shape=nullptr)

        Sets beam parameters with alpha_i of the beam defined in the range. 

        """
        return _libBornAgainCore.DepthProbeSimulation_setBeamParameters(self, _lambda, nbins, alpha_i_min, alpha_i_max, beam_shape)

    def setZSpan(self, n_bins, z_min, z_max):
        r"""
        setZSpan(DepthProbeSimulation self, size_t n_bins, double z_min, double z_max)
        void DepthProbeSimulation::setZSpan(size_t n_bins, double z_min, double z_max)

        Set z positions for intensity calculations. Negative z's correspond to the area under sample surface. The more negative z is, the deeper layer corresponds to it. 

        """
        return _libBornAgainCore.DepthProbeSimulation_setZSpan(self, n_bins, z_min, z_max)

    def getAlphaAxis(self):
        r"""
        getAlphaAxis(DepthProbeSimulation self) -> IAxis
        const IAxis * DepthProbeSimulation::getAlphaAxis() const

        Returns a pointer to incident angle axis. 

        """
        return _libBornAgainCore.DepthProbeSimulation_getAlphaAxis(self)

    def getZAxis(self):
        r"""
        getZAxis(DepthProbeSimulation self) -> IAxis
        const IAxis * DepthProbeSimulation::getZAxis() const

        Returns a pointer to z-position axis. 

        """
        return _libBornAgainCore.DepthProbeSimulation_getZAxis(self)

    def intensityMapSize(self):
        r"""
        intensityMapSize(DepthProbeSimulation self) -> size_t
        size_t DepthProbeSimulation::intensityMapSize() const override

        Returns the total number of the intensity values in the simulation result. 

        """
        return _libBornAgainCore.DepthProbeSimulation_intensityMapSize(self)

# Register DepthProbeSimulation in _libBornAgainCore:
_libBornAgainCore.DepthProbeSimulation_swigregister(DepthProbeSimulation)

class SpecularSimulation(ISimulation):
    r"""


    Main class to run a specular simulation.

    C++ includes: SpecularSimulation.h

    """

    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__(SpecularSimulation self) -> SpecularSimulation
        SpecularSimulation::SpecularSimulation()

        """
        _libBornAgainCore.SpecularSimulation_swiginit(self, _libBornAgainCore.new_SpecularSimulation())
    __swig_destroy__ = _libBornAgainCore.delete_SpecularSimulation

    def clone(self):
        r"""
        clone(SpecularSimulation self) -> SpecularSimulation
        SpecularSimulation * SpecularSimulation::clone() const override

        """
        return _libBornAgainCore.SpecularSimulation_clone(self)

    def prepareSimulation(self):
        r"""
        prepareSimulation(SpecularSimulation self)
        void SpecularSimulation::prepareSimulation() override

        Put into a clean state for running a simulation. 

        """
        return _libBornAgainCore.SpecularSimulation_prepareSimulation(self)

    def accept(self, visitor):
        r"""
        accept(SpecularSimulation self, INodeVisitor * visitor)
        void SpecularSimulation::accept(INodeVisitor *visitor) const final

        """
        return _libBornAgainCore.SpecularSimulation_accept(self, visitor)

    def result(self):
        r"""
        result(SpecularSimulation self) -> SimulationResult
        SimulationResult SpecularSimulation::result() const override

        Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays. If simulation was not run, returns an array of proper size filled with zeros. 

        """
        return _libBornAgainCore.SpecularSimulation_result(self)

    def setScan(self, scan):
        r"""
        setScan(SpecularSimulation self, ISpecularScan const & scan)
        void SpecularSimulation::setScan(const ISpecularScan &scan)

        Sets chosen specular scan to the simulation. 

        """
        return _libBornAgainCore.SpecularSimulation_setScan(self, scan)

    def coordinateAxis(self):
        r"""
        coordinateAxis(SpecularSimulation self) -> IAxis
        const IAxis * SpecularSimulation::coordinateAxis() const

        Returns a pointer to coordinate axis. 

        """
        return _libBornAgainCore.SpecularSimulation_coordinateAxis(self)

    def footprintFactor(self):
        r"""
        footprintFactor(SpecularSimulation self) -> IFootprintFactor const *
        const IFootprintFactor * SpecularSimulation::footprintFactor() const

        Returns a pointer to footprint factor holder. 

        """
        return _libBornAgainCore.SpecularSimulation_footprintFactor(self)

    def intensityMapSize(self):
        r"""
        intensityMapSize(SpecularSimulation self) -> size_t
        size_t SpecularSimulation::intensityMapSize() const override

        Returns the total number of the intensity values in the simulation result. 

        """
        return _libBornAgainCore.SpecularSimulation_intensityMapSize(self)

    def setSampleBuilder(self, ptr):
        self.samplebuilder = ptr
        self.setSampleBuilderCpp(ptr)


# Register SpecularSimulation in _libBornAgainCore:
_libBornAgainCore.SpecularSimulation_swigregister(SpecularSimulation)

class OffSpecularSimulation(ISimulation2D):
    r"""


    Main class to run an off-specular simulation.

    C++ includes: OffSpecularSimulation.h

    """

    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__(OffSpecularSimulation self, Beam const & beam, MultiLayer const & sample, IDetector const & detector) -> OffSpecularSimulation
        __init__(OffSpecularSimulation self) -> OffSpecularSimulation
        OffSpecularSimulation::OffSpecularSimulation()

        """
        _libBornAgainCore.OffSpecularSimulation_swiginit(self, _libBornAgainCore.new_OffSpecularSimulation(*args))
    __swig_destroy__ = _libBornAgainCore.delete_OffSpecularSimulation

    def clone(self):
        r"""
        clone(OffSpecularSimulation self) -> OffSpecularSimulation
        OffSpecularSimulation* OffSpecularSimulation::clone() const override

        """
        return _libBornAgainCore.OffSpecularSimulation_clone(self)

    def accept(self, visitor):
        r"""
        accept(OffSpecularSimulation self, INodeVisitor * visitor)
        void OffSpecularSimulation::accept(INodeVisitor *visitor) const override

        """
        return _libBornAgainCore.OffSpecularSimulation_accept(self, visitor)

    def prepareSimulation(self):
        r"""
        prepareSimulation(OffSpecularSimulation self)
        void OffSpecularSimulation::prepareSimulation() override

        Put into a clean state for running a simulation. 

        """
        return _libBornAgainCore.OffSpecularSimulation_prepareSimulation(self)

    def result(self):
        r"""
        result(OffSpecularSimulation self) -> SimulationResult
        SimulationResult OffSpecularSimulation::result() const override

        Returns the results of the simulation in a format that supports unit conversion and export to numpy arrays 

        """
        return _libBornAgainCore.OffSpecularSimulation_result(self)

    def setBeamParameters(self, wavelength, alpha_axis, phi_i):
        r"""
        setBeamParameters(OffSpecularSimulation self, double wavelength, IAxis alpha_axis, double phi_i)
        void OffSpecularSimulation::setBeamParameters(double wavelength, const IAxis &alpha_axis, double phi_i)

        Sets beam parameters from here (forwarded to Instrument) 

        """
        return _libBornAgainCore.OffSpecularSimulation_setBeamParameters(self, wavelength, alpha_axis, phi_i)

    def beamAxis(self):
        r"""
        beamAxis(OffSpecularSimulation self) -> IAxis
        const IAxis * OffSpecularSimulation::beamAxis() const

        Returns axis of the beam. 

        """
        return _libBornAgainCore.OffSpecularSimulation_beamAxis(self)

    def intensityMapSize(self):
        r"""
        intensityMapSize(OffSpecularSimulation self) -> size_t
        size_t OffSpecularSimulation::intensityMapSize() const override

        Returns the total number of the intensity values in the simulation result. 

        """
        return _libBornAgainCore.OffSpecularSimulation_intensityMapSize(self)

# Register OffSpecularSimulation in _libBornAgainCore:
_libBornAgainCore.OffSpecularSimulation_swigregister(OffSpecularSimulation)

class IBackground(libBornAgainBase.ICloneable, libBornAgainParam.INode):
    r"""


    Interface for a simulating the background signal

    C++ includes: IBackground.h

    """

    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__ = _libBornAgainCore.delete_IBackground

    def clone(self):
        r"""
        clone(IBackground self) -> IBackground
        virtual IBackground* IBackground::clone() const =0

        """
        return _libBornAgainCore.IBackground_clone(self)

    def addBackground(self, element):
        r"""
        addBackground(IBackground self, double element) -> double
        virtual double IBackground::addBackground(double element) const =0

        """
        return _libBornAgainCore.IBackground_addBackground(self, element)

# Register IBackground in _libBornAgainCore:
_libBornAgainCore.IBackground_swigregister(IBackground)

class ConstantBackground(IBackground):
    r"""


    Class representing a constant background signal

    C++ includes: ConstantBackground.h

    """

    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
        ConstantBackground::ConstantBackground(double background_value)

        """
        _libBornAgainCore.ConstantBackground_swiginit(self, _libBornAgainCore.new_ConstantBackground(*args))

    def clone(self):
        r"""
        clone(ConstantBackground self) -> ConstantBackground
        ConstantBackground * ConstantBackground::clone() const final

        """
        return _libBornAgainCore.ConstantBackground_clone(self)

    def backgroundValue(self):
        r"""
        backgroundValue(ConstantBackground self) -> double
        double ConstantBackground::backgroundValue() const

        """
        return _libBornAgainCore.ConstantBackground_backgroundValue(self)

    def accept(self, visitor):
        r"""
        accept(ConstantBackground self, INodeVisitor * visitor)
        void ConstantBackground::accept(INodeVisitor *visitor) const override

        """
        return _libBornAgainCore.ConstantBackground_accept(self, visitor)

    def addBackground(self, intensity):
        r"""
        addBackground(ConstantBackground self, double intensity) -> double
        double ConstantBackground::addBackground(double intensity) const final

        """
        return _libBornAgainCore.ConstantBackground_addBackground(self, intensity)
    __swig_destroy__ = _libBornAgainCore.delete_ConstantBackground

# Register ConstantBackground in _libBornAgainCore:
_libBornAgainCore.ConstantBackground_swigregister(ConstantBackground)

class PoissonNoiseBackground(IBackground):
    r"""


    Class representing Poisson noise on top of the scattered intensity

    C++ includes: PoissonNoiseBackground.h

    """

    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__(PoissonNoiseBackground self) -> PoissonNoiseBackground
        PoissonNoiseBackground::PoissonNoiseBackground()

        """
        _libBornAgainCore.PoissonNoiseBackground_swiginit(self, _libBornAgainCore.new_PoissonNoiseBackground())

    def clone(self):
        r"""
        clone(PoissonNoiseBackground self) -> PoissonNoiseBackground
        PoissonNoiseBackground * PoissonNoiseBackground::clone() const final

        """
        return _libBornAgainCore.PoissonNoiseBackground_clone(self)

    def accept(self, visitor):
        r"""
        accept(PoissonNoiseBackground self, INodeVisitor * visitor)
        void PoissonNoiseBackground::accept(INodeVisitor *visitor) const override

        """
        return _libBornAgainCore.PoissonNoiseBackground_accept(self, visitor)

    def addBackground(self, intensity):
        r"""
        addBackground(PoissonNoiseBackground self, double intensity) -> double
        double PoissonNoiseBackground::addBackground(double intensity) const final

        """
        return _libBornAgainCore.PoissonNoiseBackground_addBackground(self, intensity)
    __swig_destroy__ = _libBornAgainCore.delete_PoissonNoiseBackground

# Register PoissonNoiseBackground in _libBornAgainCore:
_libBornAgainCore.PoissonNoiseBackground_swigregister(PoissonNoiseBackground)


def sampleCode(multilayer):
    r"""
    sampleCode(MultiLayer const & multilayer) -> std::string
    std::string ExportToPython::sampleCode(const MultiLayer &multilayer)

    """
    return _libBornAgainCore.sampleCode(multilayer)

def simulationPlotCode(simulation):
    r"""
    simulationPlotCode(ISimulation simulation) -> std::string
    std::string ExportToPython::simulationPlotCode(const ISimulation &simulation)

    """
    return _libBornAgainCore.simulationPlotCode(simulation)

def simulationSaveCode(simulation, fname):
    r"""
    simulationSaveCode(ISimulation simulation, std::string const & fname) -> std::string
    std::string ExportToPython::simulationSaveCode(const ISimulation &simulation, const std::string &fname)

    """
    return _libBornAgainCore.simulationSaveCode(simulation, fname)
class IIntensityFunction(object):
    r"""


    Interface for applying arbitrary function to the measured intensity.

    C++ includes: IIntensityFunction.h

    """

    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__ = _libBornAgainCore.delete_IIntensityFunction

    def clone(self):
        r"""
        clone(IIntensityFunction self) -> IIntensityFunction
        virtual IIntensityFunction* IIntensityFunction::clone() const =0

        """
        return _libBornAgainCore.IIntensityFunction_clone(self)

    def evaluate(self, value):
        r"""
        evaluate(IIntensityFunction self, double value) -> double
        virtual double IIntensityFunction::evaluate(double value) const =0

        """
        return _libBornAgainCore.IIntensityFunction_evaluate(self, value)

# Register IIntensityFunction in _libBornAgainCore:
_libBornAgainCore.IIntensityFunction_swigregister(IIntensityFunction)

class IntensityFunctionLog(IIntensityFunction):
    r"""


    Algorithm for applying log function to the measured intensity.

    C++ includes: IIntensityFunction.h

    """

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

    def clone(self):
        r"""
        clone(IntensityFunctionLog self) -> IntensityFunctionLog
        IntensityFunctionLog * IntensityFunctionLog::clone() const

        """
        return _libBornAgainCore.IntensityFunctionLog_clone(self)

    def evaluate(self, value):
        r"""
        evaluate(IntensityFunctionLog self, double value) -> double
        double IntensityFunctionLog::evaluate(double value) const

        """
        return _libBornAgainCore.IntensityFunctionLog_evaluate(self, value)

    def __init__(self):
        r"""
        __init__(IntensityFunctionLog self) -> IntensityFunctionLog


        Algorithm for applying log function to the measured intensity.

        C++ includes: IIntensityFunction.h

        """
        _libBornAgainCore.IntensityFunctionLog_swiginit(self, _libBornAgainCore.new_IntensityFunctionLog())
    __swig_destroy__ = _libBornAgainCore.delete_IntensityFunctionLog

# Register IntensityFunctionLog in _libBornAgainCore:
_libBornAgainCore.IntensityFunctionLog_swigregister(IntensityFunctionLog)

class IntensityFunctionSqrt(IIntensityFunction):
    r"""


    Algorithm for applying sqrt function to the measured intensity.

    C++ includes: IIntensityFunction.h

    """

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

    def clone(self):
        r"""
        clone(IntensityFunctionSqrt self) -> IntensityFunctionSqrt
        IntensityFunctionSqrt * IntensityFunctionSqrt::clone() const

        """
        return _libBornAgainCore.IntensityFunctionSqrt_clone(self)

    def evaluate(self, value):
        r"""
        evaluate(IntensityFunctionSqrt self, double value) -> double
        double IntensityFunctionSqrt::evaluate(double value) const

        """
        return _libBornAgainCore.IntensityFunctionSqrt_evaluate(self, value)

    def __init__(self):
        r"""
        __init__(IntensityFunctionSqrt self) -> IntensityFunctionSqrt


        Algorithm for applying sqrt function to the measured intensity.

        C++ includes: IIntensityFunction.h

        """
        _libBornAgainCore.IntensityFunctionSqrt_swiginit(self, _libBornAgainCore.new_IntensityFunctionSqrt())
    __swig_destroy__ = _libBornAgainCore.delete_IntensityFunctionSqrt

# Register IntensityFunctionSqrt in _libBornAgainCore:
_libBornAgainCore.IntensityFunctionSqrt_swigregister(IntensityFunctionSqrt)

class IChiSquaredModule(libBornAgainBase.ICloneable):
    r"""


    Interface residual calculations.

    C++ includes: IChiSquaredModule.h

    """

    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__ = _libBornAgainCore.delete_IChiSquaredModule

    def clone(self):
        r"""
        clone(IChiSquaredModule self) -> IChiSquaredModule
        virtual IChiSquaredModule* IChiSquaredModule::clone() const =0

        clone method 

        """
        return _libBornAgainCore.IChiSquaredModule_clone(self)

    def varianceFunction(self):
        r"""
        varianceFunction(IChiSquaredModule self) -> IVarianceFunction
        const IVarianceFunction * IChiSquaredModule::varianceFunction() const

        Returns squared function. 

        """
        return _libBornAgainCore.IChiSquaredModule_varianceFunction(self)

    def setVarianceFunction(self, variance_function):
        r"""
        setVarianceFunction(IChiSquaredModule self, IVarianceFunction variance_function)
        void IChiSquaredModule::setVarianceFunction(const IVarianceFunction &variance_function)

        Sets squared function. 

        """
        return _libBornAgainCore.IChiSquaredModule_setVarianceFunction(self, variance_function)

    def getIntensityFunction(self):
        r"""
        getIntensityFunction(IChiSquaredModule self) -> IIntensityFunction
        const IIntensityFunction * IChiSquaredModule::getIntensityFunction() const

        Returns data rescaler. 

        """
        return _libBornAgainCore.IChiSquaredModule_getIntensityFunction(self)

    def setIntensityFunction(self, intensity_function):
        r"""
        setIntensityFunction(IChiSquaredModule self, IIntensityFunction intensity_function)
        void IChiSquaredModule::setIntensityFunction(const IIntensityFunction &intensity_function)

        Sets data rescaler. 

        """
        return _libBornAgainCore.IChiSquaredModule_setIntensityFunction(self, intensity_function)

    def residual(self, a, b, weight):
        r"""
        residual(IChiSquaredModule self, double a, double b, double weight) -> double
        virtual double IChiSquaredModule::residual(double a, double b, double weight)=0

        """
        return _libBornAgainCore.IChiSquaredModule_residual(self, a, b, weight)

# Register IChiSquaredModule in _libBornAgainCore:
_libBornAgainCore.IChiSquaredModule_swigregister(IChiSquaredModule)

class ChiSquaredModule(IChiSquaredModule):
    r"""


    Calculation of chi2 between two data sets.

    C++ includes: ChiSquaredModule.h

    """

    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
        ChiSquaredModule::ChiSquaredModule(const ChiSquaredModule &other)

        """
        _libBornAgainCore.ChiSquaredModule_swiginit(self, _libBornAgainCore.new_ChiSquaredModule(*args))
    __swig_destroy__ = _libBornAgainCore.delete_ChiSquaredModule

    def clone(self):
        r"""
        clone(ChiSquaredModule self) -> ChiSquaredModule
        virtual ChiSquaredModule* ChiSquaredModule::clone() const

        clone method 

        """
        return _libBornAgainCore.ChiSquaredModule_clone(self)

    def residual(self, a, b, weight):
        r"""
        residual(ChiSquaredModule self, double a, double b, double weight) -> double
        double ChiSquaredModule::residual(double a, double b, double weight)

        """
        return _libBornAgainCore.ChiSquaredModule_residual(self, a, b, weight)

# Register ChiSquaredModule in _libBornAgainCore:
_libBornAgainCore.ChiSquaredModule_swigregister(ChiSquaredModule)

class IVarianceFunction(object):
    r"""


    Variance function interface.

    C++ includes: VarianceFunctions.h

    """

    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__ = _libBornAgainCore.delete_IVarianceFunction

    def clone(self):
        r"""
        clone(IVarianceFunction self) -> IVarianceFunction
        virtual IVarianceFunction* IVarianceFunction::clone() const =0

        """
        return _libBornAgainCore.IVarianceFunction_clone(self)

    def variance(self, real_value, simulated_value):
        r"""
        variance(IVarianceFunction self, double real_value, double simulated_value) -> double
        virtual double IVarianceFunction::variance(double real_value, double simulated_value) const =0

        """
        return _libBornAgainCore.IVarianceFunction_variance(self, real_value, simulated_value)

# Register IVarianceFunction in _libBornAgainCore:
_libBornAgainCore.IVarianceFunction_swigregister(IVarianceFunction)

class VarianceConstantFunction(IVarianceFunction):
    r"""


    Returns 1.0 as variance value

    C++ includes: VarianceFunctions.h

    """

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

    def clone(self):
        r"""
        clone(VarianceConstantFunction self) -> VarianceConstantFunction
        VarianceConstantFunction * VarianceConstantFunction::clone() const override

        """
        return _libBornAgainCore.VarianceConstantFunction_clone(self)

    def variance(self, arg2, arg3):
        r"""
        variance(VarianceConstantFunction self, double arg2, double arg3) -> double
        double VarianceConstantFunction::variance(double, double) const override

        """
        return _libBornAgainCore.VarianceConstantFunction_variance(self, arg2, arg3)

    def __init__(self):
        r"""
        __init__(VarianceConstantFunction self) -> VarianceConstantFunction


        Returns 1.0 as variance value

        C++ includes: VarianceFunctions.h

        """
        _libBornAgainCore.VarianceConstantFunction_swiginit(self, _libBornAgainCore.new_VarianceConstantFunction())
    __swig_destroy__ = _libBornAgainCore.delete_VarianceConstantFunction

# Register VarianceConstantFunction in _libBornAgainCore:
_libBornAgainCore.VarianceConstantFunction_swigregister(VarianceConstantFunction)

class VarianceSimFunction(IVarianceFunction):
    r"""


    Returns max(sim, epsilon)

    C++ includes: VarianceFunctions.h

    """

    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
        VarianceSimFunction::VarianceSimFunction(double epsilon=1.0)

        """
        _libBornAgainCore.VarianceSimFunction_swiginit(self, _libBornAgainCore.new_VarianceSimFunction(epsilon))

    def clone(self):
        r"""
        clone(VarianceSimFunction self) -> VarianceSimFunction
        VarianceSimFunction * VarianceSimFunction::clone() const override

        """
        return _libBornAgainCore.VarianceSimFunction_clone(self)

    def variance(self, exp, sim):
        r"""
        variance(VarianceSimFunction self, double exp, double sim) -> double
        double VarianceSimFunction::variance(double exp, double sim) const override

        """
        return _libBornAgainCore.VarianceSimFunction_variance(self, exp, sim)
    __swig_destroy__ = _libBornAgainCore.delete_VarianceSimFunction

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


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

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

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




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

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



