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

from sys import version_info as _swig_python_version_info
import _libBornAgainSample

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __bool__(self):
        r"""__bool__(vector_pvacuum_double_T self) -> bool"""
        return _libBornAgainSample.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 _libBornAgainSample.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 _libBornAgainSample.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 _libBornAgainSample.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 _libBornAgainSample.vector_pvacuum_double_T___delslice__(self, i, j)

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register vector_pvacuum_double_T in _libBornAgainSample:
_libBornAgainSample.vector_pvacuum_double_T_swigregister(vector_pvacuum_double_T)
import libBornAgainBase
class vector_R3(object):
    r"""Proxy of C++ std::vector< R3 > class."""

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

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

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

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

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

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

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

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

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

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

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

    def pop(self):
        r"""pop(vector_R3 self) -> std::vector< Vec3< double > >::value_type"""
        return _libBornAgainSample.vector_R3_pop(self)

    def append(self, x):
        r"""append(vector_R3 self, std::vector< Vec3< double > >::value_type const & x)"""
        return _libBornAgainSample.vector_R3_append(self, x)

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

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

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

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

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

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

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

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

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

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

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

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

    def push_back(self, x):
        r"""push_back(vector_R3 self, std::vector< Vec3< double > >::value_type const & x)"""
        return _libBornAgainSample.vector_R3_push_back(self, x)

    def front(self):
        r"""front(vector_R3 self) -> std::vector< Vec3< double > >::value_type const &"""
        return _libBornAgainSample.vector_R3_front(self)

    def back(self):
        r"""back(vector_R3 self) -> std::vector< Vec3< double > >::value_type const &"""
        return _libBornAgainSample.vector_R3_back(self)

    def assign(self, n, x):
        r"""assign(vector_R3 self, std::vector< Vec3< double > >::size_type n, std::vector< Vec3< double > >::value_type const & x)"""
        return _libBornAgainSample.vector_R3_assign(self, n, x)

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

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

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

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

# Register vector_R3 in _libBornAgainSample:
_libBornAgainSample.vector_R3_swigregister(vector_R3)
class RefractiveMaterial(object):
    r""" Material implementation based on refractive coefficiencts (valid for one wavelength value only)"""

    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__(RefractiveMaterial self, std::string const & name, MaterialColor const & color, double delta, double beta, R3 const & magnetization={}) -> RefractiveMaterial
        __init__(RefractiveMaterial self, std::string const & name, MaterialColor const & color, complex_t refr_idx, R3 const & magnetization={}) -> RefractiveMaterial
        """
        _libBornAgainSample.RefractiveMaterial_swiginit(self, _libBornAgainSample.new_RefractiveMaterial(*args))
    __swig_destroy__ = _libBornAgainSample.delete_RefractiveMaterial

# Register RefractiveMaterial in _libBornAgainSample:
_libBornAgainSample.RefractiveMaterial_swigregister(RefractiveMaterial)
class SLDMaterial(object):
    r""" Material implementation based on wavelength-independent data (valid for a range of wavelengths)"""

    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""" Constructs a wavelength-independent material with a given complex-valued scattering length density (SLD). SLD units are Å⁻²."""
        _libBornAgainSample.SLDMaterial_swiginit(self, _libBornAgainSample.new_SLDMaterial(*args))
    __swig_destroy__ = _libBornAgainSample.delete_SLDMaterial

# Register SLDMaterial in _libBornAgainSample:
_libBornAgainSample.SLDMaterial_swigregister(SLDMaterial)
class Vacuum(object):
    r""" The material with n=1."""

    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__(Vacuum self, std::string const & name="Vacuum") -> Vacuum"""
        _libBornAgainSample.Vacuum_swiginit(self, _libBornAgainSample.new_Vacuum(*args))
    __swig_destroy__ = _libBornAgainSample.delete_Vacuum

# Register Vacuum in _libBornAgainSample:
_libBornAgainSample.Vacuum_swigregister(Vacuum)
class Formfactor(object):
    r""" Abstract base class for Born form factors. In contrast to the generic IReParticle, a Born form factor does not depend on the incoming and outgoing wave vectors ki and kf, except through their difference, the scattering vector q=ki-kf."""

    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__ = _libBornAgainSample.delete_Formfactor

    def className(self):
        r"""className(Formfactor self) -> std::string"""
        return _libBornAgainSample.Formfactor_className(self)

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(Formfactor self, C3 q) -> complex_t"""
        return _libBornAgainSample.Formfactor_formfactorAtBottom(self, q)

    def volume(self):
        r"""volume(Formfactor self) -> double"""
        return _libBornAgainSample.Formfactor_volume(self)

# Register Formfactor in _libBornAgainSample:
_libBornAgainSample.Formfactor_swigregister(Formfactor)
class HardFormfactor(Formfactor):
    r""" Abstract base class for hard particle form factors with well-defined boundaries."""

    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__ = _libBornAgainSample.delete_HardFormfactor

# Register HardFormfactor in _libBornAgainSample:
_libBornAgainSample.HardFormfactor_swigregister(HardFormfactor)
class SoftFormfactor(Formfactor):
    r""" Abstract base class for soft particle form factors with diffuse boundaries. Soft particles have no well-defined boundary, so geometric containment tests are not meaningful."""

    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__ = _libBornAgainSample.delete_SoftFormfactor

# Register SoftFormfactor in _libBornAgainSample:
_libBornAgainSample.SoftFormfactor_swigregister(SoftFormfactor)
class Rotation(object):
    r""" Abstract base class for rotations."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def newRotation(matrix):
        r"""newRotation(RotMatrix const & matrix) -> Rotation"""
        return _libBornAgainSample.Rotation_newRotation(matrix)
    __swig_destroy__ = _libBornAgainSample.delete_Rotation

# Register Rotation in _libBornAgainSample:
_libBornAgainSample.Rotation_swigregister(Rotation)

def newProduct(left, right):
    r"""newProduct(Rotation left, Rotation right) -> Rotation"""
    return _libBornAgainSample.newProduct(left, right)
class IdentityRotation(Rotation):
    r""" The identity rotation, which leaves everything in place."""

    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__(IdentityRotation self) -> IdentityRotation"""
        _libBornAgainSample.IdentityRotation_swiginit(self, _libBornAgainSample.new_IdentityRotation())
    __swig_destroy__ = _libBornAgainSample.delete_IdentityRotation

# Register IdentityRotation in _libBornAgainSample:
_libBornAgainSample.IdentityRotation_swigregister(IdentityRotation)
class RotationX(Rotation):
    r""" A rotation about the x axis."""

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

    def __init__(self, angle):
        r"""__init__(RotationX self, double angle) -> RotationX"""
        _libBornAgainSample.RotationX_swiginit(self, _libBornAgainSample.new_RotationX(angle))
    __swig_destroy__ = _libBornAgainSample.delete_RotationX

# Register RotationX in _libBornAgainSample:
_libBornAgainSample.RotationX_swigregister(RotationX)
class RotationY(Rotation):
    r""" A rotation about the y axis."""

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

    def __init__(self, angle):
        r"""__init__(RotationY self, double angle) -> RotationY"""
        _libBornAgainSample.RotationY_swiginit(self, _libBornAgainSample.new_RotationY(angle))
    __swig_destroy__ = _libBornAgainSample.delete_RotationY

# Register RotationY in _libBornAgainSample:
_libBornAgainSample.RotationY_swigregister(RotationY)
class RotationZ(Rotation):
    r""" A rotation about the z axis."""

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

    def __init__(self, angle):
        r"""__init__(RotationZ self, double angle) -> RotationZ"""
        _libBornAgainSample.RotationZ_swiginit(self, _libBornAgainSample.new_RotationZ(angle))
    __swig_destroy__ = _libBornAgainSample.delete_RotationZ

# Register RotationZ in _libBornAgainSample:
_libBornAgainSample.RotationZ_swigregister(RotationZ)
class RotationEuler(Rotation):
    r""" A sequence of rotations about the z-x'-z'' axes."""

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

    def __init__(self, alpha, beta, gamma):
        r"""__init__(RotationEuler self, double alpha, double beta, double gamma) -> RotationEuler"""
        _libBornAgainSample.RotationEuler_swiginit(self, _libBornAgainSample.new_RotationEuler(alpha, beta, gamma))
    __swig_destroy__ = _libBornAgainSample.delete_RotationEuler

# Register RotationEuler in _libBornAgainSample:
_libBornAgainSample.RotationEuler_swigregister(RotationEuler)
class Crystal(object):
    r""" A crystal structure, defined by a Bravais lattice, a basis, and a position variance. Computations are delegated to class ReMesocrystal. Used in Mesocrystal, where it is given an outer shape."""

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

    def __init__(self, basis, lattice, position_variance=0):
        r"""__init__(Crystal self, IParticle basis, Lattice3D lattice, double position_variance=0) -> Crystal"""
        _libBornAgainSample.Crystal_swiginit(self, _libBornAgainSample.new_Crystal(basis, lattice, position_variance))
    __swig_destroy__ = _libBornAgainSample.delete_Crystal

# Register Crystal in _libBornAgainSample:
_libBornAgainSample.Crystal_swigregister(Crystal)
class IParticle(object):
    r""" Abstract base class for Particle, Compound, CoreAndShell, Mesocrystal, Mixture. Provides position/rotation and form factor."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_IParticle

    def translate(self, *args):
        r"""
        *Overload 1:*
        Translates the particle, and returns this.

        |

        *Overload 2:*
        Translates the particle, and returns this.
        """
        return _libBornAgainSample.IParticle_translate(self, *args)

    def rotate(self, rotation):
        r""" Rotates the particle, and returns this."""
        return _libBornAgainSample.IParticle_rotate(self, rotation)

    def height(self):
        r"""height(IParticle self) -> double"""
        return _libBornAgainSample.IParticle_height(self)

    def height_above_center(self):
        r"""height_above_center(IParticle self) -> double"""
        return _libBornAgainSample.IParticle_height_above_center(self)

    def height_below_center(self):
        r"""height_below_center(IParticle self) -> double"""
        return _libBornAgainSample.IParticle_height_below_center(self)

# Register IParticle in _libBornAgainSample:
_libBornAgainSample.IParticle_swigregister(IParticle)
class Mesocrystal(IParticle):
    r""" A particle with a crystalline inner structure, made of smaller particles, and an outer shape described by a particle form factor."""

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

    def __init__(self, crystal, formfactor):
        r"""__init__(Mesocrystal self, Crystal crystal, HardFormfactor formfactor) -> Mesocrystal"""
        _libBornAgainSample.Mesocrystal_swiginit(self, _libBornAgainSample.new_Mesocrystal(crystal, formfactor))
    __swig_destroy__ = _libBornAgainSample.delete_Mesocrystal

# Register Mesocrystal in _libBornAgainSample:
_libBornAgainSample.Mesocrystal_swigregister(Mesocrystal)
class Mixture(IParticle):
    r""" An uncorrelated random mixture of different particle types. Each particle type has a positive relative abundance, normalized internally. Unlike Compound, which coherently sums form factors of particles at fixed positions, Mixture represents an incoherent mixture where each particle type is handled separately in the scattering calculation. In showSample3D, each layout position displays one realization of this compositional disorder: one variant sampled by abundance. This is a visualization choice; the scattering calculation still uses the full ensemble."""

    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__(Mixture self) -> Mixture"""
        _libBornAgainSample.Mixture_swiginit(self, _libBornAgainSample.new_Mixture())
    __swig_destroy__ = _libBornAgainSample.delete_Mixture

    def addParticle(self, particle, abundance):
        r"""
         Adds a particle type with given abundance. :type particle: :py:class:`IParticle`
        :param particle: The particle to add :type abundance: float
        :param abundance: Relative weight of this particle type (must be positive)
        """
        return _libBornAgainSample.Mixture_addParticle(self, particle, abundance)

    def nbrParticles(self):
        r""" Returns number of different particle types"""
        return _libBornAgainSample.Mixture_nbrParticles(self)

# Register Mixture in _libBornAgainSample:
_libBornAgainSample.Mixture_swigregister(Mixture)
class Compound(IParticle):
    r""" A composition of particles at fixed positions"""

    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__(Compound self) -> Compound"""
        _libBornAgainSample.Compound_swiginit(self, _libBornAgainSample.new_Compound())
    __swig_destroy__ = _libBornAgainSample.delete_Compound

    def addComponent(self, *args):
        r"""
        addComponent(Compound self, IParticle particle)
        addComponent(Compound self, IParticle particle, R3 const & position)
        """
        return _libBornAgainSample.Compound_addComponent(self, *args)

    def addComponents(self, particle, positions):
        r"""addComponents(Compound self, IParticle particle, vector_R3 positions)"""
        return _libBornAgainSample.Compound_addComponents(self, particle, positions)

    def setRadius(self, radius):
        r"""setRadius(Compound self, double radius)"""
        return _libBornAgainSample.Compound_setRadius(self, radius)

# Register Compound in _libBornAgainSample:
_libBornAgainSample.Compound_swigregister(Compound)
class CoreAndShell(IParticle):
    r""" A particle with a core/shell geometry. The core may itself be a nested CoreAndShell to represent onion-like particles."""

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

    def __init__(self, core, shell):
        r"""__init__(CoreAndShell self, IParticle core, Particle shell) -> CoreAndShell"""
        _libBornAgainSample.CoreAndShell_swiginit(self, _libBornAgainSample.new_CoreAndShell(core, shell))
    __swig_destroy__ = _libBornAgainSample.delete_CoreAndShell

# Register CoreAndShell in _libBornAgainSample:
_libBornAgainSample.CoreAndShell_swigregister(CoreAndShell)
class Profile1D(object):
    r""" Interface for a one-dimensional distribution, with normalization adjusted so that the Fourier transform standardizedFT(q) is a decay function that starts at standardizedFT(0)=1."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_Profile1D

