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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SHARED_PTR_DISOWN = _libBornAgainParam.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 _libBornAgainParam.vdouble1d_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __bool__(self):
        r"""__bool__(vector_pvacuum_double_t self) -> bool"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.vector_pvacuum_double_t___setitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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
        """
        _libBornAgainParam.kvector_t_swiginit(self, _libBornAgainParam.new_kvector_t(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def project(self, v):
        r"""project(kvector_t self, kvector_t v) -> kvector_t"""
        return _libBornAgainParam.kvector_t_project(self, v)
    __swig_destroy__ = _libBornAgainParam.delete_kvector_t

# Register kvector_t in _libBornAgainParam:
_libBornAgainParam.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 _libBornAgainParam.vector_kvector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vector_kvector_t self) -> std::vector< BasicVector3D< double > >::size_type"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.vector_kvector_t___setitem__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        r"""pop_back(vector_kvector_t self)"""
        return _libBornAgainParam.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 _libBornAgainParam.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
        """
        _libBornAgainParam.vector_kvector_t_swiginit(self, _libBornAgainParam.new_vector_kvector_t(*args))

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

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

    def back(self):
        r"""back(vector_kvector_t self) -> kvector_t"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.vector_kvector_t_insert(self, *args)

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

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

# Register vector_kvector_t in _libBornAgainParam:
_libBornAgainParam.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
        """
        _libBornAgainParam.cvector_t_swiginit(self, _libBornAgainParam.new_cvector_t(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register cvector_t in _libBornAgainParam:
_libBornAgainParam.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 _libBornAgainParam.vector_cvector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

    def __len__(self):
        r"""__len__(vector_cvector_t self) -> std::vector< BasicVector3D< std::complex< double > > >::size_type"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.vector_cvector_t___setitem__(self, *args)

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

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

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

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

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

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

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

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

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

    def clear(self):
        r"""clear(vector_cvector_t self)"""
        return _libBornAgainParam.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 _libBornAgainParam.vector_cvector_t_get_allocator(self)

    def pop_back(self):
        r"""pop_back(vector_cvector_t self)"""
        return _libBornAgainParam.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 _libBornAgainParam.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
        """
        _libBornAgainParam.vector_cvector_t_swiginit(self, _libBornAgainParam.new_vector_cvector_t(*args))

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

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

    def back(self):
        r"""back(vector_cvector_t self) -> cvector_t"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.vector_cvector_t_reserve(self, n)

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

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

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 _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_inode_vector___nonzero__(self)

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

    def __len__(self):
        r"""__len__(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_inode_vector___setitem__(self, *args)

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

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

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

    def size(self):
        r"""size(swig_dummy_type_inode_vector self) -> std::vector< INode * >::size_type"""
        return _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_inode_vector_swap(self, v)

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

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

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

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

    def clear(self):
        r"""clear(swig_dummy_type_inode_vector self)"""
        return _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_inode_vector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(swig_dummy_type_inode_vector self)"""
        return _libBornAgainParam.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 _libBornAgainParam.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
        """
        _libBornAgainParam.swig_dummy_type_inode_vector_swiginit(self, _libBornAgainParam.new_swig_dummy_type_inode_vector(*args))

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

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

    def back(self):
        r"""back(swig_dummy_type_inode_vector self) -> INode"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_inode_vector_capacity(self)
    __swig_destroy__ = _libBornAgainParam.delete_swig_dummy_type_inode_vector

# Register swig_dummy_type_inode_vector in _libBornAgainParam:
_libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_const_inode_vector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(swig_dummy_type_const_inode_vector self) -> bool"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_const_inode_vector___setitem__(self, *args)

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

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

    def empty(self):
        r"""empty(swig_dummy_type_const_inode_vector self) -> bool"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_const_inode_vector_rend(self)

    def clear(self):
        r"""clear(swig_dummy_type_const_inode_vector self)"""
        return _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_const_inode_vector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(swig_dummy_type_const_inode_vector self)"""
        return _libBornAgainParam.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 _libBornAgainParam.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
        """
        _libBornAgainParam.swig_dummy_type_const_inode_vector_swiginit(self, _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_const_inode_vector_push_back(self, x)

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

    def back(self):
        r"""back(swig_dummy_type_const_inode_vector self) -> INode"""
        return _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.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 _libBornAgainParam.swig_dummy_type_const_inode_vector_capacity(self)
    __swig_destroy__ = _libBornAgainParam.delete_swig_dummy_type_const_inode_vector

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

class IParameterReal(object):
    r"""


    Abstract base class for parameter wrapper classes  RealParameter, ComponentParameter. Holds a pointer to the wrapped parameter, a name, and a callback function to be called when the parameter is changed. This class is templated on the data type of the wrapped parameter.

    C++ includes: IParameter.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__ = _libBornAgainParam.delete_IParameterReal

    def clone(self, *args):
        r"""
        clone(IParameterReal self, std::string const & new_name="") -> IParameterReal
        virtual IParameter* IParameter< T >::clone(const std::string &new_name="") const =0

        """
        return _libBornAgainParam.IParameterReal_clone(self, *args)

    def isNull(self):
        r"""
        isNull(IParameterReal self) -> bool
        virtual bool IParameter< T >::isNull() const

        Returns true if wrapped parameter was not initialized with proper real value. 

        """
        return _libBornAgainParam.IParameterReal_isNull(self)

    def getData(self):
        r"""
        getData(IParameterReal self) -> double &
        T& IParameter< T >::getData() const

        """
        return _libBornAgainParam.IParameterReal_getData(self)

    def setData(self, data):
        r"""
        setData(IParameterReal self, double & data)
        void IParameter< T >::setData(T &data)

        """
        return _libBornAgainParam.IParameterReal_setData(self, data)

    def hasSameData(self, other):
        r"""
        hasSameData(IParameterReal self, IParameterReal other) -> bool
        bool IParameter< T >::hasSameData(const IParameter &other)

        Returns true if two parameters are pointing to the same raw data. 

        """
        return _libBornAgainParam.IParameterReal_hasSameData(self, other)

    def getName(self):
        r"""
        getName(IParameterReal self) -> std::string const &
        const std::string& IParameter< T >::getName() const

        """
        return _libBornAgainParam.IParameterReal_getName(self)

# Register IParameterReal in _libBornAgainParam:
_libBornAgainParam.IParameterReal_swigregister(IParameterReal)

class RealParameter(IParameterReal):
    r"""


    Wraps a parameter of type double. In addition to name and on-change callback held by the parent class  IParameter, this class holds Limits, Attributes (currently only fixed or not), and a  Unit.

    C++ includes: RealParameter.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__(RealParameter self, std::string const & name, double * par, std::string const & parent_name="", std::function< void () > const & onChange=std::function< void () >(), RealLimits const & limits=RealLimits::limitless(), Attributes const & attr=Attributes::free()) -> RealParameter
        RealParameter::RealParameter(const std::string &name, double *par, const std::string &parent_name="", const std::function< void()> &onChange=std::function< void()>(), const RealLimits &limits=RealLimits::limitless(), const Attributes &attr=Attributes::free())

        """
        _libBornAgainParam.RealParameter_swiginit(self, _libBornAgainParam.new_RealParameter(*args))
    __swig_destroy__ = _libBornAgainParam.delete_RealParameter

    def clone(self, *args):
        r"""
        clone(RealParameter self, std::string const & new_name="") -> RealParameter
        RealParameter * RealParameter::clone(const std::string &new_name="") const

        """
        return _libBornAgainParam.RealParameter_clone(self, *args)

    def setValue(self, value):
        r"""
        setValue(RealParameter self, double value)
        void RealParameter::setValue(double value)

        Sets value of wrapped parameter and emit signal. 

        """
        return _libBornAgainParam.RealParameter_setValue(self, value)

    def value(self):
        r"""
        value(RealParameter self) -> double
        double RealParameter::value() const

        Returns value of wrapped parameter. 

        """
        return _libBornAgainParam.RealParameter_value(self)

    def setLimits(self, limits):
        r"""
        setLimits(RealParameter self, RealLimits const & limits) -> RealParameter
        RealParameter & RealParameter::setLimits(const RealLimits &limits)

        """
        return _libBornAgainParam.RealParameter_setLimits(self, limits)

    def limits(self):
        r"""
        limits(RealParameter self) -> RealLimits
        RealLimits RealParameter::limits() const

        """
        return _libBornAgainParam.RealParameter_limits(self)

    def setLimited(self, lower, upper):
        r"""
        setLimited(RealParameter self, double lower, double upper) -> RealParameter
        RealParameter & RealParameter::setLimited(double lower, double upper)

        """
        return _libBornAgainParam.RealParameter_setLimited(self, lower, upper)

    def setPositive(self):
        r"""
        setPositive(RealParameter self) -> RealParameter
        RealParameter & RealParameter::setPositive()

        """
        return _libBornAgainParam.RealParameter_setPositive(self)

    def setNonnegative(self):
        r"""
        setNonnegative(RealParameter self) -> RealParameter
        RealParameter & RealParameter::setNonnegative()

        """
        return _libBornAgainParam.RealParameter_setNonnegative(self)

    def setUnit(self, name):
        r"""
        setUnit(RealParameter self, std::string const & name) -> RealParameter
        RealParameter & RealParameter::setUnit(const std::string &name)

        """
        return _libBornAgainParam.RealParameter_setUnit(self, name)

    def unit(self):
        r"""
        unit(RealParameter self) -> std::string
        std::string RealParameter::unit() const

        """
        return _libBornAgainParam.RealParameter_unit(self)

# Register RealParameter in _libBornAgainParam:
_libBornAgainParam.RealParameter_swigregister(RealParameter)

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


    Container with parameters for  IParametricComponent object.

    C++ includes: ParameterPool.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__(ParameterPool self) -> ParameterPool
        ParameterPool::ParameterPool()

        Constructs an empty parameter pool. 

        """
        _libBornAgainParam.ParameterPool_swiginit(self, _libBornAgainParam.new_ParameterPool())
    __swig_destroy__ = _libBornAgainParam.delete_ParameterPool

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

        Returns a literal clone. 

        """
        return _libBornAgainParam.ParameterPool_clone(self)

    def copyToExternalPool(self, prefix, other_pool):
        r"""
        copyToExternalPool(ParameterPool self, std::string const & prefix, ParameterPool other_pool)
        void ParameterPool::copyToExternalPool(const std::string &prefix, ParameterPool *other_pool) const

        Copies parameters of given pool to  other pool, prepeding  prefix to the parameter names. 

        """
        return _libBornAgainParam.ParameterPool_copyToExternalPool(self, prefix, other_pool)

    def clear(self):
        r"""
        clear(ParameterPool self)
        void ParameterPool::clear()

        Clears the parameter map. 

        """
        return _libBornAgainParam.ParameterPool_clear(self)

    def size(self):
        r"""
        size(ParameterPool self) -> size_t
        size_t ParameterPool::size() const

        Returns number of parameters in the pool. 

        """
        return _libBornAgainParam.ParameterPool_size(self)

    def empty(self):
        r"""
        empty(ParameterPool self) -> bool
        bool ParameterPool::empty() const

        """
        return _libBornAgainParam.ParameterPool_empty(self)

    def addParameter(self, newPar):
        r"""
        addParameter(ParameterPool self, RealParameter newPar) -> RealParameter
        RealParameter & ParameterPool::addParameter(RealParameter *newPar)

        Adds parameter to the pool, and returns reference to the input pointer.

        Returning the input pointer allows us to concatenate function calls like pool->addParameter( new RealParameter(...) ).setLimits(-1,+1).setFixed().setUnit("nm") 

        """
        return _libBornAgainParam.ParameterPool_addParameter(self, newPar)

    def parameter(self, *args):
        r"""
        parameter(ParameterPool self, std::string const & name) -> RealParameter
        parameter(ParameterPool self, std::string const & name) -> RealParameter
        const RealParameter * ParameterPool::parameter(const std::string &name) const

        Returns parameter with given  name. 

        """
        return _libBornAgainParam.ParameterPool_parameter(self, *args)

    def parameters(self):
        r"""
        parameters(ParameterPool self) -> std::vector< RealParameter *,std::allocator< RealParameter * > > const
        const std::vector<RealParameter*> ParameterPool::parameters() const

        Returns full vector of parameters. 

        """
        return _libBornAgainParam.ParameterPool_parameters(self)

    def getMatchedParameters(self, pattern):
        r"""
        getMatchedParameters(ParameterPool self, std::string const & pattern) -> std::vector< RealParameter *,std::allocator< RealParameter * > >
        std::vector< RealParameter * > ParameterPool::getMatchedParameters(const std::string &pattern) const

        Returns nonempty vector of parameters that match the  pattern ('*' allowed), or throws. 

        """
        return _libBornAgainParam.ParameterPool_getMatchedParameters(self, pattern)

    def getUniqueMatch(self, pattern):
        r"""
        getUniqueMatch(ParameterPool self, std::string const & pattern) -> RealParameter
        RealParameter * ParameterPool::getUniqueMatch(const std::string &pattern) const

        Returns the one parameter that matches the  pattern (wildcards '*' allowed), or throws. 

        """
        return _libBornAgainParam.ParameterPool_getUniqueMatch(self, pattern)

    def setParameterValue(self, name, value):
        r"""
        setParameterValue(ParameterPool self, std::string const & name, double value)
        void ParameterPool::setParameterValue(const std::string &name, double value)

        Sets parameter value. 

        """
        return _libBornAgainParam.ParameterPool_setParameterValue(self, name, value)

    def setMatchedParametersValue(self, wildcards, value):
        r"""
        setMatchedParametersValue(ParameterPool self, std::string const & wildcards, double value) -> int
        int ParameterPool::setMatchedParametersValue(const std::string &wildcards, double value)

        Sets value of the nonzero parameters that match  pattern ('*' allowed), or throws. 

        """
        return _libBornAgainParam.ParameterPool_setMatchedParametersValue(self, wildcards, value)

    def setUniqueMatchValue(self, pattern, value):
        r"""
        setUniqueMatchValue(ParameterPool self, std::string const & pattern, double value)
        void ParameterPool::setUniqueMatchValue(const std::string &pattern, double value)

        Sets value of the one parameter that matches  pattern ('*' allowed), or throws. 

        """
        return _libBornAgainParam.ParameterPool_setUniqueMatchValue(self, pattern, value)

    def parameterNames(self):
        r"""
        parameterNames(ParameterPool self) -> vector_string_t
        std::vector< std::string > ParameterPool::parameterNames() const

        """
        return _libBornAgainParam.ParameterPool_parameterNames(self)

    def removeParameter(self, name):
        r"""
        removeParameter(ParameterPool self, std::string const & name)
        void ParameterPool::removeParameter(const std::string &name)

        Removes parameter with given name from the pool. 

        """
        return _libBornAgainParam.ParameterPool_removeParameter(self, name)

    def __getitem__(self, index):
        r"""__getitem__(ParameterPool self, size_t index) -> RealParameter"""
        return _libBornAgainParam.ParameterPool___getitem__(self, index)

    def __iter__(self):
        return ParameterPoolIterator(self)


# Register ParameterPool in _libBornAgainParam:
_libBornAgainParam.ParameterPool_swigregister(ParameterPool)

class IComponent(object):
    r"""


    Root of class hierarchy for sample and instrument model.

    C++ includes: IComponent.h

    """

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

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


        Root of class hierarchy for sample and instrument model.

        C++ includes: IComponent.h

        """
        if self.__class__ == IComponent:
            _self = None
        else:
            _self = self
        _libBornAgainParam.IComponent_swiginit(self, _libBornAgainParam.new_IComponent(_self, ))
    def __disown__(self):
        self.this.disown()
        _libBornAgainParam.disown_IComponent(self)
        return weakref.proxy(self)

# Register IComponent in _libBornAgainParam:
_libBornAgainParam.IComponent_swigregister(IComponent)

class IParametricComponent(IComponent):
    r"""


    Manages a local parameter pool, and a tree of child pools.

    C++ includes: IParametricComponent.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__(IParametricComponent self, std::string const & name="") -> IParametricComponent
        __init__(IParametricComponent self, IParametricComponent other) -> IParametricComponent
        IParametricComponent::IParametricComponent(const IParametricComponent &other)

        """
        if self.__class__ == IParametricComponent:
            _self = None
        else:
            _self = self
        _libBornAgainParam.IParametricComponent_swiginit(self, _libBornAgainParam.new_IParametricComponent(_self, *args))
    __swig_destroy__ = _libBornAgainParam.delete_IParametricComponent

    def parameterPool(self):
        r"""
        parameterPool(IParametricComponent self) -> ParameterPool
        ParameterPool* IParametricComponent::parameterPool() const

        Returns pointer to the parameter pool. 

        """
        return _libBornAgainParam.IParametricComponent_parameterPool(self)

    def createParameterTree(self):
        r"""
        createParameterTree(IParametricComponent self) -> ParameterPool
        ParameterPool * IParametricComponent::createParameterTree() const

        Creates new parameter pool, with all local parameters and those of its children. 

        """
        return _libBornAgainParam.IParametricComponent_createParameterTree(self)

    def parametersToString(self):
        r"""
        parametersToString(IParametricComponent self) -> std::string
        std::string IParametricComponent::parametersToString() const

        Returns multiline string representing available parameters. 

        """
        return _libBornAgainParam.IParametricComponent_parametersToString(self)

    def registerParameter(self, name, parpointer):
        r"""
        registerParameter(IParametricComponent self, std::string const & name, double * parpointer) -> RealParameter
        RealParameter & IParametricComponent::registerParameter(const std::string &name, double *parpointer)

        """
        return _libBornAgainParam.IParametricComponent_registerParameter(self, name, parpointer)

    def registerVector(self, *args):
        r"""
        registerVector(IParametricComponent self, std::string const & base_name, kvector_t p_vec, std::string const & units="nm")
        void IParametricComponent::registerVector(const std::string &base_name, kvector_t *p_vec, const std::string &units="nm")

        """
        return _libBornAgainParam.IParametricComponent_registerVector(self, *args)

    def setParameterValue(self, name, value):
        r"""
        setParameterValue(IParametricComponent self, std::string const & name, double value)
        void IParametricComponent::setParameterValue(const std::string &name, double value)

        """
        return _libBornAgainParam.IParametricComponent_setParameterValue(self, name, value)

    def setVectorValue(self, base_name, value):
        r"""
        setVectorValue(IParametricComponent self, std::string const & base_name, kvector_t value)
        void IParametricComponent::setVectorValue(const std::string &base_name, kvector_t value)

        """
        return _libBornAgainParam.IParametricComponent_setVectorValue(self, base_name, value)

    def parameter(self, name):
        r"""
        parameter(IParametricComponent self, std::string const & name) -> RealParameter
        RealParameter * IParametricComponent::parameter(const std::string &name) const

        Returns parameter with given 'name'. 

        """
        return _libBornAgainParam.IParametricComponent_parameter(self, name)

    def onChange(self):
        r"""
        onChange(IParametricComponent self)
        virtual void IParametricComponent::onChange()

        Action to be taken in inherited class when a parameter has changed. 

        """
        return _libBornAgainParam.IParametricComponent_onChange(self)

    def removeParameter(self, name):
        r"""
        removeParameter(IParametricComponent self, std::string const & name)
        void IParametricComponent::removeParameter(const std::string &name)

        """
        return _libBornAgainParam.IParametricComponent_removeParameter(self, name)

    def removeVector(self, base_name):
        r"""
        removeVector(IParametricComponent self, std::string const & base_name)
        void IParametricComponent::removeVector(const std::string &base_name)

        """
        return _libBornAgainParam.IParametricComponent_removeVector(self, base_name)

    @staticmethod
    def XComponentName(base_name):
        r"""XComponentName(std::string const & base_name) -> std::string"""
        return _libBornAgainParam.IParametricComponent_XComponentName(base_name)

    @staticmethod
    def YComponentName(base_name):
        r"""YComponentName(std::string const & base_name) -> std::string"""
        return _libBornAgainParam.IParametricComponent_YComponentName(base_name)

    @staticmethod
    def ZComponentName(base_name):
        r"""ZComponentName(std::string const & base_name) -> std::string"""
        return _libBornAgainParam.IParametricComponent_ZComponentName(base_name)

    def setName(self, name):
        r"""
        setName(IParametricComponent self, std::string const & name)
        void IParametricComponent::setName(const std::string &name)

        """
        return _libBornAgainParam.IParametricComponent_setName(self, name)

    def getName(self):
        r"""
        getName(IParametricComponent self) -> std::string const &
        const std::string& IParametricComponent::getName() const

        """
        return _libBornAgainParam.IParametricComponent_getName(self)
    def __disown__(self):
        self.this.disown()
        _libBornAgainParam.disown_IParametricComponent(self)
        return weakref.proxy(self)

# Register IParametricComponent in _libBornAgainParam:
_libBornAgainParam.IParametricComponent_swigregister(IParametricComponent)

def IParametricComponent_XComponentName(base_name):
    r"""IParametricComponent_XComponentName(std::string const & base_name) -> std::string"""
    return _libBornAgainParam.IParametricComponent_XComponentName(base_name)

def IParametricComponent_YComponentName(base_name):
    r"""IParametricComponent_YComponentName(std::string const & base_name) -> std::string"""
    return _libBornAgainParam.IParametricComponent_YComponentName(base_name)

def IParametricComponent_ZComponentName(base_name):
    r"""IParametricComponent_ZComponentName(std::string const & base_name) -> std::string"""
    return _libBornAgainParam.IParametricComponent_ZComponentName(base_name)

class ParaMeta(object):
    r"""


    Metadata of one model parameter.

    C++ includes: INode.h

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_libBornAgainParam.ParaMeta_name_get, _libBornAgainParam.ParaMeta_name_set, doc=r"""name : std::string""")
    unit = property(_libBornAgainParam.ParaMeta_unit_get, _libBornAgainParam.ParaMeta_unit_set, doc=r"""unit : std::string""")
    tooltip = property(_libBornAgainParam.ParaMeta_tooltip_get, _libBornAgainParam.ParaMeta_tooltip_set, doc=r"""tooltip : std::string""")
    vMin = property(_libBornAgainParam.ParaMeta_vMin_get, _libBornAgainParam.ParaMeta_vMin_set, doc=r"""vMin : double""")
    vMax = property(_libBornAgainParam.ParaMeta_vMax_get, _libBornAgainParam.ParaMeta_vMax_set, doc=r"""vMax : double""")
    vDefault = property(_libBornAgainParam.ParaMeta_vDefault_get, _libBornAgainParam.ParaMeta_vDefault_set, doc=r"""vDefault : double""")

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


        Metadata of one model parameter.

        C++ includes: INode.h

        """
        _libBornAgainParam.ParaMeta_swiginit(self, _libBornAgainParam.new_ParaMeta())
    __swig_destroy__ = _libBornAgainParam.delete_ParaMeta

# Register ParaMeta in _libBornAgainParam:
_libBornAgainParam.ParaMeta_swigregister(ParaMeta)
cvar = _libBornAgainParam.cvar
INF = cvar.INF

class NodeMeta(object):
    r"""


    Metadata of one model node.

    C++ includes: INode.h

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    className = property(_libBornAgainParam.NodeMeta_className_get, _libBornAgainParam.NodeMeta_className_set, doc=r"""className : std::string""")
    tooltip = property(_libBornAgainParam.NodeMeta_tooltip_get, _libBornAgainParam.NodeMeta_tooltip_set, doc=r"""tooltip : std::string""")
    paraMeta = property(_libBornAgainParam.NodeMeta_paraMeta_get, _libBornAgainParam.NodeMeta_paraMeta_set, doc=r"""paraMeta : std::vector<(ParaMeta,std::allocator<(ParaMeta)>)>""")

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


        Metadata of one model node.

        C++ includes: INode.h

        """
        _libBornAgainParam.NodeMeta_swiginit(self, _libBornAgainParam.new_NodeMeta())
    __swig_destroy__ = _libBornAgainParam.delete_NodeMeta

# Register NodeMeta in _libBornAgainParam:
_libBornAgainParam.NodeMeta_swigregister(NodeMeta)


def nodeMetaUnion(base, other):
    r"""
    nodeMetaUnion(std::vector< ParaMeta,std::allocator< ParaMeta > > const & base, NodeMeta other) -> NodeMeta
    NodeMeta nodeMetaUnion(const std::vector< ParaMeta > &base, const NodeMeta &other)

    """
    return _libBornAgainParam.nodeMetaUnion(base, other)
class INode(IParametricComponent):
    r"""


    Base class for tree-like structures containing parameterized objects.

    C++ includes: INode.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__(INode self) -> INode
        __init__(INode self, NodeMeta meta, vdouble1d_t PValues) -> INode
        INode::INode(const NodeMeta &meta, const std::vector< double > &PValues)

        """
        if self.__class__ == INode:
            _self = None
        else:
            _self = self
        _libBornAgainParam.INode_swiginit(self, _libBornAgainParam.new_INode(_self, *args))
    __swig_destroy__ = _libBornAgainParam.delete_INode

    def accept(self, visitor):
        r"""
        accept(INode self, INodeVisitor visitor)
        virtual void INode::accept(INodeVisitor *visitor) const =0

        Calls the  INodeVisitor's visit method. 

        """
        return _libBornAgainParam.INode_accept(self, visitor)

    def treeToString(self):
        r"""
        treeToString(INode self) -> std::string
        std::string INode::treeToString() const

        Returns multiline string representing tree structure below the node. 

        """
        return _libBornAgainParam.INode_treeToString(self)

    def registerChild(self, node):
        r"""
        registerChild(INode self, INode node)
        void INode::registerChild(INode *node)

        """
        return _libBornAgainParam.INode_registerChild(self, node)

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

        Returns a vector of children. 

        """
        return _libBornAgainParam.INode_getChildren(self)

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

        Returns a vector of all descendants. 

        """
        return _libBornAgainParam.INode_progeny(self)

    def setParent(self, newParent):
        r"""
        setParent(INode self, INode newParent)
        void INode::setParent(const INode *newParent)

        """
        return _libBornAgainParam.INode_setParent(self, newParent)

    def parent(self, *args):
        r"""
        parent(INode self) -> INode
        parent(INode self) -> INode
        INode * INode::parent()

        """
        return _libBornAgainParam.INode_parent(self, *args)

    def copyNumber(self, node):
        r"""
        copyNumber(INode self, INode node) -> int
        int INode::copyNumber(const INode *node) const

        Returns copyNumber of child, which takes into account existence of children with same name. 

        """
        return _libBornAgainParam.INode_copyNumber(self, node)

    def displayName(self):
        r"""
        displayName(INode self) -> std::string
        std::string INode::displayName() const

        Returns display name, composed from the name of node and it's copy number. 

        """
        return _libBornAgainParam.INode_displayName(self)

    def createParameterTree(self):
        r"""
        createParameterTree(INode self) -> ParameterPool
        ParameterPool * INode::createParameterTree() const

        Creates new parameter pool, with all local parameters and those of its children. 

        """
        return _libBornAgainParam.INode_createParameterTree(self)
    def __disown__(self):
        self.this.disown()
        _libBornAgainParam.disown_INode(self)
        return weakref.proxy(self)

# Register INode in _libBornAgainParam:
_libBornAgainParam.INode_swigregister(INode)

class INodeVisitor(object):
    r"""


    From visitor pattern to achieve double dispatch.

    Visitor interface to visit ISampleNode objects.

    C++ includes: INodeVisitor.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__(INodeVisitor self) -> INodeVisitor
        INodeVisitor::INodeVisitor()

        """
        _libBornAgainParam.INodeVisitor_swiginit(self, _libBornAgainParam.new_INodeVisitor())
    __swig_destroy__ = _libBornAgainParam.delete_INodeVisitor

    def visit(self, *args):
        r"""
        visit(INodeVisitor self, BasicLattice2D const * arg2)
        visit(INodeVisitor self, Beam const * arg2)
        visit(INodeVisitor self, ConstantBackground const * arg2)
        visit(INodeVisitor self, ConvolutionDetectorResolution const * arg2)
        visit(INodeVisitor self, Crystal const * arg2)
        visit(INodeVisitor self, DistributionCosine arg2)
        visit(INodeVisitor self, DistributionGate arg2)
        visit(INodeVisitor self, DistributionGaussian arg2)
        visit(INodeVisitor self, DistributionLogNormal arg2)
        visit(INodeVisitor self, DistributionLorentz arg2)
        visit(INodeVisitor self, DistributionTrapezoid arg2)
        visit(INodeVisitor self, FootprintGauss const * arg2)
        visit(INodeVisitor self, FootprintSquare const * arg2)
        visit(INodeVisitor self, FormFactorAnisoPyramid const * arg2)
        visit(INodeVisitor self, FormFactorBarGauss const * arg2)
        visit(INodeVisitor self, FormFactorBarLorentz const * arg2)
        visit(INodeVisitor self, FormFactorBox const * arg2)
        visit(INodeVisitor self, FormFactorCantellatedCube const * arg2)
        visit(INodeVisitor self, FormFactorCone const * arg2)
        visit(INodeVisitor self, FormFactorCone6 const * arg2)
        visit(INodeVisitor self, FormFactorCoreShell const * arg2)
        visit(INodeVisitor self, FormFactorCrystal const * arg2)
        visit(INodeVisitor self, FormFactorCuboctahedron const * arg2)
        visit(INodeVisitor self, FormFactorCylinder const * arg2)
        visit(INodeVisitor self, FormFactorDecoratorMaterial const * arg2)
        visit(INodeVisitor self, FormFactorDecoratorPositionFactor const * arg2)
        visit(INodeVisitor self, FormFactorDecoratorRotation const * arg2)
        visit(INodeVisitor self, FormFactorDodecahedron const * arg2)
        visit(INodeVisitor self, FormFactorDot const * arg2)
        visit(INodeVisitor self, FormFactorEllipsoidalCylinder const * arg2)
        visit(INodeVisitor self, FormFactorFullSphere const * arg2)
        visit(INodeVisitor self, FormFactorFullSpheroid const * arg2)
        visit(INodeVisitor self, FormFactorGaussSphere const * arg2)
        visit(INodeVisitor self, FormFactorHemiEllipsoid const * arg2)
        visit(INodeVisitor self, FormFactorHollowSphere const * arg2)
        visit(INodeVisitor self, FormFactorIcosahedron const * arg2)
        visit(INodeVisitor self, FormFactorLongBoxGauss const * arg2)
        visit(INodeVisitor self, FormFactorLongBoxLorentz const * arg2)
        visit(INodeVisitor self, FormFactorPrism3 const * arg2)
        visit(INodeVisitor self, FormFactorPrism6 const * arg2)
        visit(INodeVisitor self, FormFactorPyramid const * arg2)
        visit(INodeVisitor self, FormFactorCosineRippleBox const * arg2)
        visit(INodeVisitor self, FormFactorCosineRippleGauss const * arg2)
        visit(INodeVisitor self, FormFactorCosineRippleLorentz const * arg2)
        visit(INodeVisitor self, FormFactorSawtoothRippleBox const * arg2)
        visit(INodeVisitor self, FormFactorSawtoothRippleGauss const * arg2)
        visit(INodeVisitor self, FormFactorSawtoothRippleLorentz const * arg2)
        visit(INodeVisitor self, FormFactorSphereGaussianRadius const * arg2)
        visit(INodeVisitor self, FormFactorSphereLogNormalRadius const * arg2)
        visit(INodeVisitor self, FormFactorTetrahedron const * arg2)
        visit(INodeVisitor self, FormFactorTruncatedCube const * arg2)
        visit(INodeVisitor self, FormFactorTruncatedSphere const * arg2)
        visit(INodeVisitor self, FormFactorTruncatedSpheroid const * arg2)
        visit(INodeVisitor self, FormFactorWeighted const * arg2)
        visit(INodeVisitor self, FTDecayFunction1DCauchy const * arg2)
        visit(INodeVisitor self, FTDecayFunction1DGauss const * arg2)
        visit(INodeVisitor self, FTDecayFunction1DTriangle const * arg2)
        visit(INodeVisitor self, FTDecayFunction1DVoigt const * arg2)
        visit(INodeVisitor self, FTDecayFunction2DCauchy const * arg2)
        visit(INodeVisitor self, FTDecayFunction2DGauss const * arg2)
        visit(INodeVisitor self, FTDecayFunction2DVoigt const * arg2)
        visit(INodeVisitor self, FTDistribution1DCauchy const * arg2)
        visit(INodeVisitor self, FTDistribution1DCosine const * arg2)
        visit(INodeVisitor self, FTDistribution1DGate const * arg2)
        visit(INodeVisitor self, FTDistribution1DGauss const * arg2)
        visit(INodeVisitor self, FTDistribution1DTriangle const * arg2)
        visit(INodeVisitor self, FTDistribution1DVoigt const * arg2)
        visit(INodeVisitor self, FTDistribution2DCauchy const * arg2)
        visit(INodeVisitor self, FTDistribution2DCone const * arg2)
        visit(INodeVisitor self, FTDistribution2DGate const * arg2)
        visit(INodeVisitor self, FTDistribution2DGauss const * arg2)
        visit(INodeVisitor self, FTDistribution2DVoigt const * arg2)
        visit(INodeVisitor self, GISASSimulation const * arg2)
        visit(INodeVisitor self, HexagonalLattice2D const * arg2)
        visit(INodeVisitor self, IAbstractParticle const * arg2)
        visit(INodeVisitor self, IClusteredParticles const * arg2)
        visit(INodeVisitor self, IdentityRotation const * arg2)
        visit(INodeVisitor self, IFormFactor const * arg2)
        visit(INodeVisitor self, IBornFF const * arg2)
        visit(INodeVisitor self, IFormFactorDecorator const * arg2)
        visit(INodeVisitor self, IInterferenceFunction const * arg2)
        visit(INodeVisitor self, ParticleLayout const * arg2)
        visit(INodeVisitor self, INode arg2)
        visit(INodeVisitor self, Instrument const * arg2)
        visit(INodeVisitor self, InterferenceFunction1DLattice const * arg2)
        visit(INodeVisitor self, InterferenceFunction2DLattice const * arg2)
        visit(INodeVisitor self, InterferenceFunction2DParaCrystal const * arg2)
        visit(INodeVisitor self, InterferenceFunction2DSuperLattice const * arg2)
        visit(INodeVisitor self, InterferenceFunction3DLattice const * arg2)
        visit(INodeVisitor self, InterferenceFunctionFinite2DLattice const * arg2)
        visit(INodeVisitor self, InterferenceFunctionFinite3DLattice const * arg2)
        visit(INodeVisitor self, InterferenceFunctionHardDisk const * arg2)
        visit(INodeVisitor self, InterferenceFunctionRadialParaCrystal const * arg2)
        visit(INodeVisitor self, InterferenceFunctionTwin const * arg2)
        visit(INodeVisitor self, InterferenceFunctionNone const * arg2)
        visit(INodeVisitor self, IParticle const * arg2)
        visit(INodeVisitor self, IPeakShape const * arg2)
        visit(INodeVisitor self, IRotation const * arg2)
        visit(INodeVisitor self, ISampleNode const * arg2)
        visit(INodeVisitor self, IsGISAXSDetector const * arg2)
        visit(INodeVisitor self, Layer const * arg2)
        visit(INodeVisitor self, LayerInterface const * arg2)
        visit(INodeVisitor self, LayerRoughness const * arg2)
        visit(INodeVisitor self, MesoCrystal const * arg2)
        visit(INodeVisitor self, MultiLayer const * arg2)
        visit(INodeVisitor self, OffSpecularSimulation const * arg2)
        visit(INodeVisitor self, Particle const * arg2)
        visit(INodeVisitor self, ParticleComposition const * arg2)
        visit(INodeVisitor self, ParticleCoreShell const * arg2)
        visit(INodeVisitor self, ParticleDistribution const * arg2)
        visit(INodeVisitor self, PoissonNoiseBackground const * arg2)
        visit(INodeVisitor self, RectangularDetector const * arg2)
        visit(INodeVisitor self, ResolutionFunction2DGaussian const * arg2)
        visit(INodeVisitor self, RotationEuler const * arg2)
        visit(INodeVisitor self, RotationX const * arg2)
        visit(INodeVisitor self, RotationY const * arg2)
        visit(INodeVisitor self, RotationZ const * arg2)
        visit(INodeVisitor self, SpecularDetector1D const * arg2)
        visit(INodeVisitor self, SpecularSimulation const * arg2)
        visit(INodeVisitor self, SphericalDetector const * arg2)
        visit(INodeVisitor self, SquareLattice2D const * arg2)
        virtual void INodeVisitor::visit(const SquareLattice2D *)

        """
        return _libBornAgainParam.INodeVisitor_visit(self, *args)

    def depth(self):
        r"""
        depth(INodeVisitor self) -> int
        int INodeVisitor::depth() const

        Returns depth of the visitor in the composite hierarchy. 

        """
        return _libBornAgainParam.INodeVisitor_depth(self)

    def setDepth(self, depth):
        r"""
        setDepth(INodeVisitor self, int depth)
        void INodeVisitor::setDepth(int depth)

        Sets depth of the visitor in the composite hierarchy. 

        """
        return _libBornAgainParam.INodeVisitor_setDepth(self, depth)

# Register INodeVisitor in _libBornAgainParam:
_libBornAgainParam.INodeVisitor_swigregister(INodeVisitor)

class IDistribution1D(libBornAgainBase.ICloneable, INode):
    r"""


    Interface for one-dimensional distributions.

    C++ includes: Distributions.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

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

        """
        return _libBornAgainParam.IDistribution1D_clone(self)

    def probabilityDensity(self, x):
        r"""
        probabilityDensity(IDistribution1D self, double x) -> double
        virtual double IDistribution1D::probabilityDensity(double x) const =0

        Returns the distribution-specific probability density for value x. 

        """
        return _libBornAgainParam.IDistribution1D_probabilityDensity(self, x)

    def getMean(self):
        r"""
        getMean(IDistribution1D self) -> double
        virtual double IDistribution1D::getMean() const =0

        Returns the distribution-specific mean. 

        """
        return _libBornAgainParam.IDistribution1D_getMean(self)

    def equidistantSamples(self, *args):
        r"""
        equidistantSamples(IDistribution1D self, size_t nbr_samples, double sigma_factor=0., RealLimits const & limits=RealLimits()) -> ParameterSampleVector
        std::vector< ParameterSample > IDistribution1D::equidistantSamples(size_t nbr_samples, double sigma_factor=0., const RealLimits &limits=RealLimits()) const

        Returns equidistant samples, using intrinsic parameters, weighted with  probabilityDensity(). 

        """
        return _libBornAgainParam.IDistribution1D_equidistantSamples(self, *args)

    def equidistantSamplesInRange(self, nbr_samples, xmin, xmax):
        r"""
        equidistantSamplesInRange(IDistribution1D self, size_t nbr_samples, double xmin, double xmax) -> ParameterSampleVector
        std::vector< ParameterSample > IDistribution1D::equidistantSamplesInRange(size_t nbr_samples, double xmin, double xmax) const

        Returns equidistant samples from xmin to xmax, weighted with  probabilityDensity(). 

        """
        return _libBornAgainParam.IDistribution1D_equidistantSamplesInRange(self, nbr_samples, xmin, xmax)

    def equidistantPoints(self, *args):
        r"""
        equidistantPoints(IDistribution1D self, size_t nbr_samples, double sigma_factor, RealLimits const & limits=RealLimits()) -> vdouble1d_t
        virtual std::vector<double> IDistribution1D::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits=RealLimits()) const =0

        Returns equidistant interpolation points, with range computed in distribution-specific way from mean and width parameter, taking into account limits and sigma_factor. 

        """
        return _libBornAgainParam.IDistribution1D_equidistantPoints(self, *args)

    def equidistantPointsInRange(self, nbr_samples, xmin, xmax):
        r"""
        equidistantPointsInRange(IDistribution1D self, size_t nbr_samples, double xmin, double xmax) -> vdouble1d_t
        std::vector< double > IDistribution1D::equidistantPointsInRange(size_t nbr_samples, double xmin, double xmax) const

        Returns equidistant interpolation points from xmin to xmax. 

        """
        return _libBornAgainParam.IDistribution1D_equidistantPointsInRange(self, nbr_samples, xmin, xmax)

    def isDelta(self):
        r"""
        isDelta(IDistribution1D self) -> bool
        virtual bool IDistribution1D::isDelta() const =0

        Returns true if the distribution is in the limit case of a Dirac delta distribution. 

        """
        return _libBornAgainParam.IDistribution1D_isDelta(self)

    def setUnits(self, units):
        r"""
        setUnits(IDistribution1D self, std::string const & units)
        void IDistribution1D::setUnits(const std::string &units)

        Sets distribution units. 

        """
        return _libBornAgainParam.IDistribution1D_setUnits(self, units)
    __swig_destroy__ = _libBornAgainParam.delete_IDistribution1D

# Register IDistribution1D in _libBornAgainParam:
_libBornAgainParam.IDistribution1D_swigregister(IDistribution1D)

class DistributionGate(IDistribution1D):
    r"""


    Uniform distribution function with half width hwhm.

    C++ includes: Distributions.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__(DistributionGate self, vdouble1d_t P) -> DistributionGate
        __init__(DistributionGate self, double min, double max) -> DistributionGate
        __init__(DistributionGate self) -> DistributionGate
        DistributionGate::DistributionGate()

        """
        _libBornAgainParam.DistributionGate_swiginit(self, _libBornAgainParam.new_DistributionGate(*args))

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

        """
        return _libBornAgainParam.DistributionGate_clone(self)

    def probabilityDensity(self, x):
        r"""
        probabilityDensity(DistributionGate self, double x) -> double
        double DistributionGate::probabilityDensity(double x) const final

        Returns the distribution-specific probability density for value x. 

        """
        return _libBornAgainParam.DistributionGate_probabilityDensity(self, x)

    def getMean(self):
        r"""
        getMean(DistributionGate self) -> double
        double DistributionGate::getMean() const final

        Returns the distribution-specific mean. 

        """
        return _libBornAgainParam.DistributionGate_getMean(self)

    def lowerBound(self):
        r"""
        lowerBound(DistributionGate self) -> double
        double DistributionGate::lowerBound() const

        """
        return _libBornAgainParam.DistributionGate_lowerBound(self)

    def upperBound(self):
        r"""
        upperBound(DistributionGate self) -> double
        double DistributionGate::upperBound() const

        """
        return _libBornAgainParam.DistributionGate_upperBound(self)

    def equidistantPoints(self, *args):
        r"""
        equidistantPoints(DistributionGate self, size_t nbr_samples, double sigma_factor, RealLimits const & limits=RealLimits()) -> vdouble1d_t
        std::vector< double > DistributionGate::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits=RealLimits()) const

        Returns list of sample values. 

        """
        return _libBornAgainParam.DistributionGate_equidistantPoints(self, *args)

    def isDelta(self):
        r"""
        isDelta(DistributionGate self) -> bool
        bool DistributionGate::isDelta() const final

        Returns true if the distribution is in the limit case of a Dirac delta distribution. 

        """
        return _libBornAgainParam.DistributionGate_isDelta(self)

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

        Calls the  INodeVisitor's visit method. 

        """
        return _libBornAgainParam.DistributionGate_accept(self, visitor)
    __swig_destroy__ = _libBornAgainParam.delete_DistributionGate

# Register DistributionGate in _libBornAgainParam:
_libBornAgainParam.DistributionGate_swigregister(DistributionGate)

class DistributionLorentz(IDistribution1D):
    r"""


    Lorentz distribution with half width hwhm.

    C++ includes: Distributions.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__(DistributionLorentz self, vdouble1d_t P) -> DistributionLorentz
        __init__(DistributionLorentz self, double mean, double hwhm) -> DistributionLorentz
        __init__(DistributionLorentz self) -> DistributionLorentz
        DistributionLorentz::DistributionLorentz()

        """
        _libBornAgainParam.DistributionLorentz_swiginit(self, _libBornAgainParam.new_DistributionLorentz(*args))

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

        """
        return _libBornAgainParam.DistributionLorentz_clone(self)

    def probabilityDensity(self, x):
        r"""
        probabilityDensity(DistributionLorentz self, double x) -> double
        double DistributionLorentz::probabilityDensity(double x) const final

        Returns the distribution-specific probability density for value x. 

        """
        return _libBornAgainParam.DistributionLorentz_probabilityDensity(self, x)

    def getMean(self):
        r"""
        getMean(DistributionLorentz self) -> double
        double DistributionLorentz::getMean() const final

        Returns the distribution-specific mean. 

        """
        return _libBornAgainParam.DistributionLorentz_getMean(self)

    def getHWHM(self):
        r"""
        getHWHM(DistributionLorentz self) -> double
        double DistributionLorentz::getHWHM() const

        """
        return _libBornAgainParam.DistributionLorentz_getHWHM(self)

    def equidistantPoints(self, *args):
        r"""
        equidistantPoints(DistributionLorentz self, size_t nbr_samples, double sigma_factor, RealLimits const & limits=RealLimits()) -> vdouble1d_t
        std::vector< double > DistributionLorentz::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits=RealLimits()) const

        generate list of sample values 

        """
        return _libBornAgainParam.DistributionLorentz_equidistantPoints(self, *args)

    def isDelta(self):
        r"""
        isDelta(DistributionLorentz self) -> bool
        bool DistributionLorentz::isDelta() const final

        Returns true if the distribution is in the limit case of a Dirac delta distribution. 

        """
        return _libBornAgainParam.DistributionLorentz_isDelta(self)

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

        Calls the  INodeVisitor's visit method. 

        """
        return _libBornAgainParam.DistributionLorentz_accept(self, visitor)
    __swig_destroy__ = _libBornAgainParam.delete_DistributionLorentz

# Register DistributionLorentz in _libBornAgainParam:
_libBornAgainParam.DistributionLorentz_swigregister(DistributionLorentz)

class DistributionGaussian(IDistribution1D):
    r"""


    Gaussian distribution with standard deviation std_dev.

    C++ includes: Distributions.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__(DistributionGaussian self, vdouble1d_t P) -> DistributionGaussian
        __init__(DistributionGaussian self, double mean, double std_dev) -> DistributionGaussian
        __init__(DistributionGaussian self) -> DistributionGaussian
        DistributionGaussian::DistributionGaussian()

        """
        _libBornAgainParam.DistributionGaussian_swiginit(self, _libBornAgainParam.new_DistributionGaussian(*args))

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

        """
        return _libBornAgainParam.DistributionGaussian_clone(self)

    def probabilityDensity(self, x):
        r"""
        probabilityDensity(DistributionGaussian self, double x) -> double
        double DistributionGaussian::probabilityDensity(double x) const final

        Returns the distribution-specific probability density for value x. 

        """
        return _libBornAgainParam.DistributionGaussian_probabilityDensity(self, x)

    def getMean(self):
        r"""
        getMean(DistributionGaussian self) -> double
        double DistributionGaussian::getMean() const final

        Returns the distribution-specific mean. 

        """
        return _libBornAgainParam.DistributionGaussian_getMean(self)

    def getStdDev(self):
        r"""
        getStdDev(DistributionGaussian self) -> double
        double DistributionGaussian::getStdDev() const

        """
        return _libBornAgainParam.DistributionGaussian_getStdDev(self)

    def equidistantPoints(self, *args):
        r"""
        equidistantPoints(DistributionGaussian self, size_t nbr_samples, double sigma_factor, RealLimits const & limits=RealLimits()) -> vdouble1d_t
        std::vector< double > DistributionGaussian::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits=RealLimits()) const

        generate list of sample values 

        """
        return _libBornAgainParam.DistributionGaussian_equidistantPoints(self, *args)

    def isDelta(self):
        r"""
        isDelta(DistributionGaussian self) -> bool
        bool DistributionGaussian::isDelta() const final

        Returns true if the distribution is in the limit case of a Dirac delta distribution. 

        """
        return _libBornAgainParam.DistributionGaussian_isDelta(self)

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

        Calls the  INodeVisitor's visit method. 

        """
        return _libBornAgainParam.DistributionGaussian_accept(self, visitor)
    __swig_destroy__ = _libBornAgainParam.delete_DistributionGaussian

# Register DistributionGaussian in _libBornAgainParam:
_libBornAgainParam.DistributionGaussian_swigregister(DistributionGaussian)

class DistributionLogNormal(IDistribution1D):
    r"""


    Log-normal distribution.

    C++ includes: Distributions.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__(DistributionLogNormal self, vdouble1d_t P) -> DistributionLogNormal
        __init__(DistributionLogNormal self, double median, double scale_param) -> DistributionLogNormal
        DistributionLogNormal::DistributionLogNormal()=delete

        """
        _libBornAgainParam.DistributionLogNormal_swiginit(self, _libBornAgainParam.new_DistributionLogNormal(*args))

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

        """
        return _libBornAgainParam.DistributionLogNormal_clone(self)

    def probabilityDensity(self, x):
        r"""
        probabilityDensity(DistributionLogNormal self, double x) -> double
        double DistributionLogNormal::probabilityDensity(double x) const final

        Returns the distribution-specific probability density for value x. 

        """
        return _libBornAgainParam.DistributionLogNormal_probabilityDensity(self, x)

    def getMean(self):
        r"""
        getMean(DistributionLogNormal self) -> double
        double DistributionLogNormal::getMean() const final

        Returns the distribution-specific mean. 

        """
        return _libBornAgainParam.DistributionLogNormal_getMean(self)

    def getMedian(self):
        r"""
        getMedian(DistributionLogNormal self) -> double
        double DistributionLogNormal::getMedian() const

        """
        return _libBornAgainParam.DistributionLogNormal_getMedian(self)

    def getScalePar(self):
        r"""
        getScalePar(DistributionLogNormal self) -> double
        double DistributionLogNormal::getScalePar() const

        """
        return _libBornAgainParam.DistributionLogNormal_getScalePar(self)

    def equidistantPoints(self, *args):
        r"""
        equidistantPoints(DistributionLogNormal self, size_t nbr_samples, double sigma_factor, RealLimits const & limits=RealLimits()) -> vdouble1d_t
        std::vector< double > DistributionLogNormal::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits=RealLimits()) const

        generate list of sample values 

        """
        return _libBornAgainParam.DistributionLogNormal_equidistantPoints(self, *args)

    def isDelta(self):
        r"""
        isDelta(DistributionLogNormal self) -> bool
        bool DistributionLogNormal::isDelta() const final

        Returns true if the distribution is in the limit case of a Dirac delta distribution. 

        """
        return _libBornAgainParam.DistributionLogNormal_isDelta(self)

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

        Calls the  INodeVisitor's visit method. 

        """
        return _libBornAgainParam.DistributionLogNormal_accept(self, visitor)

    def setUnits(self, units):
        r"""
        setUnits(DistributionLogNormal self, std::string const & units)
        void DistributionLogNormal::setUnits(const std::string &units)

        Sets distribution units. 

        """
        return _libBornAgainParam.DistributionLogNormal_setUnits(self, units)
    __swig_destroy__ = _libBornAgainParam.delete_DistributionLogNormal

# Register DistributionLogNormal in _libBornAgainParam:
_libBornAgainParam.DistributionLogNormal_swigregister(DistributionLogNormal)

class DistributionCosine(IDistribution1D):
    r"""


    Cosine distribution.

    C++ includes: Distributions.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__(DistributionCosine self, vdouble1d_t P) -> DistributionCosine
        __init__(DistributionCosine self, double mean, double sigma) -> DistributionCosine
        __init__(DistributionCosine self) -> DistributionCosine
        DistributionCosine::DistributionCosine()

        """
        _libBornAgainParam.DistributionCosine_swiginit(self, _libBornAgainParam.new_DistributionCosine(*args))

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

        """
        return _libBornAgainParam.DistributionCosine_clone(self)

    def probabilityDensity(self, x):
        r"""
        probabilityDensity(DistributionCosine self, double x) -> double
        double DistributionCosine::probabilityDensity(double x) const final

        Returns the distribution-specific probability density for value x. 

        """
        return _libBornAgainParam.DistributionCosine_probabilityDensity(self, x)

    def getMean(self):
        r"""
        getMean(DistributionCosine self) -> double
        double DistributionCosine::getMean() const final

        Returns the distribution-specific mean. 

        """
        return _libBornAgainParam.DistributionCosine_getMean(self)

    def getSigma(self):
        r"""
        getSigma(DistributionCosine self) -> double
        double DistributionCosine::getSigma() const

        """
        return _libBornAgainParam.DistributionCosine_getSigma(self)

    def equidistantPoints(self, *args):
        r"""
        equidistantPoints(DistributionCosine self, size_t nbr_samples, double sigma_factor, RealLimits const & limits=RealLimits()) -> vdouble1d_t
        std::vector< double > DistributionCosine::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits=RealLimits()) const

        generate list of sample values 

        """
        return _libBornAgainParam.DistributionCosine_equidistantPoints(self, *args)

    def isDelta(self):
        r"""
        isDelta(DistributionCosine self) -> bool
        bool DistributionCosine::isDelta() const final

        Returns true if the distribution is in the limit case of a Dirac delta distribution. 

        """
        return _libBornAgainParam.DistributionCosine_isDelta(self)

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

        Calls the  INodeVisitor's visit method. 

        """
        return _libBornAgainParam.DistributionCosine_accept(self, visitor)
    __swig_destroy__ = _libBornAgainParam.delete_DistributionCosine