# Register Profile1D in _libBornAgainSample:
_libBornAgainSample.Profile1D_swigregister(Profile1D)
class Profile1DCauchy(Profile1D):
    r""" Exponential Profile1D exp(-|omega*x|); its Fourier transform standardizedFT(q) is a Cauchy-Lorentzian starting at standardizedFT(0)=1."""

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

    def __init__(self, omega):
        r"""__init__(Profile1DCauchy self, double omega) -> Profile1DCauchy"""
        _libBornAgainSample.Profile1DCauchy_swiginit(self, _libBornAgainSample.new_Profile1DCauchy(omega))
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DCauchy

# Register Profile1DCauchy in _libBornAgainSample:
_libBornAgainSample.Profile1DCauchy_swigregister(Profile1DCauchy)
class Profile1DGauss(Profile1D):
    r""" Gaussian Profile1D; its Fourier transform standardizedFT(q) is a Gaussian starting at standardizedFT(0)=1."""

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

    def __init__(self, omega):
        r"""__init__(Profile1DGauss self, double omega) -> Profile1DGauss"""
        _libBornAgainSample.Profile1DGauss_swiginit(self, _libBornAgainSample.new_Profile1DGauss(omega))
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DGauss

# Register Profile1DGauss in _libBornAgainSample:
_libBornAgainSample.Profile1DGauss_swigregister(Profile1DGauss)
class Profile1DGate(Profile1D):
    r""" Square gate Profile1D; its Fourier transform standardizedFT(q) is a sinc function starting at standardizedFT(0)=1."""

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

    def __init__(self, omega):
        r"""__init__(Profile1DGate self, double omega) -> Profile1DGate"""
        _libBornAgainSample.Profile1DGate_swiginit(self, _libBornAgainSample.new_Profile1DGate(omega))
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DGate

# Register Profile1DGate in _libBornAgainSample:
_libBornAgainSample.Profile1DGate_swigregister(Profile1DGate)
class Profile1DTriangle(Profile1D):
    r""" Triangle Profile1D [1-|x|/omega if |x|<omega, and 0 otherwise]; its Fourier transform standardizedFT(q) is a squared sinc function starting at standardizedFT(0)=1."""

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

    def __init__(self, omega):
        r"""__init__(Profile1DTriangle self, double omega) -> Profile1DTriangle"""
        _libBornAgainSample.Profile1DTriangle_swiginit(self, _libBornAgainSample.new_Profile1DTriangle(omega))
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DTriangle

# Register Profile1DTriangle in _libBornAgainSample:
_libBornAgainSample.Profile1DTriangle_swigregister(Profile1DTriangle)
class Profile1DCosine(Profile1D):
    r""" Profile1D consisting of one cosine wave [1+cos(pi*x/omega) if |x|<omega, and 0 otherwise]; its Fourier transform standardizedFT(q) starts at standardizedFT(0)=1."""

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

    def __init__(self, omega):
        r"""__init__(Profile1DCosine self, double omega) -> Profile1DCosine"""
        _libBornAgainSample.Profile1DCosine_swiginit(self, _libBornAgainSample.new_Profile1DCosine(omega))
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DCosine

# Register Profile1DCosine in _libBornAgainSample:
_libBornAgainSample.Profile1DCosine_swigregister(Profile1DCosine)
class Profile1DVoigt(Profile1D):
    r""" Profile1D that provides a Fourier transform standardizedFT(q) in form of a pseudo-Voigt decay function eta*Gauss + (1-eta)*Cauchy, with both components starting at 1 for q=0."""

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

    def __init__(self, omega, eta):
        r"""__init__(Profile1DVoigt self, double omega, double eta) -> Profile1DVoigt"""
        _libBornAgainSample.Profile1DVoigt_swiginit(self, _libBornAgainSample.new_Profile1DVoigt(omega, eta))
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DVoigt

# Register Profile1DVoigt in _libBornAgainSample:
_libBornAgainSample.Profile1DVoigt_swigregister(Profile1DVoigt)
class Profile2D(object):
    r""" Interface for two-dimensional distributions in Fourier space."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_Profile2D

# Register Profile2D in _libBornAgainSample:
_libBornAgainSample.Profile2D_swigregister(Profile2D)
class Profile2DCauchy(Profile2D):
    r""" Two-dimensional Cauchy distribution in Fourier space; corresponds to a normalized exp(-r) in real space, with =(_x})^2 + (_y})^2}:math:`.`"""

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

    def __init__(self, omega_x, omega_y, gamma):
        r"""__init__(Profile2DCauchy self, double omega_x, double omega_y, double gamma) -> Profile2DCauchy"""
        _libBornAgainSample.Profile2DCauchy_swiginit(self, _libBornAgainSample.new_Profile2DCauchy(omega_x, omega_y, gamma))
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DCauchy

# Register Profile2DCauchy in _libBornAgainSample:
_libBornAgainSample.Profile2DCauchy_swigregister(Profile2DCauchy)
class Profile2DGauss(Profile2D):
    r""" Two-dimensional Gauss distribution in Fourier space; corresponds to normalized exp(-r^2/2) in real space with =(_x})^2 + (_y})^2}:math:`.`"""

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

    def __init__(self, omega_x, omega_y, gamma):
        r"""__init__(Profile2DGauss self, double omega_x, double omega_y, double gamma) -> Profile2DGauss"""
        _libBornAgainSample.Profile2DGauss_swiginit(self, _libBornAgainSample.new_Profile2DGauss(omega_x, omega_y, gamma))
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DGauss

# Register Profile2DGauss in _libBornAgainSample:
_libBornAgainSample.Profile2DGauss_swigregister(Profile2DGauss)
class Profile2DGate(Profile2D):
    r""" Two-dimensional gate distribution in Fourier space; corresponds to normalized constant if r<1 (and 0 otherwise) in real space, with =(_x})^2 + (_y})^2}:math:`.`"""

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

    def __init__(self, omega_x, omega_y, gamma):
        r"""__init__(Profile2DGate self, double omega_x, double omega_y, double gamma) -> Profile2DGate"""
        _libBornAgainSample.Profile2DGate_swiginit(self, _libBornAgainSample.new_Profile2DGate(omega_x, omega_y, gamma))
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DGate

# Register Profile2DGate in _libBornAgainSample:
_libBornAgainSample.Profile2DGate_swigregister(Profile2DGate)
class Profile2DCone(Profile2D):
    r""" Two-dimensional cone distribution in Fourier space; corresponds to 1-r if r<1 (and 0 otherwise) in real space with =(_x})^2 + (_y})^2}:math:`.`"""

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

    def __init__(self, omega_x, omega_y, gamma):
        r"""__init__(Profile2DCone self, double omega_x, double omega_y, double gamma) -> Profile2DCone"""
        _libBornAgainSample.Profile2DCone_swiginit(self, _libBornAgainSample.new_Profile2DCone(omega_x, omega_y, gamma))
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DCone

# Register Profile2DCone in _libBornAgainSample:
_libBornAgainSample.Profile2DCone_swigregister(Profile2DCone)
class Profile2DVoigt(Profile2D):
    r""" Two-dimensional Voigt distribution in Fourier space; corresponds to eta*Gauss + (1-eta)*Cauchy"""

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

    def __init__(self, omega_x, omega_y, gamma, eta):
        r"""__init__(Profile2DVoigt self, double omega_x, double omega_y, double gamma, double eta) -> Profile2DVoigt"""
        _libBornAgainSample.Profile2DVoigt_swiginit(self, _libBornAgainSample.new_Profile2DVoigt(omega_x, omega_y, gamma, eta))
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DVoigt

# Register Profile2DVoigt in _libBornAgainSample:
_libBornAgainSample.Profile2DVoigt_swigregister(Profile2DVoigt)
class PeakShape(object):
    r""" Abstract base class class that defines the peak shape of a Bragg peak."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_PeakShape

# Register PeakShape in _libBornAgainSample:
_libBornAgainSample.PeakShape_swigregister(PeakShape)
class IsotropicGaussPeakShape(PeakShape):
    r""" Class that implements an isotropic Gaussian peak shape of a Bragg peak."""

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

    def __init__(self, max_intensity, domainsize):
        r"""__init__(IsotropicGaussPeakShape self, double max_intensity, double domainsize) -> IsotropicGaussPeakShape"""
        _libBornAgainSample.IsotropicGaussPeakShape_swiginit(self, _libBornAgainSample.new_IsotropicGaussPeakShape(max_intensity, domainsize))
    __swig_destroy__ = _libBornAgainSample.delete_IsotropicGaussPeakShape

# Register IsotropicGaussPeakShape in _libBornAgainSample:
_libBornAgainSample.IsotropicGaussPeakShape_swigregister(IsotropicGaussPeakShape)
class IsotropicLorentzPeakShape(PeakShape):
    r""" An isotropic Lorentzian peak shape of a Bragg peak."""

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

    def __init__(self, max_intensity, domainsize):
        r"""__init__(IsotropicLorentzPeakShape self, double max_intensity, double domainsize) -> IsotropicLorentzPeakShape"""
        _libBornAgainSample.IsotropicLorentzPeakShape_swiginit(self, _libBornAgainSample.new_IsotropicLorentzPeakShape(max_intensity, domainsize))
    __swig_destroy__ = _libBornAgainSample.delete_IsotropicLorentzPeakShape

# Register IsotropicLorentzPeakShape in _libBornAgainSample:
_libBornAgainSample.IsotropicLorentzPeakShape_swigregister(IsotropicLorentzPeakShape)
class GaussFisherPeakShape(PeakShape):
    r""" A peak shape that is Gaussian in the radial direction and uses the Mises-Fisher distribution in the angular direction."""

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

    def __init__(self, max_intensity, radial_size, kappa):
        r"""__init__(GaussFisherPeakShape self, double max_intensity, double radial_size, double kappa) -> GaussFisherPeakShape"""
        _libBornAgainSample.GaussFisherPeakShape_swiginit(self, _libBornAgainSample.new_GaussFisherPeakShape(max_intensity, radial_size, kappa))
    __swig_destroy__ = _libBornAgainSample.delete_GaussFisherPeakShape

# Register GaussFisherPeakShape in _libBornAgainSample:
_libBornAgainSample.GaussFisherPeakShape_swigregister(GaussFisherPeakShape)
class LorentzFisherPeakShape(PeakShape):
    r""" A peak shape that is Lorentzian in the radial direction and uses the Mises-Fisher distribution in the angular direction."""

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

    def __init__(self, max_intensity, radial_size, kappa):
        r"""__init__(LorentzFisherPeakShape self, double max_intensity, double radial_size, double kappa) -> LorentzFisherPeakShape"""
        _libBornAgainSample.LorentzFisherPeakShape_swiginit(self, _libBornAgainSample.new_LorentzFisherPeakShape(max_intensity, radial_size, kappa))
    __swig_destroy__ = _libBornAgainSample.delete_LorentzFisherPeakShape

# Register LorentzFisherPeakShape in _libBornAgainSample:
_libBornAgainSample.LorentzFisherPeakShape_swigregister(LorentzFisherPeakShape)
class MisesFisherGaussPeakShape(PeakShape):
    r""" A peak shape that is Gaussian in the radial direction and a convolution of a Mises-Fisher distribution with a Mises distribution on the two-sphere."""

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

    def __init__(self, max_intensity, radial_size, zenith, kappa_1, kappa_2):
        r"""__init__(MisesFisherGaussPeakShape self, double max_intensity, double radial_size, R3 const & zenith, double kappa_1, double kappa_2) -> MisesFisherGaussPeakShape"""
        _libBornAgainSample.MisesFisherGaussPeakShape_swiginit(self, _libBornAgainSample.new_MisesFisherGaussPeakShape(max_intensity, radial_size, zenith, kappa_1, kappa_2))
    __swig_destroy__ = _libBornAgainSample.delete_MisesFisherGaussPeakShape

# Register MisesFisherGaussPeakShape in _libBornAgainSample:
_libBornAgainSample.MisesFisherGaussPeakShape_swigregister(MisesFisherGaussPeakShape)
class MisesGaussPeakShape(PeakShape):
    r""" A peak shape that is a convolution of a Mises-Fisher distribution with a 3d Gaussian."""

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

    def __init__(self, max_intensity, radial_size, zenith, kappa):
        r"""__init__(MisesGaussPeakShape self, double max_intensity, double radial_size, R3 const & zenith, double kappa) -> MisesGaussPeakShape"""
        _libBornAgainSample.MisesGaussPeakShape_swiginit(self, _libBornAgainSample.new_MisesGaussPeakShape(max_intensity, radial_size, zenith, kappa))
    __swig_destroy__ = _libBornAgainSample.delete_MisesGaussPeakShape

# Register MisesGaussPeakShape in _libBornAgainSample:
_libBornAgainSample.MisesGaussPeakShape_swigregister(MisesGaussPeakShape)
class Struct(object):
    r"""Proxy of C++ Struct 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

    def className(self):
        r"""className(Struct self) -> std::string"""
        return _libBornAgainSample.Struct_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_Struct

# Register Struct in _libBornAgainSample:
_libBornAgainSample.Struct_swigregister(Struct)
class Struct2D(Struct):
    r"""Proxy of C++ Struct2D 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__ = _libBornAgainSample.delete_Struct2D

# Register Struct2D in _libBornAgainSample:
_libBornAgainSample.Struct2D_swigregister(Struct2D)
class Struct3D(Struct):
    r"""Proxy of C++ Struct3D 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__ = _libBornAgainSample.delete_Struct3D

# Register Struct3D in _libBornAgainSample:
_libBornAgainSample.Struct3D_swigregister(Struct3D)
class Disordered2D(Struct2D):
    r""" Disordered 2D particle assembly with a given area number density."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_Disordered2D

    def className(self):
        r"""className(Disordered2D self) -> std::string"""
        return _libBornAgainSample.Disordered2D_className(self)

# Register Disordered2D in _libBornAgainSample:
_libBornAgainSample.Disordered2D_swigregister(Disordered2D)
class Disordered3D(Struct3D):
    r""" Disordered 3D particle assembly with a given volume number density."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_Disordered3D

    def className(self):
        r"""className(Disordered3D self) -> std::string"""
        return _libBornAgainSample.Disordered3D_className(self)

# Register Disordered3D in _libBornAgainSample:
_libBornAgainSample.Disordered3D_swigregister(Disordered3D)
class Dilute2D(Disordered2D):
    r""" Disordered 2D particle structure with dilute approximation (no inter-particle correlations)."""

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

    def __init__(self, area_density, particle):
        r"""__init__(Dilute2D self, double area_density, IParticle particle) -> Dilute2D"""
        _libBornAgainSample.Dilute2D_swiginit(self, _libBornAgainSample.new_Dilute2D(area_density, particle))
    __swig_destroy__ = _libBornAgainSample.delete_Dilute2D

    def className(self):
        r"""className(Dilute2D self) -> std::string"""
        return _libBornAgainSample.Dilute2D_className(self)

# Register Dilute2D in _libBornAgainSample:
_libBornAgainSample.Dilute2D_swigregister(Dilute2D)
class Dense2D(Disordered2D):
    r""" Disordered 2D particle structure with Percus-Yevick hard disk approximation."""

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

    def __init__(self, area_density, particle):
        r"""__init__(Dense2D self, double area_density, IParticle particle) -> Dense2D"""
        _libBornAgainSample.Dense2D_swiginit(self, _libBornAgainSample.new_Dense2D(area_density, particle))
    __swig_destroy__ = _libBornAgainSample.delete_Dense2D

    def className(self):
        r"""className(Dense2D self) -> std::string"""
        return _libBornAgainSample.Dense2D_className(self)

# Register Dense2D in _libBornAgainSample:
_libBornAgainSample.Dense2D_swigregister(Dense2D)
class Dilute3D(Disordered3D):
    r""" Disordered 3D particle structure with dilute approximation (no inter-particle correlations)."""

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

    def __init__(self, volume_density, particle):
        r"""__init__(Dilute3D self, double volume_density, IParticle particle) -> Dilute3D"""
        _libBornAgainSample.Dilute3D_swiginit(self, _libBornAgainSample.new_Dilute3D(volume_density, particle))
    __swig_destroy__ = _libBornAgainSample.delete_Dilute3D

    def className(self):
        r"""className(Dilute3D self) -> std::string"""
        return _libBornAgainSample.Dilute3D_className(self)

# Register Dilute3D in _libBornAgainSample:
_libBornAgainSample.Dilute3D_swigregister(Dilute3D)
class Ordered2D(Struct2D):
    r""" Abstract base class of interference functions."""

    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__ = _libBornAgainSample.delete_Ordered2D

# Register Ordered2D in _libBornAgainSample:
_libBornAgainSample.Ordered2D_swigregister(Ordered2D)
class ICrystal2D(Ordered2D):
    r""" Abstract base for infinite and finite 2D lattice structures."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_ICrystal2D

    def setIntegrationOverXi(self, integrate_xi):
        r"""setIntegrationOverXi(ICrystal2D self, bool integrate_xi)"""
        return _libBornAgainSample.ICrystal2D_setIntegrationOverXi(self, integrate_xi)

    def className(self):
        r"""className(ICrystal2D self) -> std::string"""
        return _libBornAgainSample.ICrystal2D_className(self)

# Register ICrystal2D in _libBornAgainSample:
_libBornAgainSample.ICrystal2D_swigregister(ICrystal2D)
class LongRangeOrdered2D(Ordered2D):
    r""" Base class for crystal-like long-range order planar structures. Contains in-plane position variance."""

    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__ = _libBornAgainSample.delete_LongRangeOrdered2D

    def setLateralPositionVariance(self, var):
        r""" Sets the variance of the lateral position for the calculation of the DW factor It is defined as the rms variance in each relevant dimension"""
        return _libBornAgainSample.LongRangeOrdered2D_setLateralPositionVariance(self, var)

# Register LongRangeOrdered2D in _libBornAgainSample:
_libBornAgainSample.LongRangeOrdered2D_swigregister(LongRangeOrdered2D)
class Crystal1D(LongRangeOrdered2D):
    r""" Interference function of a 1D crystal. Contains lateral position variance which is gived in "2D", not just along the lattice => uses 2D Debye-Waller factor."""

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

    def __init__(self, particle, length, xi, linear_density):
        r"""__init__(Crystal1D self, IParticle particle, double length, double xi, double linear_density) -> Crystal1D"""
        _libBornAgainSample.Crystal1D_swiginit(self, _libBornAgainSample.new_Crystal1D(particle, length, xi, linear_density))
    __swig_destroy__ = _libBornAgainSample.delete_Crystal1D

    def setDecayFunction(self, decay):
        r"""setDecayFunction(Crystal1D self, Profile1D decay)"""
        return _libBornAgainSample.Crystal1D_setDecayFunction(self, decay)

    def className(self):
        r"""className(Crystal1D self) -> std::string"""
        return _libBornAgainSample.Crystal1D_className(self)

# Register Crystal1D in _libBornAgainSample:
_libBornAgainSample.Crystal1D_swigregister(Crystal1D)
class Crystal2D(LongRangeOrdered2D, ICrystal2D):
    r""" Interference function of an infinite 2D crystal."""

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

    def __init__(self, particle, lattice):
        r"""__init__(Crystal2D self, IParticle particle, Lattice2D lattice) -> Crystal2D"""
        _libBornAgainSample.Crystal2D_swiginit(self, _libBornAgainSample.new_Crystal2D(particle, lattice))
    __swig_destroy__ = _libBornAgainSample.delete_Crystal2D

    def setDecayFunction(self, decay):
        r"""setDecayFunction(Crystal2D self, Profile2D decay)"""
        return _libBornAgainSample.Crystal2D_setDecayFunction(self, decay)

    def className(self):
        r"""className(Crystal2D self) -> std::string"""
        return _libBornAgainSample.Crystal2D_className(self)

# Register Crystal2D in _libBornAgainSample:
_libBornAgainSample.Crystal2D_swigregister(Crystal2D)
class Paracrystal2D(ICrystal2D):
    r""" Interference function of a 2D paracrystal."""

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

    def __init__(self, particle, lattice, damping_length, domain_size_1, domain_size_2):
        r"""__init__(Paracrystal2D self, IParticle particle, Lattice2D lattice, double damping_length, double domain_size_1, double domain_size_2) -> Paracrystal2D"""
        _libBornAgainSample.Paracrystal2D_swiginit(self, _libBornAgainSample.new_Paracrystal2D(particle, lattice, damping_length, domain_size_1, domain_size_2))
    __swig_destroy__ = _libBornAgainSample.delete_Paracrystal2D

    def setDomainSizes(self, size_1, size_2):
        r"""setDomainSizes(Paracrystal2D self, double size_1, double size_2)"""
        return _libBornAgainSample.Paracrystal2D_setDomainSizes(self, size_1, size_2)

    def setProbabilityDistributions(self, pdf_1, pdf_2):
        r"""setProbabilityDistributions(Paracrystal2D self, Profile2D pdf_1, Profile2D pdf_2)"""
        return _libBornAgainSample.Paracrystal2D_setProbabilityDistributions(self, pdf_1, pdf_2)

    def setDampingLength(self, damping_length):
        r"""setDampingLength(Paracrystal2D self, double damping_length)"""
        return _libBornAgainSample.Paracrystal2D_setDampingLength(self, damping_length)

    def className(self):
        r"""className(Paracrystal2D self) -> std::string"""
        return _libBornAgainSample.Paracrystal2D_className(self)

# Register Paracrystal2D in _libBornAgainSample:
_libBornAgainSample.Paracrystal2D_swigregister(Paracrystal2D)
class FiniteCrystal2D(LongRangeOrdered2D, ICrystal2D):
    r""" Interference function of a finite 2D crystal."""

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

    def __init__(self, particle, lattice, N_1, N_2):
        r"""__init__(FiniteCrystal2D self, IParticle particle, Lattice2D lattice, unsigned int N_1, unsigned int N_2) -> FiniteCrystal2D"""
        _libBornAgainSample.FiniteCrystal2D_swiginit(self, _libBornAgainSample.new_FiniteCrystal2D(particle, lattice, N_1, N_2))
    __swig_destroy__ = _libBornAgainSample.delete_FiniteCrystal2D

    def className(self):
        r"""className(FiniteCrystal2D self) -> std::string"""
        return _libBornAgainSample.FiniteCrystal2D_className(self)

# Register FiniteCrystal2D in _libBornAgainSample:
_libBornAgainSample.FiniteCrystal2D_swigregister(FiniteCrystal2D)
class RadialParacrystal(Ordered2D):
    r""" Interference function of radial paracrystal."""

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

    def __init__(self, particle, peak_distance, damping_length):
        r"""__init__(RadialParacrystal self, IParticle particle, double peak_distance, double damping_length) -> RadialParacrystal"""
        _libBornAgainSample.RadialParacrystal_swiginit(self, _libBornAgainSample.new_RadialParacrystal(particle, peak_distance, damping_length))
    __swig_destroy__ = _libBornAgainSample.delete_RadialParacrystal

    def setKappa(self, kappa):
        r"""setKappa(RadialParacrystal self, double kappa)"""
        return _libBornAgainSample.RadialParacrystal_setKappa(self, kappa)

    def setDomainSize(self, size):
        r"""setDomainSize(RadialParacrystal self, double size)"""
        return _libBornAgainSample.RadialParacrystal_setDomainSize(self, size)

    def setProbabilityDistribution(self, pdf):
        r"""setProbabilityDistribution(RadialParacrystal self, Profile1D pdf)"""
        return _libBornAgainSample.RadialParacrystal_setProbabilityDistribution(self, pdf)

    def className(self):
        r"""className(RadialParacrystal self) -> std::string"""
        return _libBornAgainSample.RadialParacrystal_className(self)

# Register RadialParacrystal in _libBornAgainSample:
_libBornAgainSample.RadialParacrystal_swigregister(RadialParacrystal)
class Roughness(object):
    r""" A roughness of interface between two layers. Based on the article "X-ray reflection and transmission by rough surfaces" by D. K. G. de Boer, Physical Review B 51, 5297 (1995)"""

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

    def __init__(self, autocorrelation, transient, crosscorrelation=None):
        r"""__init__(Roughness self, AutocorrelationModel autocorrelation, TransientModel transient, CrosscorrelationModel crosscorrelation=None) -> Roughness"""
        _libBornAgainSample.Roughness_swiginit(self, _libBornAgainSample.new_Roughness(autocorrelation, transient, crosscorrelation))
    __swig_destroy__ = _libBornAgainSample.delete_Roughness