# Register DistributionCosine in _libBornAgainParam:
_libBornAgainParam.DistributionCosine_swigregister(DistributionCosine)

class DistributionTrapezoid(IDistribution1D):
    r"""


    Trapezoidal distribution.

    C++ includes: Distributions.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__(DistributionTrapezoid self, vdouble1d_t P) -> DistributionTrapezoid
        __init__(DistributionTrapezoid self, double center, double left, double middle, double right) -> DistributionTrapezoid
        __init__(DistributionTrapezoid self) -> DistributionTrapezoid
        DistributionTrapezoid::DistributionTrapezoid()

        """
        _libBornAgainParam.DistributionTrapezoid_swiginit(self, _libBornAgainParam.new_DistributionTrapezoid(*args))

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

        """
        return _libBornAgainParam.DistributionTrapezoid_clone(self)

    def probabilityDensity(self, x):
        r"""
        probabilityDensity(DistributionTrapezoid self, double x) -> double
        double DistributionTrapezoid::probabilityDensity(double x) const final

        Returns the distribution-specific probability density for value x. 

        """
        return _libBornAgainParam.DistributionTrapezoid_probabilityDensity(self, x)

    def getMean(self):
        r"""
        getMean(DistributionTrapezoid self) -> double
        double DistributionTrapezoid::getMean() const final

        Returns the distribution-specific mean. 

        """
        return _libBornAgainParam.DistributionTrapezoid_getMean(self)

    def getLeftWidth(self):
        r"""
        getLeftWidth(DistributionTrapezoid self) -> double
        double DistributionTrapezoid::getLeftWidth() const

        """
        return _libBornAgainParam.DistributionTrapezoid_getLeftWidth(self)

    def getMiddleWidth(self):
        r"""
        getMiddleWidth(DistributionTrapezoid self) -> double
        double DistributionTrapezoid::getMiddleWidth() const

        """
        return _libBornAgainParam.DistributionTrapezoid_getMiddleWidth(self)

    def getRightWidth(self):
        r"""
        getRightWidth(DistributionTrapezoid self) -> double
        double DistributionTrapezoid::getRightWidth() const

        """
        return _libBornAgainParam.DistributionTrapezoid_getRightWidth(self)

    def equidistantPoints(self, *args):
        r"""
        equidistantPoints(DistributionTrapezoid self, size_t nbr_samples, double sigma_factor, RealLimits const & limits=RealLimits()) -> vdouble1d_t
        std::vector< double > DistributionTrapezoid::equidistantPoints(size_t nbr_samples, double sigma_factor, const RealLimits &limits=RealLimits()) const

        generate list of sample values 

        """
        return _libBornAgainParam.DistributionTrapezoid_equidistantPoints(self, *args)

    def isDelta(self):
        r"""
        isDelta(DistributionTrapezoid self) -> bool
        bool DistributionTrapezoid::isDelta() const final

        Returns true if the distribution is in the limit case of a Dirac delta distribution. 

        """
        return _libBornAgainParam.DistributionTrapezoid_isDelta(self)

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

        Calls the  INodeVisitor's visit method. 

        """
        return _libBornAgainParam.DistributionTrapezoid_accept(self, visitor)
    __swig_destroy__ = _libBornAgainParam.delete_DistributionTrapezoid