# Register Roughness in _libBornAgainSample:
_libBornAgainSample.Roughness_swigregister(Roughness)
class ILayer(object):
    r""" Common base for layers and stacks."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_ILayer

# Register ILayer in _libBornAgainSample:
_libBornAgainSample.ILayer_swigregister(ILayer)
class PlainLayer(object):
    r""" Common base for Layer%s and Slice%s."""

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

    def __init__(self, material, thickness, roughness=None):
        r"""__init__(PlainLayer self, Material const & material, double thickness, Roughness roughness=None) -> PlainLayer"""
        _libBornAgainSample.PlainLayer_swiginit(self, _libBornAgainSample.new_PlainLayer(material, thickness, roughness))
    __swig_destroy__ = _libBornAgainSample.delete_PlainLayer

# Register PlainLayer in _libBornAgainSample:
_libBornAgainSample.PlainLayer_swigregister(PlainLayer)
class Layer(PlainLayer, ILayer):
    r""" A layer in a multilayer Sample."""

    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__(Layer self, Material const & material, double thickness, Roughness roughness=None) -> Layer
        __init__(Layer self, Material const & material, Roughness roughness=None) -> Layer
        """
        _libBornAgainSample.Layer_swiginit(self, _libBornAgainSample.new_Layer(*args))
    __swig_destroy__ = _libBornAgainSample.delete_Layer

    def deposit2D(self, structure):
        r"""deposit2D(Layer self, Struct2D structure)"""
        return _libBornAgainSample.Layer_deposit2D(self, structure)

    def addDeposit2D(self, coverage, structure):
        r"""addDeposit2D(Layer self, double coverage, Struct2D structure)"""
        return _libBornAgainSample.Layer_addDeposit2D(self, coverage, structure)

    def suspend2D(self, structure):
        r"""suspend2D(Layer self, Struct2D structure)"""
        return _libBornAgainSample.Layer_suspend2D(self, structure)

    def addSuspend2D(self, coverage, structure):
        r"""addSuspend2D(Layer self, double coverage, Struct2D structure)"""
        return _libBornAgainSample.Layer_addSuspend2D(self, coverage, structure)

    def fill3D(self, structure):
        r"""fill3D(Layer self, Struct3D structure)"""
        return _libBornAgainSample.Layer_fill3D(self, structure)

    def add3D(self, coverage, structure):
        r"""add3D(Layer self, double coverage, Struct3D structure)"""
        return _libBornAgainSample.Layer_add3D(self, coverage, structure)

    def setNumberOfSlices(self, n_slices):
        r"""setNumberOfSlices(Layer self, unsigned int n_slices)"""
        return _libBornAgainSample.Layer_setNumberOfSlices(self, n_slices)

# Register Layer in _libBornAgainSample:
_libBornAgainSample.Layer_swigregister(Layer)
class LayerStack(ILayer):
    r"""Proxy of C++ LayerStack 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, num_periods=1):
        r"""__init__(LayerStack self, size_t num_periods=1) -> LayerStack"""
        _libBornAgainSample.LayerStack_swiginit(self, _libBornAgainSample.new_LayerStack(num_periods))
    __swig_destroy__ = _libBornAgainSample.delete_LayerStack

    def addLayer(self, layer):
        r"""addLayer(LayerStack self, Layer layer)"""
        return _libBornAgainSample.LayerStack_addLayer(self, layer)

    def addStack(self, substack):
        r"""addStack(LayerStack self, LayerStack substack)"""
        return _libBornAgainSample.LayerStack_addStack(self, substack)

# Register LayerStack in _libBornAgainSample:
_libBornAgainSample.LayerStack_swigregister(LayerStack)
class RoughnessMap(object):
    r""" Generation of random rough surface with given both spectrum and height statistics. Accepts not just the roughness model of the chosen interface, but the whole underlying part of sample because of roughness replication. Algorithm by Pérez-Ràfols & Almqvist, Tribology International 131, 591-604 (2019) https://doi.org/10.1016/j.triboint.2018.11.020"""

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

    @staticmethod
    def generateInterfaceMaps(x_points, y_points, Lx, Ly, sample, interface_indices, seed=0):
        r""" Generates selected rough interface maps and returns them in the requested order."""
        return _libBornAgainSample.RoughnessMap_generateInterfaceMaps(x_points, y_points, Lx, Ly, sample, interface_indices, seed)

    def __init__(self, x_points, y_points, Lx, Ly, sample, i_layer, seed=0):
        r"""__init__(RoughnessMap self, size_t x_points, size_t y_points, double Lx, double Ly, Sample sample, size_t i_layer, unsigned int seed=0) -> RoughnessMap"""
        _libBornAgainSample.RoughnessMap_swiginit(self, _libBornAgainSample.new_RoughnessMap(x_points, y_points, Lx, Ly, sample, i_layer, seed))

    def generateMap(self):
        r""" Generates one rough interface with the requested auto-spectrum and height statistics."""
        return _libBornAgainSample.RoughnessMap_generateMap(self)

    def generate(self, *args):
        _arrayf64Wrapper = _libBornAgainSample.RoughnessMap_generate(self, *args)  # call the original SWIG-generated method
        return _arrayf64Wrapper.to_numpy()


    __swig_destroy__ = _libBornAgainSample.delete_RoughnessMap

# Register RoughnessMap in _libBornAgainSample:
_libBornAgainSample.RoughnessMap_swigregister(RoughnessMap)

def _RoughnessMap_generateInterfaceMaps(x_points, y_points, Lx, Ly, sample, interface_indices,
                                        seed=0):
    _arrayf64Wrapper = _libBornAgainSample.RoughnessMap_generateInterfaceMaps(
        x_points, y_points, Lx, Ly, sample, interface_indices, seed)
    return _arrayf64Wrapper.to_numpy()

RoughnessMap.generateInterfaceMaps = staticmethod(_RoughnessMap_generateInterfaceMaps)

class Sample(object):
    r""" Our sample model: a stack of layers one below the other. Example of system of 4 layers (3 interfaces):  vacuum      layer 0 ---------   interface 0    z=0.0 Fe, 20A     layer 1 ---------   interface 1    z=-20.0 Cr, 40A     layer 2 ---------   interface 2    z=-60.0 substrate   layer 3"""

    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__(Sample self) -> Sample"""
        _libBornAgainSample.Sample_swiginit(self, _libBornAgainSample.new_Sample())
    __swig_destroy__ = _libBornAgainSample.delete_Sample

    def addLayer(self, layer):
        r"""addLayer(Sample self, Layer layer)"""
        return _libBornAgainSample.Sample_addLayer(self, layer)

    def addStack(self, substack):
        r"""addStack(Sample self, LayerStack substack)"""
        return _libBornAgainSample.Sample_addStack(self, substack)

    def setExternalField(self, ext_field):
        r""" Sets the external field applied to the sample (units: A/m)"""
        return _libBornAgainSample.Sample_setExternalField(self, ext_field)

# Register Sample in _libBornAgainSample:
_libBornAgainSample.Sample_swigregister(Sample)
class Cuvette(Sample):
    r""" A sample consisting of three vacuum layers, for SAS simulations. The middle layer has the specified thickness, with interfaces at ±thickness/2. Particles can be added to the middle layer using Layer::fill3D() with Disordered3D."""

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

    def __init__(self, thickness):
        r"""__init__(Cuvette self, double thickness) -> Cuvette"""
        _libBornAgainSample.Cuvette_swiginit(self, _libBornAgainSample.new_Cuvette(thickness))

    def middleLayer(self):
        r""" Returns the middle layer for adding particles."""
        return _libBornAgainSample.Cuvette_middleLayer(self)
    __swig_destroy__ = _libBornAgainSample.delete_Cuvette

# Register Cuvette in _libBornAgainSample:
_libBornAgainSample.Cuvette_swigregister(Cuvette)
class AutocorrelationModel(object):
    r""" Base class for autocorrelation function models."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setMaxSpatialFrequency(self, val):
        r"""setMaxSpatialFrequency(AutocorrelationModel self, double val)"""
        return _libBornAgainSample.AutocorrelationModel_setMaxSpatialFrequency(self, val)

    def maxSpatialFrequency(self):
        r"""maxSpatialFrequency(AutocorrelationModel self) -> double"""
        return _libBornAgainSample.AutocorrelationModel_maxSpatialFrequency(self)
    __swig_destroy__ = _libBornAgainSample.delete_AutocorrelationModel

# Register AutocorrelationModel in _libBornAgainSample:
_libBornAgainSample.AutocorrelationModel_swigregister(AutocorrelationModel)
class SelfAffineFractalModel(AutocorrelationModel):
    r""" The model is described e.g. in the article "Roughness spectrum and surface width of self-affine fractal surfaces via the K-correlation model" by G. Palasantzas, Physical Review B 48, 14472-14478 (1993)"""

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

    def __init__(self, sigma, hurst, lateralCorrLength, maxSpatFrequency=0.5):
        r"""__init__(SelfAffineFractalModel self, double sigma, double hurst, double lateralCorrLength, double maxSpatFrequency=0.5) -> SelfAffineFractalModel"""
        _libBornAgainSample.SelfAffineFractalModel_swiginit(self, _libBornAgainSample.new_SelfAffineFractalModel(sigma, hurst, lateralCorrLength, maxSpatFrequency))

    def spectralFunction(self, spatial_f):
        r""" Returns power spectral density of the surface roughness"""
        return _libBornAgainSample.SelfAffineFractalModel_spectralFunction(self, spatial_f)

    def setSigma(self, sigma):
        r""" Returns rms of roughness"""
        return _libBornAgainSample.SelfAffineFractalModel_setSigma(self, sigma)

    def setHurstParameter(self, hurstParameter):
        r"""setHurstParameter(SelfAffineFractalModel self, double hurstParameter)"""
        return _libBornAgainSample.SelfAffineFractalModel_setHurstParameter(self, hurstParameter)

    def setLatteralCorrLength(self, lateralCorrLen):
        r"""setLatteralCorrLength(SelfAffineFractalModel self, double lateralCorrLen)"""
        return _libBornAgainSample.SelfAffineFractalModel_setLatteralCorrLength(self, lateralCorrLen)
    __swig_destroy__ = _libBornAgainSample.delete_SelfAffineFractalModel

# Register SelfAffineFractalModel in _libBornAgainSample:
_libBornAgainSample.SelfAffineFractalModel_swigregister(SelfAffineFractalModel)
class LinearGrowthModel(AutocorrelationModel):
    r""" The model is described e.g. in the article "Stochastic model for thin film growth and erosion" by D. G. Stearns, Applied Physics Letters 62, 1745–1747 (1993) and extended in e.g. Stearns, D. G. & Gullikson, E. M. "Nonspecular scattering from extreme ultraviolet multilayer coatings", Physica B: Condensed Matter 283, 1–3, p. 84-91 (2000)"""

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

    def __init__(self, particle_volume, damp1, damp2, damp3, damp4, maxSpatFrequency=0.5):
        r"""__init__(LinearGrowthModel self, double particle_volume, double damp1, double damp2, double damp3, double damp4, double maxSpatFrequency=0.5) -> LinearGrowthModel"""
        _libBornAgainSample.LinearGrowthModel_swiginit(self, _libBornAgainSample.new_LinearGrowthModel(particle_volume, damp1, damp2, damp3, damp4, maxSpatFrequency))

    def spectralFunction(self, spectrum_below, thickness, spatial_f):
        r""" Returns power spectral density of the surface roughness"""
        return _libBornAgainSample.LinearGrowthModel_spectralFunction(self, spectrum_below, thickness, spatial_f)

    def crosscorrSpectrum(self, spectrum_below, thickness, spatial_f):
        r"""crosscorrSpectrum(LinearGrowthModel self, double spectrum_below, double thickness, double spatial_f) -> double"""
        return _libBornAgainSample.LinearGrowthModel_crosscorrSpectrum(self, spectrum_below, thickness, spatial_f)

    def setClusterVolume(self, particle_volume):
        r"""setClusterVolume(LinearGrowthModel self, double particle_volume)"""
        return _libBornAgainSample.LinearGrowthModel_setClusterVolume(self, particle_volume)

    def clusterVolume(self):
        r"""clusterVolume(LinearGrowthModel self) -> double"""
        return _libBornAgainSample.LinearGrowthModel_clusterVolume(self)

    def setDamp1(self, damp1):
        r"""setDamp1(LinearGrowthModel self, double damp1)"""
        return _libBornAgainSample.LinearGrowthModel_setDamp1(self, damp1)

    def setDamp2(self, damp2):
        r"""setDamp2(LinearGrowthModel self, double damp2)"""
        return _libBornAgainSample.LinearGrowthModel_setDamp2(self, damp2)

    def setDamp3(self, damp3):
        r"""setDamp3(LinearGrowthModel self, double damp3)"""
        return _libBornAgainSample.LinearGrowthModel_setDamp3(self, damp3)

    def setDamp4(self, damp4):
        r"""setDamp4(LinearGrowthModel self, double damp4)"""
        return _libBornAgainSample.LinearGrowthModel_setDamp4(self, damp4)
    __swig_destroy__ = _libBornAgainSample.delete_LinearGrowthModel

# Register LinearGrowthModel in _libBornAgainSample:
_libBornAgainSample.LinearGrowthModel_swigregister(LinearGrowthModel)
class TransientModel(object):
    r"""Proxy of C++ TransientModel 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")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_TransientModel

# Register TransientModel in _libBornAgainSample:
_libBornAgainSample.TransientModel_swigregister(TransientModel)
class ErfTransient(TransientModel):
    r"""Proxy of C++ ErfTransient class."""

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

    def __init__(self):
        r"""__init__(ErfTransient self) -> ErfTransient"""
        _libBornAgainSample.ErfTransient_swiginit(self, _libBornAgainSample.new_ErfTransient())
    __swig_destroy__ = _libBornAgainSample.delete_ErfTransient

# Register ErfTransient in _libBornAgainSample:
_libBornAgainSample.ErfTransient_swigregister(ErfTransient)
class TanhTransient(TransientModel):
    r"""Proxy of C++ TanhTransient class."""

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

    def __init__(self):
        r"""__init__(TanhTransient self) -> TanhTransient"""
        _libBornAgainSample.TanhTransient_swiginit(self, _libBornAgainSample.new_TanhTransient())
    __swig_destroy__ = _libBornAgainSample.delete_TanhTransient

# Register TanhTransient in _libBornAgainSample:
_libBornAgainSample.TanhTransient_swigregister(TanhTransient)
class CrosscorrelationModel(object):
    r""" Base class for cross-correlation function models."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_CrosscorrelationModel