# Register DistributionTrapezoid in _libBornAgainParam:
_libBornAgainParam.DistributionTrapezoid_swigregister(DistributionTrapezoid)

class ParameterDistribution(IParametricComponent):
    r"""


    A parametric distribution function, for use with any model parameter.

    C++ includes: ParameterDistribution.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__(ParameterDistribution self, std::string const & par_name, IDistribution1D distribution, size_t nbr_samples, double sigma_factor=0.0, RealLimits const & limits=RealLimits()) -> ParameterDistribution
        __init__(ParameterDistribution self, std::string const & par_name, IDistribution1D distribution, size_t nbr_samples, double xmin, double xmax) -> ParameterDistribution
        __init__(ParameterDistribution self, ParameterDistribution other) -> ParameterDistribution
        ParameterDistribution::ParameterDistribution(const ParameterDistribution &other)

        """
        _libBornAgainParam.ParameterDistribution_swiginit(self, _libBornAgainParam.new_ParameterDistribution(*args))
    __swig_destroy__ = _libBornAgainParam.delete_ParameterDistribution

    def linkParameter(self, par_name):
        r"""
        linkParameter(ParameterDistribution self, std::string par_name) -> ParameterDistribution
        ParameterDistribution & ParameterDistribution::linkParameter(std::string par_name)

        """
        return _libBornAgainParam.ParameterDistribution_linkParameter(self, par_name)

    def getMainParameterName(self):
        r"""
        getMainParameterName(ParameterDistribution self) -> std::string
        std::string ParameterDistribution::getMainParameterName() const

        get the main parameter's name 

        """
        return _libBornAgainParam.ParameterDistribution_getMainParameterName(self)

    def getNbrSamples(self):
        r"""
        getNbrSamples(ParameterDistribution self) -> size_t
        size_t ParameterDistribution::getNbrSamples() const

        get number of samples for this distribution 

        """
        return _libBornAgainParam.ParameterDistribution_getNbrSamples(self)

    def getSigmaFactor(self):
        r"""
        getSigmaFactor(ParameterDistribution self) -> double
        double ParameterDistribution::getSigmaFactor() const

        get the sigma factor 

        """
        return _libBornAgainParam.ParameterDistribution_getSigmaFactor(self)

    def getDistribution(self, *args):
        r"""
        getDistribution(ParameterDistribution self) -> IDistribution1D
        getDistribution(ParameterDistribution self) -> IDistribution1D
        IDistribution1D * ParameterDistribution::getDistribution()

        """
        return _libBornAgainParam.ParameterDistribution_getDistribution(self, *args)

    def generateSamples(self):
        r"""
        generateSamples(ParameterDistribution self) -> ParameterSampleVector
        std::vector< ParameterSample > ParameterDistribution::generateSamples() const

        generate list of sampled values with their weight 

        """
        return _libBornAgainParam.ParameterDistribution_generateSamples(self)

    def getLinkedParameterNames(self):
        r"""
        getLinkedParameterNames(ParameterDistribution self) -> vector_string_t
        std::vector<std::string> ParameterDistribution::getLinkedParameterNames() const

        get list of linked parameter names 

        """
        return _libBornAgainParam.ParameterDistribution_getLinkedParameterNames(self)

    def getLimits(self):
        r"""
        getLimits(ParameterDistribution self) -> RealLimits
        RealLimits ParameterDistribution::getLimits() const

        """
        return _libBornAgainParam.ParameterDistribution_getLimits(self)

    def getMinValue(self):
        r"""
        getMinValue(ParameterDistribution self) -> double
        double ParameterDistribution::getMinValue() const

        """
        return _libBornAgainParam.ParameterDistribution_getMinValue(self)

    def getMaxValue(self):
        r"""
        getMaxValue(ParameterDistribution self) -> double
        double ParameterDistribution::getMaxValue() const

        """
        return _libBornAgainParam.ParameterDistribution_getMaxValue(self)