# Register CrosscorrelationModel in _libBornAgainSample:
_libBornAgainSample.CrosscorrelationModel_swigregister(CrosscorrelationModel)
class SpatialFrequencyCrosscorrelation(CrosscorrelationModel):
    r""" The crosscorrelation factor depends both on the distance between interfaces and the spatial frequency of roughness."""

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

    def __init__(self, base_crosscorr_depth, base_frequency, power):
        r"""__init__(SpatialFrequencyCrosscorrelation self, double base_crosscorr_depth, double base_frequency, double power) -> SpatialFrequencyCrosscorrelation"""
        _libBornAgainSample.SpatialFrequencyCrosscorrelation_swiginit(self, _libBornAgainSample.new_SpatialFrequencyCrosscorrelation(base_crosscorr_depth, base_frequency, power))

    def crosscorrSpectrum(self, spectrum_up, spectrum_low, thickness, spatial_f):
        r"""crosscorrSpectrum(SpatialFrequencyCrosscorrelation self, double spectrum_up, double spectrum_low, double thickness, double spatial_f) -> double"""
        return _libBornAgainSample.SpatialFrequencyCrosscorrelation_crosscorrSpectrum(self, spectrum_up, spectrum_low, thickness, spatial_f)
    __swig_destroy__ = _libBornAgainSample.delete_SpatialFrequencyCrosscorrelation

# Register SpatialFrequencyCrosscorrelation in _libBornAgainSample:
_libBornAgainSample.SpatialFrequencyCrosscorrelation_swigregister(SpatialFrequencyCrosscorrelation)
class CommonDepthCrosscorrelation(SpatialFrequencyCrosscorrelation):
    r""" The crosscorrelation factor depends on the distance between interfaces and does not depend on the spatial frequency of roughness."""

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

    def __init__(self, cross_corr_depth):
        r"""__init__(CommonDepthCrosscorrelation self, double cross_corr_depth) -> CommonDepthCrosscorrelation"""
        _libBornAgainSample.CommonDepthCrosscorrelation_swiginit(self, _libBornAgainSample.new_CommonDepthCrosscorrelation(cross_corr_depth))
    __swig_destroy__ = _libBornAgainSample.delete_CommonDepthCrosscorrelation

# Register CommonDepthCrosscorrelation in _libBornAgainSample:
_libBornAgainSample.CommonDepthCrosscorrelation_swigregister(CommonDepthCrosscorrelation)
class FormfactorPolyhedron(HardFormfactor):
    r""" A polyhedron, for form factor computation."""

    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__ = _libBornAgainSample.delete_FormfactorPolyhedron

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(FormfactorPolyhedron self, C3 q) -> complex_t"""
        return _libBornAgainSample.FormfactorPolyhedron_formfactorAtBottom(self, q)

    def volume(self):
        r"""volume(FormfactorPolyhedron self) -> double"""
        return _libBornAgainSample.FormfactorPolyhedron_volume(self)

    def getPolyhedron(self):
        r"""getPolyhedron(FormfactorPolyhedron self) -> std::shared_ptr< ff::Polyhedron >"""
        return _libBornAgainSample.FormfactorPolyhedron_getPolyhedron(self)

# Register FormfactorPolyhedron in _libBornAgainSample:
_libBornAgainSample.FormfactorPolyhedron_swigregister(FormfactorPolyhedron)
class FormfactorPrism(FormfactorPolyhedron):
    r""" A prism with a polygonal base, for form factor computation."""

    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__ = _libBornAgainSample.delete_FormfactorPrism

    def height(self):
        r"""height(FormfactorPrism self) -> double"""
        return _libBornAgainSample.FormfactorPrism_height(self)

# Register FormfactorPrism in _libBornAgainSample:
_libBornAgainSample.FormfactorPrism_swigregister(FormfactorPrism)
class ProfileRipple(HardFormfactor):
    r""" Base class for form factors with a cosine ripple profile in the yz plane."""

    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 length(self):
        r"""length(ProfileRipple self) -> double"""
        return _libBornAgainSample.ProfileRipple_length(self)

    def height(self):
        r"""height(ProfileRipple self) -> double"""
        return _libBornAgainSample.ProfileRipple_height(self)

    def width(self):
        r"""width(ProfileRipple self) -> double"""
        return _libBornAgainSample.ProfileRipple_width(self)

    def radialExtension(self):
        r"""radialExtension(ProfileRipple self) -> double"""
        return _libBornAgainSample.ProfileRipple_radialExtension(self)

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(ProfileRipple self, C3 q) -> complex_t"""
        return _libBornAgainSample.ProfileRipple_formfactorAtBottom(self, q)

    def validate(self):
        r"""validate(ProfileRipple self)"""
        return _libBornAgainSample.ProfileRipple_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_ProfileRipple

# Register ProfileRipple in _libBornAgainSample:
_libBornAgainSample.ProfileRipple_swigregister(ProfileRipple)
class ProfileRectangularRipple(ProfileRipple):
    r""" Base class for form factors with a rectangular ripple (bar) profile in the yz plane."""

    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__ = _libBornAgainSample.delete_ProfileRectangularRipple

# Register ProfileRectangularRipple in _libBornAgainSample:
_libBornAgainSample.ProfileRectangularRipple_swigregister(ProfileRectangularRipple)
class CosineRipple(ProfileRipple):
    r""" Base class for form factors with a cosine ripple profile in the yz plane."""

    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__ = _libBornAgainSample.delete_CosineRipple

# Register CosineRipple in _libBornAgainSample:
_libBornAgainSample.CosineRipple_swigregister(CosineRipple)
class SawtoothRipple(ProfileRipple):
    r""" Base class for form factors with a triangular ripple profile in the yz plane."""

    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 asymmetry(self):
        r"""asymmetry(SawtoothRipple self) -> double"""
        return _libBornAgainSample.SawtoothRipple_asymmetry(self)
    __swig_destroy__ = _libBornAgainSample.delete_SawtoothRipple

# Register SawtoothRipple in _libBornAgainSample:
_libBornAgainSample.SawtoothRipple_swigregister(SawtoothRipple)
class Box(FormfactorPrism):
    r""" A rectangular prism (parallelepiped)."""

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

    def __init__(self, length, width, height):
        r"""__init__(Box self, double length, double width, double height) -> Box"""
        _libBornAgainSample.Box_swiginit(self, _libBornAgainSample.new_Box(length, width, height))

    def className(self):
        r"""className(Box self) -> std::string"""
        return _libBornAgainSample.Box_className(self)

    def length(self):
        r"""length(Box self) -> double"""
        return _libBornAgainSample.Box_length(self)

    def width(self):
        r"""width(Box self) -> double"""
        return _libBornAgainSample.Box_width(self)

    def height(self):
        r"""height(Box self) -> double"""
        return _libBornAgainSample.Box_height(self)

    def contains(self, position):
        r"""contains(Box self, R3 const & position) -> bool"""
        return _libBornAgainSample.Box_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Box

# Register Box in _libBornAgainSample:
_libBornAgainSample.Box_swigregister(Box)
class Prism3(FormfactorPrism):
    r""" A prism based on an equilateral triangle."""

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

    def __init__(self, base_edge, height):
        r"""__init__(Prism3 self, double base_edge, double height) -> Prism3"""
        _libBornAgainSample.Prism3_swiginit(self, _libBornAgainSample.new_Prism3(base_edge, height))

    def className(self):
        r"""className(Prism3 self) -> std::string"""
        return _libBornAgainSample.Prism3_className(self)

    def baseEdge(self):
        r"""baseEdge(Prism3 self) -> double"""
        return _libBornAgainSample.Prism3_baseEdge(self)

    def height(self):
        r"""height(Prism3 self) -> double"""
        return _libBornAgainSample.Prism3_height(self)

    def contains(self, position):
        r"""contains(Prism3 self, R3 const & position) -> bool"""
        return _libBornAgainSample.Prism3_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Prism3

# Register Prism3 in _libBornAgainSample:
_libBornAgainSample.Prism3_swigregister(Prism3)
class Prism6(FormfactorPrism):
    r""" A prism based on a regular hexagonal."""

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

    def __init__(self, base_edge, height):
        r"""__init__(Prism6 self, double base_edge, double height) -> Prism6"""
        _libBornAgainSample.Prism6_swiginit(self, _libBornAgainSample.new_Prism6(base_edge, height))

    def className(self):
        r"""className(Prism6 self) -> std::string"""
        return _libBornAgainSample.Prism6_className(self)

    def baseEdge(self):
        r"""baseEdge(Prism6 self) -> double"""
        return _libBornAgainSample.Prism6_baseEdge(self)

    def height(self):
        r"""height(Prism6 self) -> double"""
        return _libBornAgainSample.Prism6_height(self)

    def contains(self, position):
        r"""contains(Prism6 self, R3 const & position) -> bool"""
        return _libBornAgainSample.Prism6_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Prism6

# Register Prism6 in _libBornAgainSample:
_libBornAgainSample.Prism6_swigregister(Prism6)
class PlatonicTetrahedron(FormfactorPolyhedron):
    r""" A frustum with equilateral trigonal base."""

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

    def __init__(self, edge):
        r"""__init__(PlatonicTetrahedron self, double edge) -> PlatonicTetrahedron"""
        _libBornAgainSample.PlatonicTetrahedron_swiginit(self, _libBornAgainSample.new_PlatonicTetrahedron(edge))

    def className(self):
        r"""className(PlatonicTetrahedron self) -> std::string"""
        return _libBornAgainSample.PlatonicTetrahedron_className(self)

    def edge(self):
        r"""edge(PlatonicTetrahedron self) -> double"""
        return _libBornAgainSample.PlatonicTetrahedron_edge(self)

    def height(self):
        r"""height(PlatonicTetrahedron self) -> double"""
        return _libBornAgainSample.PlatonicTetrahedron_height(self)

    def contains(self, position):
        r"""contains(PlatonicTetrahedron self, R3 const & position) -> bool"""
        return _libBornAgainSample.PlatonicTetrahedron_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_PlatonicTetrahedron

# Register PlatonicTetrahedron in _libBornAgainSample:
_libBornAgainSample.PlatonicTetrahedron_swigregister(PlatonicTetrahedron)
class PlatonicOctahedron(FormfactorPolyhedron):
    r""" A truncated bifrustum with quadratic base."""

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

    def __init__(self, edge):
        r"""__init__(PlatonicOctahedron self, double edge) -> PlatonicOctahedron"""
        _libBornAgainSample.PlatonicOctahedron_swiginit(self, _libBornAgainSample.new_PlatonicOctahedron(edge))

    def className(self):
        r"""className(PlatonicOctahedron self) -> std::string"""
        return _libBornAgainSample.PlatonicOctahedron_className(self)

    def edge(self):
        r"""edge(PlatonicOctahedron self) -> double"""
        return _libBornAgainSample.PlatonicOctahedron_edge(self)

    def height(self):
        r"""height(PlatonicOctahedron self) -> double"""
        return _libBornAgainSample.PlatonicOctahedron_height(self)

    def contains(self, position):
        r"""contains(PlatonicOctahedron self, R3 const & position) -> bool"""
        return _libBornAgainSample.PlatonicOctahedron_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_PlatonicOctahedron

# Register PlatonicOctahedron in _libBornAgainSample:
_libBornAgainSample.PlatonicOctahedron_swigregister(PlatonicOctahedron)
class Dodecahedron(FormfactorPolyhedron):
    r""" A regular dodecahedron."""

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

    def __init__(self, edge):
        r"""__init__(Dodecahedron self, double edge) -> Dodecahedron"""
        _libBornAgainSample.Dodecahedron_swiginit(self, _libBornAgainSample.new_Dodecahedron(edge))

    def className(self):
        r"""className(Dodecahedron self) -> std::string"""
        return _libBornAgainSample.Dodecahedron_className(self)

    def edge(self):
        r"""edge(Dodecahedron self) -> double"""
        return _libBornAgainSample.Dodecahedron_edge(self)

    def contains(self, position):
        r"""contains(Dodecahedron self, R3 const & position) -> bool"""
        return _libBornAgainSample.Dodecahedron_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Dodecahedron

# Register Dodecahedron in _libBornAgainSample:
_libBornAgainSample.Dodecahedron_swigregister(Dodecahedron)
class Icosahedron(FormfactorPolyhedron):
    r""" A regular icosahedron."""

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

    def __init__(self, edge):
        r"""__init__(Icosahedron self, double edge) -> Icosahedron"""
        _libBornAgainSample.Icosahedron_swiginit(self, _libBornAgainSample.new_Icosahedron(edge))

    def className(self):
        r"""className(Icosahedron self) -> std::string"""
        return _libBornAgainSample.Icosahedron_className(self)

    def edge(self):
        r"""edge(Icosahedron self) -> double"""
        return _libBornAgainSample.Icosahedron_edge(self)

    def contains(self, position):
        r"""contains(Icosahedron self, R3 const & position) -> bool"""
        return _libBornAgainSample.Icosahedron_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Icosahedron

# Register Icosahedron in _libBornAgainSample:
_libBornAgainSample.Icosahedron_swigregister(Icosahedron)
class Pyramid2(FormfactorPolyhedron):
    r""" A frustum (truncated pyramid) with rectangular base."""

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

    def __init__(self, length, width, height, alpha):
        r"""__init__(Pyramid2 self, double length, double width, double height, double alpha) -> Pyramid2"""
        _libBornAgainSample.Pyramid2_swiginit(self, _libBornAgainSample.new_Pyramid2(length, width, height, alpha))

    def className(self):
        r"""className(Pyramid2 self) -> std::string"""
        return _libBornAgainSample.Pyramid2_className(self)

    def length(self):
        r"""length(Pyramid2 self) -> double"""
        return _libBornAgainSample.Pyramid2_length(self)

    def width(self):
        r"""width(Pyramid2 self) -> double"""
        return _libBornAgainSample.Pyramid2_width(self)

    def height(self):
        r"""height(Pyramid2 self) -> double"""
        return _libBornAgainSample.Pyramid2_height(self)

    def alpha(self):
        r"""alpha(Pyramid2 self) -> double"""
        return _libBornAgainSample.Pyramid2_alpha(self)

    def contains(self, position):
        r"""contains(Pyramid2 self, R3 const & position) -> bool"""
        return _libBornAgainSample.Pyramid2_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid2

# Register Pyramid2 in _libBornAgainSample:
_libBornAgainSample.Pyramid2_swigregister(Pyramid2)
class Pyramid3(FormfactorPolyhedron):
    r""" A frustum with equilateral trigonal base."""

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

    def __init__(self, base_edge, height, alpha):
        r"""__init__(Pyramid3 self, double base_edge, double height, double alpha) -> Pyramid3"""
        _libBornAgainSample.Pyramid3_swiginit(self, _libBornAgainSample.new_Pyramid3(base_edge, height, alpha))

    def className(self):
        r"""className(Pyramid3 self) -> std::string"""
        return _libBornAgainSample.Pyramid3_className(self)

    def baseEdge(self):
        r"""baseEdge(Pyramid3 self) -> double"""
        return _libBornAgainSample.Pyramid3_baseEdge(self)

    def height(self):
        r"""height(Pyramid3 self) -> double"""
        return _libBornAgainSample.Pyramid3_height(self)

    def alpha(self):
        r"""alpha(Pyramid3 self) -> double"""
        return _libBornAgainSample.Pyramid3_alpha(self)

    def contains(self, position):
        r"""contains(Pyramid3 self, R3 const & position) -> bool"""
        return _libBornAgainSample.Pyramid3_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid3

# Register Pyramid3 in _libBornAgainSample:
_libBornAgainSample.Pyramid3_swigregister(Pyramid3)
class Pyramid4(FormfactorPolyhedron):
    r""" A frustum with a quadratic base."""

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

    def __init__(self, base_edge, height, alpha):
        r"""__init__(Pyramid4 self, double base_edge, double height, double alpha) -> Pyramid4"""
        _libBornAgainSample.Pyramid4_swiginit(self, _libBornAgainSample.new_Pyramid4(base_edge, height, alpha))

    def className(self):
        r"""className(Pyramid4 self) -> std::string"""
        return _libBornAgainSample.Pyramid4_className(self)

    def height(self):
        r"""height(Pyramid4 self) -> double"""
        return _libBornAgainSample.Pyramid4_height(self)

    def baseEdge(self):
        r"""baseEdge(Pyramid4 self) -> double"""
        return _libBornAgainSample.Pyramid4_baseEdge(self)

    def alpha(self):
        r"""alpha(Pyramid4 self) -> double"""
        return _libBornAgainSample.Pyramid4_alpha(self)

    def contains(self, position):
        r"""contains(Pyramid4 self, R3 const & position) -> bool"""
        return _libBornAgainSample.Pyramid4_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid4

# Register Pyramid4 in _libBornAgainSample:
_libBornAgainSample.Pyramid4_swigregister(Pyramid4)
class Pyramid6(FormfactorPolyhedron):
    r""" A frustum (truncated pyramid) with regular hexagonal base."""

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

    def __init__(self, base_edge, height, alpha):
        r"""__init__(Pyramid6 self, double base_edge, double height, double alpha) -> Pyramid6"""
        _libBornAgainSample.Pyramid6_swiginit(self, _libBornAgainSample.new_Pyramid6(base_edge, height, alpha))

    def className(self):
        r"""className(Pyramid6 self) -> std::string"""
        return _libBornAgainSample.Pyramid6_className(self)

    def baseEdge(self):
        r"""baseEdge(Pyramid6 self) -> double"""
        return _libBornAgainSample.Pyramid6_baseEdge(self)

    def height(self):
        r"""height(Pyramid6 self) -> double"""
        return _libBornAgainSample.Pyramid6_height(self)

    def alpha(self):
        r"""alpha(Pyramid6 self) -> double"""
        return _libBornAgainSample.Pyramid6_alpha(self)

    def contains(self, position):
        r"""contains(Pyramid6 self, R3 const & position) -> bool"""
        return _libBornAgainSample.Pyramid6_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid6

# Register Pyramid6 in _libBornAgainSample:
_libBornAgainSample.Pyramid6_swigregister(Pyramid6)
class Bipyramid4(FormfactorPolyhedron):
    r""" A truncated bifrustum with quadratic base."""

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

    def __init__(self, length, base_height, height_ratio, alpha):
        r"""__init__(Bipyramid4 self, double length, double base_height, double height_ratio, double alpha) -> Bipyramid4"""
        _libBornAgainSample.Bipyramid4_swiginit(self, _libBornAgainSample.new_Bipyramid4(length, base_height, height_ratio, alpha))

    def className(self):
        r"""className(Bipyramid4 self) -> std::string"""
        return _libBornAgainSample.Bipyramid4_className(self)

    def length(self):
        r"""length(Bipyramid4 self) -> double"""
        return _libBornAgainSample.Bipyramid4_length(self)

    def base_height(self):
        r"""base_height(Bipyramid4 self) -> double"""
        return _libBornAgainSample.Bipyramid4_base_height(self)

    def heightRatio(self):
        r"""heightRatio(Bipyramid4 self) -> double"""
        return _libBornAgainSample.Bipyramid4_heightRatio(self)

    def alpha(self):
        r"""alpha(Bipyramid4 self) -> double"""
        return _libBornAgainSample.Bipyramid4_alpha(self)

    def height(self):
        r"""height(Bipyramid4 self) -> double"""
        return _libBornAgainSample.Bipyramid4_height(self)

    def contains(self, position):
        r"""contains(Bipyramid4 self, R3 const & position) -> bool"""
        return _libBornAgainSample.Bipyramid4_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Bipyramid4

# Register Bipyramid4 in _libBornAgainSample:
_libBornAgainSample.Bipyramid4_swigregister(Bipyramid4)
class CantellatedCube(FormfactorPolyhedron):
    r""" A cube, with truncation of all edges and corners, as in Croset (2017) Fig 7"""

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

    def __init__(self, length, removed_length):
        r"""__init__(CantellatedCube self, double length, double removed_length) -> CantellatedCube"""
        _libBornAgainSample.CantellatedCube_swiginit(self, _libBornAgainSample.new_CantellatedCube(length, removed_length))

    def className(self):
        r"""className(CantellatedCube self) -> std::string"""
        return _libBornAgainSample.CantellatedCube_className(self)

    def length(self):
        r"""length(CantellatedCube self) -> double"""
        return _libBornAgainSample.CantellatedCube_length(self)

    def removedLength(self):
        r"""removedLength(CantellatedCube self) -> double"""
        return _libBornAgainSample.CantellatedCube_removedLength(self)

    def contains(self, position):
        r"""contains(CantellatedCube self, R3 const & position) -> bool"""
        return _libBornAgainSample.CantellatedCube_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_CantellatedCube

# Register CantellatedCube in _libBornAgainSample:
_libBornAgainSample.CantellatedCube_swigregister(CantellatedCube)
class TruncatedCube(FormfactorPolyhedron):
    r""" A cube, with tetrahedral truncation of all corners"""

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

    def __init__(self, length, removed_length):
        r"""__init__(TruncatedCube self, double length, double removed_length) -> TruncatedCube"""
        _libBornAgainSample.TruncatedCube_swiginit(self, _libBornAgainSample.new_TruncatedCube(length, removed_length))

    def className(self):
        r"""className(TruncatedCube self) -> std::string"""
        return _libBornAgainSample.TruncatedCube_className(self)

    def length(self):
        r"""length(TruncatedCube self) -> double"""
        return _libBornAgainSample.TruncatedCube_length(self)

    def removedLength(self):
        r"""removedLength(TruncatedCube self) -> double"""
        return _libBornAgainSample.TruncatedCube_removedLength(self)

    def contains(self, position):
        r"""contains(TruncatedCube self, R3 const & position) -> bool"""
        return _libBornAgainSample.TruncatedCube_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_TruncatedCube

# Register TruncatedCube in _libBornAgainSample:
_libBornAgainSample.TruncatedCube_swigregister(TruncatedCube)
class Cone(HardFormfactor):
    r""" A conical frustum (cone truncated parallel to the base) with circular base."""

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

    def __init__(self, radius, height, alpha):
        r"""__init__(Cone self, double radius, double height, double alpha) -> Cone"""
        _libBornAgainSample.Cone_swiginit(self, _libBornAgainSample.new_Cone(radius, height, alpha))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(Cone self, C3 q) -> complex_t"""
        return _libBornAgainSample.Cone_formfactorAtBottom(self, q)

    def className(self):
        r"""className(Cone self) -> std::string"""
        return _libBornAgainSample.Cone_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_Cone

# Register Cone in _libBornAgainSample:
_libBornAgainSample.Cone_swigregister(Cone)
class Cylinder(HardFormfactor):
    r""" A circular cylinder."""

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

    def __init__(self, radius, height):
        r"""__init__(Cylinder self, double radius, double height) -> Cylinder"""
        _libBornAgainSample.Cylinder_swiginit(self, _libBornAgainSample.new_Cylinder(radius, height))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(Cylinder self, C3 q) -> complex_t"""
        return _libBornAgainSample.Cylinder_formfactorAtBottom(self, q)

    def className(self):
        r"""className(Cylinder self) -> std::string"""
        return _libBornAgainSample.Cylinder_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_Cylinder

# Register Cylinder in _libBornAgainSample:
_libBornAgainSample.Cylinder_swigregister(Cylinder)
class Ellipsoid(HardFormfactor):
    r""" An hemi ellipsoid,   obtained by truncating a full ellipsoid in the middle plane spanned by two principal axes."""

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

    def __init__(self, radius_x, radius_y, radius_z):
        r"""__init__(Ellipsoid self, double radius_x, double radius_y, double radius_z) -> Ellipsoid"""
        _libBornAgainSample.Ellipsoid_swiginit(self, _libBornAgainSample.new_Ellipsoid(radius_x, radius_y, radius_z))
    __swig_destroy__ = _libBornAgainSample.delete_Ellipsoid

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(Ellipsoid self, C3 q) -> complex_t"""
        return _libBornAgainSample.Ellipsoid_formfactorAtBottom(self, q)

    def className(self):
        r"""className(Ellipsoid self) -> std::string"""
        return _libBornAgainSample.Ellipsoid_className(self)

# Register Ellipsoid in _libBornAgainSample:
_libBornAgainSample.Ellipsoid_swigregister(Ellipsoid)
class EllipsoidalCylinder(HardFormfactor):
    r""" A cylinder with elliptical base."""

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

    def __init__(self, radius_x, radius_y, height):
        r"""__init__(EllipsoidalCylinder self, double radius_x, double radius_y, double height) -> EllipsoidalCylinder"""
        _libBornAgainSample.EllipsoidalCylinder_swiginit(self, _libBornAgainSample.new_EllipsoidalCylinder(radius_x, radius_y, height))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(EllipsoidalCylinder self, C3 q) -> complex_t"""
        return _libBornAgainSample.EllipsoidalCylinder_formfactorAtBottom(self, q)

    def className(self):
        r"""className(EllipsoidalCylinder self) -> std::string"""
        return _libBornAgainSample.EllipsoidalCylinder_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_EllipsoidalCylinder