# Register ParameterDistribution in _libBornAgainParam:
_libBornAgainParam.ParameterDistribution_swigregister(ParameterDistribution)

class RangedDistributionGate(object):
    r"""


    Uniform distribution function.

    C++ includes: RangedDistributions.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__(RangedDistributionGate self) -> RangedDistributionGate
        __init__(RangedDistributionGate self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionGate
        __init__(RangedDistributionGate self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionGate
        RangedDistributionGate::RangedDistributionGate(size_t n_samples, double sigma_factor, double min, double max)

        Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default  n_samples = 5,  sigma_factor = 2.0, while the limits are (-inf, +inf). 

        """
        _libBornAgainParam.RangedDistributionGate_swiginit(self, _libBornAgainParam.new_RangedDistributionGate(*args))

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

        """
        return _libBornAgainParam.RangedDistributionGate_clone(self)
    __swig_destroy__ = _libBornAgainParam.delete_RangedDistributionGate

    def name(self):
        r"""
        name(RangedDistributionGate self) -> std::string
        std::string RangedDistributionGate::name() const override

        Returns distribution name for python-formatted text. 

        """
        return _libBornAgainParam.RangedDistributionGate_name(self)

# Register RangedDistributionGate in _libBornAgainParam:
_libBornAgainParam.RangedDistributionGate_swigregister(RangedDistributionGate)

class RangedDistributionLorentz(object):
    r"""


    Lorentz distribution with median and hwhm.

    C++ includes: RangedDistributions.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__(RangedDistributionLorentz self) -> RangedDistributionLorentz
        __init__(RangedDistributionLorentz self, size_t n_samples, double hwhm_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionLorentz
        __init__(RangedDistributionLorentz self, size_t n_samples, double hwhm_factor, double min, double max) -> RangedDistributionLorentz
        RangedDistributionLorentz::RangedDistributionLorentz(size_t n_samples, double hwhm_factor, double min, double max)

        Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default  n_samples = 5,  hwhm_factor = 2.0, while the limits are (-inf, +inf). 

        """
        _libBornAgainParam.RangedDistributionLorentz_swiginit(self, _libBornAgainParam.new_RangedDistributionLorentz(*args))

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

        """
        return _libBornAgainParam.RangedDistributionLorentz_clone(self)
    __swig_destroy__ = _libBornAgainParam.delete_RangedDistributionLorentz

    def name(self):
        r"""
        name(RangedDistributionLorentz self) -> std::string
        std::string RangedDistributionLorentz::name() const override

        Returns distribution name for python-formatted text. 

        """
        return _libBornAgainParam.RangedDistributionLorentz_name(self)

# Register RangedDistributionLorentz in _libBornAgainParam:
_libBornAgainParam.RangedDistributionLorentz_swigregister(RangedDistributionLorentz)

class RangedDistributionGaussian(object):
    r"""


    Gaussian distribution with standard deviation std_dev.

    C++ includes: RangedDistributions.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__(RangedDistributionGaussian self) -> RangedDistributionGaussian
        __init__(RangedDistributionGaussian self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionGaussian
        __init__(RangedDistributionGaussian self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionGaussian
        RangedDistributionGaussian::RangedDistributionGaussian(size_t n_samples, double sigma_factor, double min, double max)

        Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default  n_samples = 5,  sigma_factor = 2.0, while the limits are (-inf, +inf). 

        """
        _libBornAgainParam.RangedDistributionGaussian_swiginit(self, _libBornAgainParam.new_RangedDistributionGaussian(*args))

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

        """
        return _libBornAgainParam.RangedDistributionGaussian_clone(self)
    __swig_destroy__ = _libBornAgainParam.delete_RangedDistributionGaussian

    def name(self):
        r"""
        name(RangedDistributionGaussian self) -> std::string
        std::string RangedDistributionGaussian::name() const override

        Returns distribution name for python-formatted text. 

        """
        return _libBornAgainParam.RangedDistributionGaussian_name(self)

# Register RangedDistributionGaussian in _libBornAgainParam:
_libBornAgainParam.RangedDistributionGaussian_swigregister(RangedDistributionGaussian)

class RangedDistributionLogNormal(object):
    r"""


    Log-normal distribution.

    C++ includes: RangedDistributions.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__(RangedDistributionLogNormal self) -> RangedDistributionLogNormal
        __init__(RangedDistributionLogNormal self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionLogNormal
        __init__(RangedDistributionLogNormal self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionLogNormal
        RangedDistributionLogNormal::RangedDistributionLogNormal(size_t n_samples, double sigma_factor, double min, double max)

        Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default  n_samples = 5,  sigma_factor = 2.0, while the limits are (-inf, +inf). 

        """
        _libBornAgainParam.RangedDistributionLogNormal_swiginit(self, _libBornAgainParam.new_RangedDistributionLogNormal(*args))

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

        """
        return _libBornAgainParam.RangedDistributionLogNormal_clone(self)
    __swig_destroy__ = _libBornAgainParam.delete_RangedDistributionLogNormal

    def name(self):
        r"""
        name(RangedDistributionLogNormal self) -> std::string
        std::string RangedDistributionLogNormal::name() const override

        Returns distribution name for python-formatted text. 

        """
        return _libBornAgainParam.RangedDistributionLogNormal_name(self)

# Register RangedDistributionLogNormal in _libBornAgainParam:
_libBornAgainParam.RangedDistributionLogNormal_swigregister(RangedDistributionLogNormal)

class RangedDistributionCosine(object):
    r"""


    Cosine distribution.

    C++ includes: RangedDistributions.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__(RangedDistributionCosine self) -> RangedDistributionCosine
        __init__(RangedDistributionCosine self, size_t n_samples, double sigma_factor, RealLimits const & limits=RealLimits::limitless()) -> RangedDistributionCosine
        __init__(RangedDistributionCosine self, size_t n_samples, double sigma_factor, double min, double max) -> RangedDistributionCosine
        RangedDistributionCosine::RangedDistributionCosine(size_t n_samples, double sigma_factor, double min, double max)

        Initializes Ranged distribution with given number of samples, sigma factor (range in standard deviations to take into account during sample generation) and limits (either RealLimits object or just min and max limits). By default  n_samples = 5,  sigma_factor = 2.0, while the limits are (-inf, +inf). 

        """
        _libBornAgainParam.RangedDistributionCosine_swiginit(self, _libBornAgainParam.new_RangedDistributionCosine(*args))

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

        """
        return _libBornAgainParam.RangedDistributionCosine_clone(self)
    __swig_destroy__ = _libBornAgainParam.delete_RangedDistributionCosine

    def name(self):
        r"""
        name(RangedDistributionCosine self) -> std::string
        std::string RangedDistributionCosine::name() const override

        Returns distribution name for python-formatted text. 

        """
        return _libBornAgainParam.RangedDistributionCosine_name(self)

# Register RangedDistributionCosine in _libBornAgainParam:
_libBornAgainParam.RangedDistributionCosine_swigregister(RangedDistributionCosine)

class ParameterSample(object):
    r"""


    A parameter value with a weight, as obtained when sampling from a distribution.

    C++ includes: ParameterSample.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, _value=0., _weight=1.):
        r"""
        __init__(ParameterSample self, double _value=0., double _weight=1.) -> ParameterSample
        ParameterSample::ParameterSample(double _value=0., double _weight=1.)

        """
        _libBornAgainParam.ParameterSample_swiginit(self, _libBornAgainParam.new_ParameterSample(_value, _weight))
    value = property(_libBornAgainParam.ParameterSample_value_get, _libBornAgainParam.ParameterSample_value_set, doc=r"""value : double""")
    weight = property(_libBornAgainParam.ParameterSample_weight_get, _libBornAgainParam.ParameterSample_weight_set, doc=r"""weight : double""")
    __swig_destroy__ = _libBornAgainParam.delete_ParameterSample

# Register ParameterSample in _libBornAgainParam:
_libBornAgainParam.ParameterSample_swigregister(ParameterSample)

class ParameterSampleVector(object):
    r"""Proxy of C++ std::vector< ParameterSample > 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(ParameterSampleVector self) -> SwigPyIterator"""
        return _libBornAgainParam.ParameterSampleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ParameterSampleVector self) -> bool"""
        return _libBornAgainParam.ParameterSampleVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ParameterSampleVector self) -> bool"""
        return _libBornAgainParam.ParameterSampleVector___bool__(self)

    def __len__(self):
        r"""__len__(ParameterSampleVector self) -> std::vector< ParameterSample >::size_type"""
        return _libBornAgainParam.ParameterSampleVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(ParameterSampleVector self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j) -> ParameterSampleVector"""
        return _libBornAgainParam.ParameterSampleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(ParameterSampleVector self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j)
        __setslice__(ParameterSampleVector self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j, ParameterSampleVector v)
        """
        return _libBornAgainParam.ParameterSampleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(ParameterSampleVector self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j)"""
        return _libBornAgainParam.ParameterSampleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(ParameterSampleVector self, std::vector< ParameterSample >::difference_type i)
        __delitem__(ParameterSampleVector self, PySliceObject * slice)
        """
        return _libBornAgainParam.ParameterSampleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ParameterSampleVector self, PySliceObject * slice) -> ParameterSampleVector
        __getitem__(ParameterSampleVector self, std::vector< ParameterSample >::difference_type i) -> ParameterSample
        """
        return _libBornAgainParam.ParameterSampleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ParameterSampleVector self, PySliceObject * slice, ParameterSampleVector v)
        __setitem__(ParameterSampleVector self, PySliceObject * slice)
        __setitem__(ParameterSampleVector self, std::vector< ParameterSample >::difference_type i, ParameterSample x)
        """
        return _libBornAgainParam.ParameterSampleVector___setitem__(self, *args)

    def pop(self):
        r"""pop(ParameterSampleVector self) -> ParameterSample"""
        return _libBornAgainParam.ParameterSampleVector_pop(self)

    def append(self, x):
        r"""append(ParameterSampleVector self, ParameterSample x)"""
        return _libBornAgainParam.ParameterSampleVector_append(self, x)

    def empty(self):
        r"""empty(ParameterSampleVector self) -> bool"""
        return _libBornAgainParam.ParameterSampleVector_empty(self)

    def size(self):
        r"""size(ParameterSampleVector self) -> std::vector< ParameterSample >::size_type"""
        return _libBornAgainParam.ParameterSampleVector_size(self)

    def swap(self, v):
        r"""swap(ParameterSampleVector self, ParameterSampleVector v)"""
        return _libBornAgainParam.ParameterSampleVector_swap(self, v)

    def begin(self):
        r"""begin(ParameterSampleVector self) -> std::vector< ParameterSample >::iterator"""
        return _libBornAgainParam.ParameterSampleVector_begin(self)

    def end(self):
        r"""end(ParameterSampleVector self) -> std::vector< ParameterSample >::iterator"""
        return _libBornAgainParam.ParameterSampleVector_end(self)

    def rbegin(self):
        r"""rbegin(ParameterSampleVector self) -> std::vector< ParameterSample >::reverse_iterator"""
        return _libBornAgainParam.ParameterSampleVector_rbegin(self)

    def rend(self):
        r"""rend(ParameterSampleVector self) -> std::vector< ParameterSample >::reverse_iterator"""
        return _libBornAgainParam.ParameterSampleVector_rend(self)

    def clear(self):
        r"""clear(ParameterSampleVector self)"""
        return _libBornAgainParam.ParameterSampleVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(ParameterSampleVector self) -> std::vector< ParameterSample >::allocator_type"""
        return _libBornAgainParam.ParameterSampleVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ParameterSampleVector self)"""
        return _libBornAgainParam.ParameterSampleVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(ParameterSampleVector self, std::vector< ParameterSample >::iterator pos) -> std::vector< ParameterSample >::iterator
        erase(ParameterSampleVector self, std::vector< ParameterSample >::iterator first, std::vector< ParameterSample >::iterator last) -> std::vector< ParameterSample >::iterator
        """
        return _libBornAgainParam.ParameterSampleVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ParameterSampleVector self) -> ParameterSampleVector
        __init__(ParameterSampleVector self, ParameterSampleVector other) -> ParameterSampleVector
        __init__(ParameterSampleVector self, std::vector< ParameterSample >::size_type size) -> ParameterSampleVector
        __init__(ParameterSampleVector self, std::vector< ParameterSample >::size_type size, ParameterSample value) -> ParameterSampleVector
        """
        _libBornAgainParam.ParameterSampleVector_swiginit(self, _libBornAgainParam.new_ParameterSampleVector(*args))

    def push_back(self, x):
        r"""push_back(ParameterSampleVector self, ParameterSample x)"""
        return _libBornAgainParam.ParameterSampleVector_push_back(self, x)

    def front(self):
        r"""front(ParameterSampleVector self) -> ParameterSample"""
        return _libBornAgainParam.ParameterSampleVector_front(self)

    def back(self):
        r"""back(ParameterSampleVector self) -> ParameterSample"""
        return _libBornAgainParam.ParameterSampleVector_back(self)

    def assign(self, n, x):
        r"""assign(ParameterSampleVector self, std::vector< ParameterSample >::size_type n, ParameterSample x)"""
        return _libBornAgainParam.ParameterSampleVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(ParameterSampleVector self, std::vector< ParameterSample >::size_type new_size)
        resize(ParameterSampleVector self, std::vector< ParameterSample >::size_type new_size, ParameterSample x)
        """
        return _libBornAgainParam.ParameterSampleVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ParameterSampleVector self, std::vector< ParameterSample >::iterator pos, ParameterSample x) -> std::vector< ParameterSample >::iterator
        insert(ParameterSampleVector self, std::vector< ParameterSample >::iterator pos, std::vector< ParameterSample >::size_type n, ParameterSample x)
        """
        return _libBornAgainParam.ParameterSampleVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(ParameterSampleVector self, std::vector< ParameterSample >::size_type n)"""
        return _libBornAgainParam.ParameterSampleVector_reserve(self, n)

    def capacity(self):
        r"""capacity(ParameterSampleVector self) -> std::vector< ParameterSample >::size_type"""
        return _libBornAgainParam.ParameterSampleVector_capacity(self)
    __swig_destroy__ = _libBornAgainParam.delete_ParameterSampleVector

# Register ParameterSampleVector in _libBornAgainParam:
_libBornAgainParam.ParameterSampleVector_swigregister(ParameterSampleVector)


class ParameterPoolIterator(object):

    def __init__(self, pool):
        self.pool = pool
        self.index = -1

    def __iter__(self):
        return self

    def next(self):
        self.index += 1
        if self.index < self.pool.size():
            return self.pool[self.index]
        else:
            raise StopIteration

    def __next__(self):
        return self.next()