# Register EllipsoidalCylinder in _libBornAgainSample:
_libBornAgainSample.EllipsoidalCylinder_swigregister(EllipsoidalCylinder)
class EllipsoidalSegment(HardFormfactor):
    r""" An hemi ellipsoid,   obtained by truncating a full ellipsoid in the middle plane spanned by two principal axes."""

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

    def __init__(self, radius_x, radius_y, radius_z, rm_top, rm_bottom):
        r"""__init__(EllipsoidalSegment self, double radius_x, double radius_y, double radius_z, double rm_top, double rm_bottom) -> EllipsoidalSegment"""
        _libBornAgainSample.EllipsoidalSegment_swiginit(self, _libBornAgainSample.new_EllipsoidalSegment(radius_x, radius_y, radius_z, rm_top, rm_bottom))
    __swig_destroy__ = _libBornAgainSample.delete_EllipsoidalSegment

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(EllipsoidalSegment self, C3 q) -> complex_t"""
        return _libBornAgainSample.EllipsoidalSegment_formfactorAtBottom(self, q)

    def className(self):
        r"""className(EllipsoidalSegment self) -> std::string"""
        return _libBornAgainSample.EllipsoidalSegment_className(self)

# Register EllipsoidalSegment in _libBornAgainSample:
_libBornAgainSample.EllipsoidalSegment_swigregister(EllipsoidalSegment)
class HorizontalCylinder(HardFormfactor):
    r""" A circular cylinder."""

    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__(HorizontalCylinder self, double radius, double length, double rm_top, double rm_bottom) -> HorizontalCylinder
        __init__(HorizontalCylinder self, double radius, double length) -> HorizontalCylinder
        """
        _libBornAgainSample.HorizontalCylinder_swiginit(self, _libBornAgainSample.new_HorizontalCylinder(*args))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(HorizontalCylinder self, C3 q) -> complex_t"""
        return _libBornAgainSample.HorizontalCylinder_formfactorAtBottom(self, q)

    def className(self):
        r"""className(HorizontalCylinder self) -> std::string"""
        return _libBornAgainSample.HorizontalCylinder_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_HorizontalCylinder

# Register HorizontalCylinder in _libBornAgainSample:
_libBornAgainSample.HorizontalCylinder_swigregister(HorizontalCylinder)
class Sphere(HardFormfactor):
    r""" A full sphere."""

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

    def __init__(self, radius):
        r"""__init__(Sphere self, double radius) -> Sphere"""
        _libBornAgainSample.Sphere_swiginit(self, _libBornAgainSample.new_Sphere(radius))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(Sphere self, C3 q) -> complex_t"""
        return _libBornAgainSample.Sphere_formfactorAtBottom(self, q)

    def className(self):
        r"""className(Sphere self) -> std::string"""
        return _libBornAgainSample.Sphere_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_Sphere

# Register Sphere in _libBornAgainSample:
_libBornAgainSample.Sphere_swigregister(Sphere)
class SphericalSegment(HardFormfactor):
    r""" A truncated Sphere."""

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

    def __init__(self, radius, top_cut, bottom_cut):
        r"""__init__(SphericalSegment self, double radius, double top_cut, double bottom_cut) -> SphericalSegment"""
        _libBornAgainSample.SphericalSegment_swiginit(self, _libBornAgainSample.new_SphericalSegment(radius, top_cut, bottom_cut))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(SphericalSegment self, C3 q) -> complex_t"""
        return _libBornAgainSample.SphericalSegment_formfactorAtBottom(self, q)

    def className(self):
        r"""className(SphericalSegment self) -> std::string"""
        return _libBornAgainSample.SphericalSegment_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_SphericalSegment

# Register SphericalSegment in _libBornAgainSample:
_libBornAgainSample.SphericalSegment_swigregister(SphericalSegment)
class Spheroid(HardFormfactor):
    r""" A full spheroid (an ellipsoid with two equal axes, hence with circular cross section)"""

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

    def __init__(self, radius_xy, radius_z):
        r"""__init__(Spheroid self, double radius_xy, double radius_z) -> Spheroid"""
        _libBornAgainSample.Spheroid_swiginit(self, _libBornAgainSample.new_Spheroid(radius_xy, radius_z))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(Spheroid self, C3 q) -> complex_t"""
        return _libBornAgainSample.Spheroid_formfactorAtBottom(self, q)

    def className(self):
        r"""className(Spheroid self) -> std::string"""
        return _libBornAgainSample.Spheroid_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_Spheroid

# Register Spheroid in _libBornAgainSample:
_libBornAgainSample.Spheroid_swigregister(Spheroid)
class SpheroidalSegment(HardFormfactor):
    r""" A truncated spheroid. An ellipsoid with two equal axis, truncated by a plane perpendicular to the third axis."""

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

    def __init__(self, radius_xy, radius_z, rm_top, rm_bottom):
        r"""__init__(SpheroidalSegment self, double radius_xy, double radius_z, double rm_top, double rm_bottom) -> SpheroidalSegment"""
        _libBornAgainSample.SpheroidalSegment_swiginit(self, _libBornAgainSample.new_SpheroidalSegment(radius_xy, radius_z, rm_top, rm_bottom))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(SpheroidalSegment self, C3 q) -> complex_t"""
        return _libBornAgainSample.SpheroidalSegment_formfactorAtBottom(self, q)

    def className(self):
        r"""className(SpheroidalSegment self) -> std::string"""
        return _libBornAgainSample.SpheroidalSegment_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_SpheroidalSegment

# Register SpheroidalSegment in _libBornAgainSample:
_libBornAgainSample.SpheroidalSegment_swigregister(SpheroidalSegment)
class BarGauss(ProfileRectangularRipple):
    r""" The form factor of an elongated bar, with Gaussian profile in elongation direction."""

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

    def __init__(self, length, width, height):
        r"""__init__(BarGauss self, double length, double width, double height) -> BarGauss"""
        _libBornAgainSample.BarGauss_swiginit(self, _libBornAgainSample.new_BarGauss(length, width, height))

    def className(self):
        r"""className(BarGauss self) -> std::string"""
        return _libBornAgainSample.BarGauss_className(self)

    def contains(self, position):
        r"""contains(BarGauss self, R3 const & position) -> bool"""
        return _libBornAgainSample.BarGauss_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_BarGauss

# Register BarGauss in _libBornAgainSample:
_libBornAgainSample.BarGauss_swigregister(BarGauss)
class BarLorentz(ProfileRectangularRipple):
    r""" The form factor of an elongated, with Lorentz form factor in elongation direction."""

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

    def __init__(self, length, width, height):
        r"""__init__(BarLorentz self, double length, double width, double height) -> BarLorentz"""
        _libBornAgainSample.BarLorentz_swiginit(self, _libBornAgainSample.new_BarLorentz(length, width, height))

    def className(self):
        r"""className(BarLorentz self) -> std::string"""
        return _libBornAgainSample.BarLorentz_className(self)

    def contains(self, position):
        r"""contains(BarLorentz self, R3 const & position) -> bool"""
        return _libBornAgainSample.BarLorentz_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_BarLorentz

# Register BarLorentz in _libBornAgainSample:
_libBornAgainSample.BarLorentz_swigregister(BarLorentz)
class CosineRippleBox(CosineRipple):
    r""" The form factor for a cosine ripple, with box profile in elongation direction."""

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

    def __init__(self, length, width, height):
        r"""__init__(CosineRippleBox self, double length, double width, double height) -> CosineRippleBox"""
        _libBornAgainSample.CosineRippleBox_swiginit(self, _libBornAgainSample.new_CosineRippleBox(length, width, height))

    def className(self):
        r"""className(CosineRippleBox self) -> std::string"""
        return _libBornAgainSample.CosineRippleBox_className(self)

    def contains(self, position):
        r"""contains(CosineRippleBox self, R3 const & position) -> bool"""
        return _libBornAgainSample.CosineRippleBox_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_CosineRippleBox

# Register CosineRippleBox in _libBornAgainSample:
_libBornAgainSample.CosineRippleBox_swigregister(CosineRippleBox)
class CosineRippleGauss(CosineRipple):
    r""" The form factor for a cosine ripple, with Gaussian profile in elongation direction."""

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

    def __init__(self, length, width, height):
        r"""__init__(CosineRippleGauss self, double length, double width, double height) -> CosineRippleGauss"""
        _libBornAgainSample.CosineRippleGauss_swiginit(self, _libBornAgainSample.new_CosineRippleGauss(length, width, height))

    def className(self):
        r"""className(CosineRippleGauss self) -> std::string"""
        return _libBornAgainSample.CosineRippleGauss_className(self)

    def contains(self, position):
        r"""contains(CosineRippleGauss self, R3 const & position) -> bool"""
        return _libBornAgainSample.CosineRippleGauss_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_CosineRippleGauss

# Register CosineRippleGauss in _libBornAgainSample:
_libBornAgainSample.CosineRippleGauss_swigregister(CosineRippleGauss)
class CosineRippleLorentz(CosineRipple):
    r""" The form factor for a cosine ripple, with Lorentz form factor in elongation direction."""

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

    def __init__(self, length, width, height):
        r"""__init__(CosineRippleLorentz self, double length, double width, double height) -> CosineRippleLorentz"""
        _libBornAgainSample.CosineRippleLorentz_swiginit(self, _libBornAgainSample.new_CosineRippleLorentz(length, width, height))

    def className(self):
        r"""className(CosineRippleLorentz self) -> std::string"""
        return _libBornAgainSample.CosineRippleLorentz_className(self)

    def contains(self, position):
        r"""contains(CosineRippleLorentz self, R3 const & position) -> bool"""
        return _libBornAgainSample.CosineRippleLorentz_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_CosineRippleLorentz

# Register CosineRippleLorentz in _libBornAgainSample:
_libBornAgainSample.CosineRippleLorentz_swigregister(CosineRippleLorentz)
class SawtoothRippleBox(SawtoothRipple):
    r""" The form factor for a cosine ripple, with box profile in elongation direction."""

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

    def __init__(self, length, width, height, asymmetry):
        r"""__init__(SawtoothRippleBox self, double length, double width, double height, double asymmetry) -> SawtoothRippleBox"""
        _libBornAgainSample.SawtoothRippleBox_swiginit(self, _libBornAgainSample.new_SawtoothRippleBox(length, width, height, asymmetry))

    def className(self):
        r"""className(SawtoothRippleBox self) -> std::string"""
        return _libBornAgainSample.SawtoothRippleBox_className(self)

    def contains(self, position):
        r"""contains(SawtoothRippleBox self, R3 const & position) -> bool"""
        return _libBornAgainSample.SawtoothRippleBox_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_SawtoothRippleBox

# Register SawtoothRippleBox in _libBornAgainSample:
_libBornAgainSample.SawtoothRippleBox_swigregister(SawtoothRippleBox)
class SawtoothRippleGauss(SawtoothRipple):
    r""" The form factor for a cosine ripple, with Gaussian profile in elongation direction."""

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

    def __init__(self, length, width, height, asymmetry):
        r"""__init__(SawtoothRippleGauss self, double length, double width, double height, double asymmetry) -> SawtoothRippleGauss"""
        _libBornAgainSample.SawtoothRippleGauss_swiginit(self, _libBornAgainSample.new_SawtoothRippleGauss(length, width, height, asymmetry))

    def className(self):
        r"""className(SawtoothRippleGauss self) -> std::string"""
        return _libBornAgainSample.SawtoothRippleGauss_className(self)

    def contains(self, position):
        r"""contains(SawtoothRippleGauss self, R3 const & position) -> bool"""
        return _libBornAgainSample.SawtoothRippleGauss_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_SawtoothRippleGauss

# Register SawtoothRippleGauss in _libBornAgainSample:
_libBornAgainSample.SawtoothRippleGauss_swigregister(SawtoothRippleGauss)
class SawtoothRippleLorentz(SawtoothRipple):
    r""" The form factor for a cosine ripple, with Lorentz form factor in elongation direction."""

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

    def __init__(self, length, width, height, asymmetry):
        r"""__init__(SawtoothRippleLorentz self, double length, double width, double height, double asymmetry) -> SawtoothRippleLorentz"""
        _libBornAgainSample.SawtoothRippleLorentz_swiginit(self, _libBornAgainSample.new_SawtoothRippleLorentz(length, width, height, asymmetry))

    def className(self):
        r"""className(SawtoothRippleLorentz self) -> std::string"""
        return _libBornAgainSample.SawtoothRippleLorentz_className(self)

    def contains(self, position):
        r"""contains(SawtoothRippleLorentz self, R3 const & position) -> bool"""
        return _libBornAgainSample.SawtoothRippleLorentz_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_SawtoothRippleLorentz

# Register SawtoothRippleLorentz in _libBornAgainSample:
_libBornAgainSample.SawtoothRippleLorentz_swigregister(SawtoothRippleLorentz)
class LongBoxGauss(HardFormfactor):
    r""" The form factor for a long rectangular box."""

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

    def __init__(self, length, width, height):
        r"""__init__(LongBoxGauss self, double length, double width, double height) -> LongBoxGauss"""
        _libBornAgainSample.LongBoxGauss_swiginit(self, _libBornAgainSample.new_LongBoxGauss(length, width, height))

    def className(self):
        r"""className(LongBoxGauss self) -> std::string"""
        return _libBornAgainSample.LongBoxGauss_className(self)

    def validate(self):
        r"""validate(LongBoxGauss self)"""
        return _libBornAgainSample.LongBoxGauss_validate(self)

    def length(self):
        r"""length(LongBoxGauss self) -> double"""
        return _libBornAgainSample.LongBoxGauss_length(self)

    def height(self):
        r"""height(LongBoxGauss self) -> double"""
        return _libBornAgainSample.LongBoxGauss_height(self)

    def width(self):
        r"""width(LongBoxGauss self) -> double"""
        return _libBornAgainSample.LongBoxGauss_width(self)

    def radialExtension(self):
        r"""radialExtension(LongBoxGauss self) -> double"""
        return _libBornAgainSample.LongBoxGauss_radialExtension(self)

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(LongBoxGauss self, C3 q) -> complex_t"""
        return _libBornAgainSample.LongBoxGauss_formfactorAtBottom(self, q)

    def contains(self, position):
        r"""contains(LongBoxGauss self, R3 const & position) -> bool"""
        return _libBornAgainSample.LongBoxGauss_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_LongBoxGauss

# Register LongBoxGauss in _libBornAgainSample:
_libBornAgainSample.LongBoxGauss_swigregister(LongBoxGauss)
class LongBoxLorentz(HardFormfactor):
    r""" The form factor for a long rectangular box."""

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

    def __init__(self, length, width, height):
        r"""__init__(LongBoxLorentz self, double length, double width, double height) -> LongBoxLorentz"""
        _libBornAgainSample.LongBoxLorentz_swiginit(self, _libBornAgainSample.new_LongBoxLorentz(length, width, height))

    def className(self):
        r"""className(LongBoxLorentz self) -> std::string"""
        return _libBornAgainSample.LongBoxLorentz_className(self)

    def length(self):
        r"""length(LongBoxLorentz self) -> double"""
        return _libBornAgainSample.LongBoxLorentz_length(self)

    def height(self):
        r"""height(LongBoxLorentz self) -> double"""
        return _libBornAgainSample.LongBoxLorentz_height(self)

    def width(self):
        r"""width(LongBoxLorentz self) -> double"""
        return _libBornAgainSample.LongBoxLorentz_width(self)

    def radialExtension(self):
        r"""radialExtension(LongBoxLorentz self) -> double"""
        return _libBornAgainSample.LongBoxLorentz_radialExtension(self)

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(LongBoxLorentz self, C3 q) -> complex_t"""
        return _libBornAgainSample.LongBoxLorentz_formfactorAtBottom(self, q)

    def validate(self):
        r"""validate(LongBoxLorentz self)"""
        return _libBornAgainSample.LongBoxLorentz_validate(self)

    def contains(self, position):
        r"""contains(LongBoxLorentz self, R3 const & position) -> bool"""
        return _libBornAgainSample.LongBoxLorentz_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_LongBoxLorentz

# Register LongBoxLorentz in _libBornAgainSample:
_libBornAgainSample.LongBoxLorentz_swigregister(LongBoxLorentz)
class GaussSphere(SoftFormfactor):
    r""" The form factor of a Gaussian sphere."""

    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 className(self):
        r"""className(GaussSphere self) -> std::string"""
        return _libBornAgainSample.GaussSphere_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_GaussSphere

# Register GaussSphere in _libBornAgainSample:
_libBornAgainSample.GaussSphere_swigregister(GaussSphere)
class FuzzySphere(SoftFormfactor):
    r""" A sphere with gaussian radius distribution."""

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

    def __init__(self, mean, sigma):
        r"""__init__(FuzzySphere self, double mean, double sigma) -> FuzzySphere"""
        _libBornAgainSample.FuzzySphere_swiginit(self, _libBornAgainSample.new_FuzzySphere(mean, sigma))

    def formfactorAtBottom(self, q):
        r"""formfactorAtBottom(FuzzySphere self, C3 q) -> complex_t"""
        return _libBornAgainSample.FuzzySphere_formfactorAtBottom(self, q)

    def className(self):
        r"""className(FuzzySphere self) -> std::string"""
        return _libBornAgainSample.FuzzySphere_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_FuzzySphere

# Register FuzzySphere in _libBornAgainSample:
_libBornAgainSample.FuzzySphere_swigregister(FuzzySphere)
class SelectionRule(object):
    r""" Abstract base class for selection rules."""

    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__ = _libBornAgainSample.delete_SelectionRule

    def coordinateSelected(self, coordinate):
        r"""coordinateSelected(SelectionRule self, I3 const & coordinate) -> bool"""
        return _libBornAgainSample.SelectionRule_coordinateSelected(self, coordinate)

    def isEqualTo(self, isr):
        r"""isEqualTo(SelectionRule self, SelectionRule isr) -> bool"""
        return _libBornAgainSample.SelectionRule_isEqualTo(self, isr)

    def __eq__(self, arg2):
        r"""__eq__(SelectionRule self, SelectionRule arg2) -> bool"""
        return _libBornAgainSample.SelectionRule___eq__(self, arg2)

# Register SelectionRule in _libBornAgainSample:
_libBornAgainSample.SelectionRule_swigregister(SelectionRule)
class SimpleSelectionRule(SelectionRule):
    r""" Selection rule (v*q)%modulus!=0, defined by vector v(a,b,c) and modulus."""

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

    def __init__(self, a, b, c, modulus):
        r"""__init__(SimpleSelectionRule self, int a, int b, int c, int modulus) -> SimpleSelectionRule"""
        _libBornAgainSample.SimpleSelectionRule_swiginit(self, _libBornAgainSample.new_SimpleSelectionRule(a, b, c, modulus))
    __swig_destroy__ = _libBornAgainSample.delete_SimpleSelectionRule

    def coordinateSelected(self, coordinate):
        r"""coordinateSelected(SimpleSelectionRule self, I3 const & coordinate) -> bool"""
        return _libBornAgainSample.SimpleSelectionRule_coordinateSelected(self, coordinate)

    def isEqualTo(self, isr):
        r"""isEqualTo(SimpleSelectionRule self, SelectionRule isr) -> bool"""
        return _libBornAgainSample.SimpleSelectionRule_isEqualTo(self, isr)

    def __eq__(self, other):
        r"""__eq__(SimpleSelectionRule self, SimpleSelectionRule other) -> bool"""
        return _libBornAgainSample.SimpleSelectionRule___eq__(self, other)

# Register SimpleSelectionRule in _libBornAgainSample:
_libBornAgainSample.SimpleSelectionRule_swigregister(SimpleSelectionRule)
class Lattice3D(object):
    r""" A Bravais lattice, characterized by three basis vectors, and optionally an SelectionRule."""

    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__(Lattice3D self, R3 const & a, R3 const & b, R3 const & c) -> Lattice3D
        __init__(Lattice3D self, Lattice3D lattice) -> Lattice3D
        """
        _libBornAgainSample.Lattice3D_swiginit(self, _libBornAgainSample.new_Lattice3D(*args))
    __swig_destroy__ = _libBornAgainSample.delete_Lattice3D

    def rotated(self, rotMatrix):
        r""" Creates rotated lattice"""
        return _libBornAgainSample.Lattice3D_rotated(self, rotMatrix)

    def basisVectorA(self):
        r""" Returns basis vector a"""
        return _libBornAgainSample.Lattice3D_basisVectorA(self)

    def basisVectorB(self):
        r""" Returns basis vector b"""
        return _libBornAgainSample.Lattice3D_basisVectorB(self)

    def basisVectorC(self):
        r""" Returns basis vector c"""
        return _libBornAgainSample.Lattice3D_basisVectorC(self)

    def millerDirection(self, h, k, l):
        r""" Returns normalized direction corresponding to the given Miller indices"""
        return _libBornAgainSample.Lattice3D_millerDirection(self, h, k, l)

    def unitCellVolume(self):
        r""" Returns the volume of the unit cell"""
        return _libBornAgainSample.Lattice3D_unitCellVolume(self)

    def reciprocalLatticeBasis(self, ra, rb, rc):
        r""" Returns the reciprocal basis vectors"""
        return _libBornAgainSample.Lattice3D_reciprocalLatticeBasis(self, ra, rb, rc)

    def setSelectionRule(self, selection_rule):
        r""" Sets a selection rule for the reciprocal vectors"""
        return _libBornAgainSample.Lattice3D_setSelectionRule(self, selection_rule)

# Register Lattice3D in _libBornAgainSample:
_libBornAgainSample.Lattice3D_swigregister(Lattice3D)
class ReciprocalBases(object):
    r""" A two-dimensional Bravais lattice."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_asx = property(_libBornAgainSample.ReciprocalBases_m_asx_get, _libBornAgainSample.ReciprocalBases_m_asx_set, doc=r""" x,y coordinates of a*""")
    m_asy = property(_libBornAgainSample.ReciprocalBases_m_asy_get, _libBornAgainSample.ReciprocalBases_m_asy_set, doc=r"""m_asy : double""")
    m_bsx = property(_libBornAgainSample.ReciprocalBases_m_bsx_get, _libBornAgainSample.ReciprocalBases_m_bsx_set, doc=r""" x,y coordinates of b*""")
    m_bsy = property(_libBornAgainSample.ReciprocalBases_m_bsy_get, _libBornAgainSample.ReciprocalBases_m_bsy_set, doc=r"""m_bsy : double""")

    def __init__(self):
        r"""__init__(ReciprocalBases self) -> ReciprocalBases"""
        _libBornAgainSample.ReciprocalBases_swiginit(self, _libBornAgainSample.new_ReciprocalBases())
    __swig_destroy__ = _libBornAgainSample.delete_ReciprocalBases

# Register ReciprocalBases in _libBornAgainSample:
_libBornAgainSample.ReciprocalBases_swigregister(ReciprocalBases)
class Lattice2D(object):
    r"""Proxy of C++ Lattice2D 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")
    __repr__ = _swig_repr
    __swig_destroy__ = _libBornAgainSample.delete_Lattice2D

# Register Lattice2D in _libBornAgainSample:
_libBornAgainSample.Lattice2D_swigregister(Lattice2D)
class BasicLattice2D(Lattice2D):
    r""" A two-dimensional Bravais lattice with no special symmetry."""

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

    def __init__(self, length1, length2, angle, xi):
        r"""__init__(BasicLattice2D self, double length1, double length2, double angle, double xi) -> BasicLattice2D"""
        _libBornAgainSample.BasicLattice2D_swiginit(self, _libBornAgainSample.new_BasicLattice2D(length1, length2, angle, xi))
    __swig_destroy__ = _libBornAgainSample.delete_BasicLattice2D

# Register BasicLattice2D in _libBornAgainSample:
_libBornAgainSample.BasicLattice2D_swigregister(BasicLattice2D)
class SquareLattice2D(Lattice2D):
    r""" A two-dimensional Bravais lattice with square unit cell."""

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

    def __init__(self, length, xi=0.0):
        r"""__init__(SquareLattice2D self, double length, double xi=0.0) -> SquareLattice2D"""
        _libBornAgainSample.SquareLattice2D_swiginit(self, _libBornAgainSample.new_SquareLattice2D(length, xi))
    __swig_destroy__ = _libBornAgainSample.delete_SquareLattice2D

# Register SquareLattice2D in _libBornAgainSample:
_libBornAgainSample.SquareLattice2D_swigregister(SquareLattice2D)
class HexagonalLattice2D(Lattice2D):
    r""" A two-dimensional Bravais lattice with hexagonal symmetry."""

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

    def __init__(self, length, xi):
        r"""__init__(HexagonalLattice2D self, double length, double xi) -> HexagonalLattice2D"""
        _libBornAgainSample.HexagonalLattice2D_swiginit(self, _libBornAgainSample.new_HexagonalLattice2D(length, xi))
    __swig_destroy__ = _libBornAgainSample.delete_HexagonalLattice2D

# Register HexagonalLattice2D in _libBornAgainSample:
_libBornAgainSample.HexagonalLattice2D_swigregister(HexagonalLattice2D)

def CubicLattice(a):
    r""" Returns a primitive cubic (cP) lattice with edge length a."""
    return _libBornAgainSample.CubicLattice(a)

def FCCLattice(a):
    r""" Returns a face-centered cubic (cF) lattice with edge length a."""
    return _libBornAgainSample.FCCLattice(a)

def HexagonalLattice(a, c):
    r""" Returns a primitive hexagonal (hP) lattice with hexagonal edge a and height c."""
    return _libBornAgainSample.HexagonalLattice(a, c)

def HCPLattice(a, c):
    r""" TODO: Clarify how this is meant: HCP is not a Bravais lattice."""
    return _libBornAgainSample.HCPLattice(a, c)

def TetragonalLattice(a, c):
    r""" Returns a primitive tetragonal (tP) lattice with square base edge a and height c."""
    return _libBornAgainSample.TetragonalLattice(a, c)

def BCTLattice(a, c):
    r""" Returns a body-centered cubic (cI) lattice with edge length a. TODO: Clarify meaning of c"""
    return _libBornAgainSample.BCTLattice(a, c)
class Particle(IParticle):
    r""" A particle with a form factor and refractive index."""

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

    def __init__(self, *args):
        r"""
        __init__(Particle self, Material const & material, Formfactor formfactor) -> Particle
        __init__(Particle self, Material const & material, PyObject * pyFormfactor) -> Particle
        """
        _libBornAgainSample.Particle_swiginit(self, _libBornAgainSample.new_Particle(*args))

# Register Particle in _libBornAgainSample:
_libBornAgainSample.Particle_swigregister(Particle)


class Particle(Particle):
    def __init__(self, material_, ff_):
        if isinstance(ff_, Formfactor):
            super().__init__(material_, ff_)
        elif hasattr(ff_, 'formfactor'):
            super().__init__(material_, ff_)
        else:
            raise TypeError("Particle: The given Python object is not a proper Formfactor. "
               "A minimal Formfactor object must have at least a 'formfactor' method "
               "which takes a 'C3' (vector) instance as argument and "
               "returns a complex or float.")



