# 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 R3(object):
    r"""Proxy of C++ Vec3< double > class."""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def rotatedZ(self, a):
        r"""rotatedZ(R3 self, double a) -> R3"""
        return _libBornAgainSample.R3_rotatedZ(self, a)
    __swig_destroy__ = _libBornAgainSample.delete_R3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def iterator(self):
        r"""iterator(vector_R3 self) -> SwigPyIterator"""
        return _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) -> R3
        """
        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, R3 x)
        """
        return _libBornAgainSample.vector_R3___setitem__(self, *args)

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

    def append(self, x):
        r"""append(vector_R3 self, R3 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, R3 value) -> vector_R3
        """
        _libBornAgainSample.vector_R3_swiginit(self, _libBornAgainSample.new_vector_R3(*args))

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

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

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

    def assign(self, n, x):
        r"""assign(vector_R3 self, std::vector< Vec3< double > >::size_type n, R3 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, R3 x)
        """
        return _libBornAgainSample.vector_R3_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(vector_R3 self, std::vector< Vec3< double > >::iterator pos, R3 x) -> std::vector< Vec3< double > >::iterator
        insert(vector_R3 self, std::vector< Vec3< double > >::iterator pos, std::vector< Vec3< double > >::size_type n, R3 x)
        """
        return _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)
import libBornAgainParam
class Material(object):
    r"""Proxy of C++ Material 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, material):
        r"""__init__(Material self, Material material) -> Material"""
        _libBornAgainSample.Material_swiginit(self, _libBornAgainSample.new_Material(material))

    def inverted(self):
        r"""inverted(Material self) -> Material"""
        return _libBornAgainSample.Material_inverted(self)

    def refractiveIndex(self, wavelength):
        r"""refractiveIndex(Material self, double wavelength) -> complex_t"""
        return _libBornAgainSample.Material_refractiveIndex(self, wavelength)

    def refractiveIndex2(self, wavelength):
        r"""refractiveIndex2(Material self, double wavelength) -> complex_t"""
        return _libBornAgainSample.Material_refractiveIndex2(self, wavelength)

    def isScalarMaterial(self):
        r"""isScalarMaterial(Material self) -> bool"""
        return _libBornAgainSample.Material_isScalarMaterial(self)

    def isMagneticMaterial(self):
        r"""isMagneticMaterial(Material self) -> bool"""
        return _libBornAgainSample.Material_isMagneticMaterial(self)

    def materialName(self):
        r"""materialName(Material self) -> std::string"""
        return _libBornAgainSample.Material_materialName(self)

    def magnetization(self):
        r"""magnetization(Material self) -> R3"""
        return _libBornAgainSample.Material_magnetization(self)

    def refractiveIndex_or_SLD(self):
        r"""refractiveIndex_or_SLD(Material self) -> complex_t"""
        return _libBornAgainSample.Material_refractiveIndex_or_SLD(self)

    def isEmpty(self):
        r"""isEmpty(Material self) -> bool"""
        return _libBornAgainSample.Material_isEmpty(self)

    def isDefaultMaterial(self):
        r"""isDefaultMaterial(Material self) -> bool"""
        return _libBornAgainSample.Material_isDefaultMaterial(self)

    def scalarSubtrSLD(self, wavevectors):
        r"""scalarSubtrSLD(Material self, WavevectorInfo const & wavevectors) -> complex_t"""
        return _libBornAgainSample.Material_scalarSubtrSLD(self, wavevectors)

    def polarizedSubtrSLD(self, wavevectors):
        r"""polarizedSubtrSLD(Material self, WavevectorInfo const & wavevectors) -> SpinMatrix"""
        return _libBornAgainSample.Material_polarizedSubtrSLD(self, wavevectors)

    def rotatedMaterial(self, transform):
        r"""rotatedMaterial(Material self, RotMatrix const & transform) -> Material"""
        return _libBornAgainSample.Material_rotatedMaterial(self, transform)
    __swig_destroy__ = _libBornAgainSample.delete_Material

# Register Material in _libBornAgainSample:
_libBornAgainSample.Material_swigregister(Material)

def RefractiveMaterial(*args):
    r"""
    RefractiveMaterial(std::string const & name, double delta, double beta, R3 magnetization={}) -> Material
    RefractiveMaterial(std::string const & name, complex_t refractive_index, R3 magnetization={}) -> Material
    """
    return _libBornAgainSample.RefractiveMaterial(*args)

def Vacuum():
    r"""Vacuum() -> Material"""
    return _libBornAgainSample.Vacuum()

def MaterialBySLD(*args):
    r"""
    MaterialBySLD(std::string const & name, double sld_real, double sld_imag, R3 magnetization={}) -> Material
    MaterialBySLD() -> Material
    """
    return _libBornAgainSample.MaterialBySLD(*args)
MATERIAL_TYPES_InvalidMaterialType = _libBornAgainSample.MATERIAL_TYPES_InvalidMaterialType

MATERIAL_TYPES_RefractiveMaterial = _libBornAgainSample.MATERIAL_TYPES_RefractiveMaterial

MATERIAL_TYPES_MaterialBySLD = _libBornAgainSample.MATERIAL_TYPES_MaterialBySLD

class IMaterialImpl(object):
    r"""Proxy of C++ IMaterialImpl 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_IMaterialImpl

    def inverted(self):
        r"""inverted(IMaterialImpl self) -> IMaterialImpl"""
        return _libBornAgainSample.IMaterialImpl_inverted(self)

    def refractiveIndex(self, wavelength):
        r"""refractiveIndex(IMaterialImpl self, double wavelength) -> complex_t"""
        return _libBornAgainSample.IMaterialImpl_refractiveIndex(self, wavelength)

    def refractiveIndex2(self, wavelength):
        r"""refractiveIndex2(IMaterialImpl self, double wavelength) -> complex_t"""
        return _libBornAgainSample.IMaterialImpl_refractiveIndex2(self, wavelength)

    def refractiveIndex_or_SLD(self):
        r"""refractiveIndex_or_SLD(IMaterialImpl self) -> complex_t"""
        return _libBornAgainSample.IMaterialImpl_refractiveIndex_or_SLD(self)

    def typeID(self):
        r"""typeID(IMaterialImpl self) -> MATERIAL_TYPES"""
        return _libBornAgainSample.IMaterialImpl_typeID(self)

    def scalarSubtrSLD(self, lambda0):
        r"""scalarSubtrSLD(IMaterialImpl self, double lambda0) -> complex_t"""
        return _libBornAgainSample.IMaterialImpl_scalarSubtrSLD(self, lambda0)

    def isScalarMaterial(self):
        r"""isScalarMaterial(IMaterialImpl self) -> bool"""
        return _libBornAgainSample.IMaterialImpl_isScalarMaterial(self)

    def isMagneticMaterial(self):
        r"""isMagneticMaterial(IMaterialImpl self) -> bool"""
        return _libBornAgainSample.IMaterialImpl_isMagneticMaterial(self)

    def magnetization(self):
        r"""magnetization(IMaterialImpl self) -> R3"""
        return _libBornAgainSample.IMaterialImpl_magnetization(self)

    def polarizedSubtrSLD(self, wavevectors):
        r"""polarizedSubtrSLD(IMaterialImpl self, WavevectorInfo const & wavevectors) -> SpinMatrix"""
        return _libBornAgainSample.IMaterialImpl_polarizedSubtrSLD(self, wavevectors)

    def rotatedMaterial(self, transform):
        r"""rotatedMaterial(IMaterialImpl self, RotMatrix const & transform) -> IMaterialImpl"""
        return _libBornAgainSample.IMaterialImpl_rotatedMaterial(self, transform)

    def _print(self):
        r"""_print(IMaterialImpl self) -> std::string"""
        return _libBornAgainSample.IMaterialImpl__print(self)

    def matName(self):
        r"""matName(IMaterialImpl self) -> std::string const &"""
        return _libBornAgainSample.IMaterialImpl_matName(self)

# Register IMaterialImpl in _libBornAgainSample:
_libBornAgainSample.IMaterialImpl_swigregister(IMaterialImpl)
class RefractiveMaterialImpl(IMaterialImpl):
    r"""Proxy of C++ RefractiveMaterialImpl 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_RefractiveMaterialImpl

    def refractiveIndex(self, wavelength):
        r"""refractiveIndex(RefractiveMaterialImpl self, double wavelength) -> complex_t"""
        return _libBornAgainSample.RefractiveMaterialImpl_refractiveIndex(self, wavelength)

    def refractiveIndex2(self, wavelength):
        r"""refractiveIndex2(RefractiveMaterialImpl self, double wavelength) -> complex_t"""
        return _libBornAgainSample.RefractiveMaterialImpl_refractiveIndex2(self, wavelength)

    def refractiveIndex_or_SLD(self):
        r"""refractiveIndex_or_SLD(RefractiveMaterialImpl self) -> complex_t"""
        return _libBornAgainSample.RefractiveMaterialImpl_refractiveIndex_or_SLD(self)

    def typeID(self):
        r"""typeID(RefractiveMaterialImpl self) -> MATERIAL_TYPES"""
        return _libBornAgainSample.RefractiveMaterialImpl_typeID(self)

    def scalarSubtrSLD(self, lambda0):
        r"""scalarSubtrSLD(RefractiveMaterialImpl self, double lambda0) -> complex_t"""
        return _libBornAgainSample.RefractiveMaterialImpl_scalarSubtrSLD(self, lambda0)

    def _print(self):
        r"""_print(RefractiveMaterialImpl self) -> std::string"""
        return _libBornAgainSample.RefractiveMaterialImpl__print(self)

# Register RefractiveMaterialImpl in _libBornAgainSample:
_libBornAgainSample.RefractiveMaterialImpl_swigregister(RefractiveMaterialImpl)
class MaterialBySLDImpl(IMaterialImpl):
    r"""Proxy of C++ MaterialBySLDImpl 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_MaterialBySLDImpl

    def refractiveIndex(self, wavelength):
        r"""refractiveIndex(MaterialBySLDImpl self, double wavelength) -> complex_t"""
        return _libBornAgainSample.MaterialBySLDImpl_refractiveIndex(self, wavelength)

    def refractiveIndex2(self, wavelength):
        r"""refractiveIndex2(MaterialBySLDImpl self, double wavelength) -> complex_t"""
        return _libBornAgainSample.MaterialBySLDImpl_refractiveIndex2(self, wavelength)

    def refractiveIndex_or_SLD(self):
        r"""refractiveIndex_or_SLD(MaterialBySLDImpl self) -> complex_t"""
        return _libBornAgainSample.MaterialBySLDImpl_refractiveIndex_or_SLD(self)

    def typeID(self):
        r"""typeID(MaterialBySLDImpl self) -> MATERIAL_TYPES"""
        return _libBornAgainSample.MaterialBySLDImpl_typeID(self)

    def scalarSubtrSLD(self, lambda0):
        r"""scalarSubtrSLD(MaterialBySLDImpl self, double lambda0) -> complex_t"""
        return _libBornAgainSample.MaterialBySLDImpl_scalarSubtrSLD(self, lambda0)

    def _print(self):
        r"""_print(MaterialBySLDImpl self) -> std::string"""
        return _libBornAgainSample.MaterialBySLDImpl__print(self)

# Register MaterialBySLDImpl in _libBornAgainSample:
_libBornAgainSample.MaterialBySLDImpl_swigregister(MaterialBySLDImpl)
class ISampleNode(libBornAgainParam.INode):
    r"""Proxy of C++ ISampleNode 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_ISampleNode

# Register ISampleNode in _libBornAgainSample:
_libBornAgainSample.ISampleNode_swigregister(ISampleNode)
class IFormfactor(ISampleNode):
    r"""Proxy of C++ IFormfactor 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_IFormfactor

    def volume(self):
        r"""volume(IFormfactor self) -> double"""
        return _libBornAgainSample.IFormfactor_volume(self)

    def radialExtension(self):
        r"""radialExtension(IFormfactor self) -> double"""
        return _libBornAgainSample.IFormfactor_radialExtension(self)

    def spanZ(self, rotation):
        r"""spanZ(IFormfactor self, IRotation rotation) -> Span"""
        return _libBornAgainSample.IFormfactor_spanZ(self, rotation)

    def canSliceAnalytically(self, rot):
        r"""canSliceAnalytically(IFormfactor self, IRotation rot) -> bool"""
        return _libBornAgainSample.IFormfactor_canSliceAnalytically(self, rot)

    def theFF(self, wavevectors):
        r"""theFF(IFormfactor self, WavevectorInfo const & wavevectors) -> complex_t"""
        return _libBornAgainSample.IFormfactor_theFF(self, wavevectors)

    def thePolFF(self, wavevectors):
        r"""thePolFF(IFormfactor self, WavevectorInfo const & wavevectors) -> SpinMatrix"""
        return _libBornAgainSample.IFormfactor_thePolFF(self, wavevectors)

    def formfactor_pol(self, q):
        r"""formfactor_pol(IFormfactor self, C3 q) -> SpinMatrix"""
        return _libBornAgainSample.IFormfactor_formfactor_pol(self, q)

    def formfactor(self, q):
        r"""formfactor(IFormfactor self, C3 q) -> complex_t"""
        return _libBornAgainSample.IFormfactor_formfactor(self, q)

    def contains(self, position):
        r"""contains(IFormfactor self, R3 position) -> bool"""
        return _libBornAgainSample.IFormfactor_contains(self, position)

    def isEqualTo(self, other):
        r"""isEqualTo(IFormfactor self, IFormfactor other) -> bool"""
        return _libBornAgainSample.IFormfactor_isEqualTo(self, other)

# Register IFormfactor in _libBornAgainSample:
_libBornAgainSample.IFormfactor_swigregister(IFormfactor)
class IRotation(libBornAgainParam.INode):
    r"""Proxy of C++ IRotation 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

    @staticmethod
    def createRotation(matrix):
        r"""createRotation(RotMatrix const & matrix) -> IRotation"""
        return _libBornAgainSample.IRotation_createRotation(matrix)

    def rotMatrix(self):
        r"""rotMatrix(IRotation self) -> RotMatrix"""
        return _libBornAgainSample.IRotation_rotMatrix(self)

    def transformed(self, v):
        r"""transformed(IRotation self, R3 v) -> R3"""
        return _libBornAgainSample.IRotation_transformed(self, v)

    def isIdentity(self):
        r"""isIdentity(IRotation self) -> bool"""
        return _libBornAgainSample.IRotation_isIdentity(self)

    def zInvariant(self):
        r"""zInvariant(IRotation self) -> bool"""
        return _libBornAgainSample.IRotation_zInvariant(self)
    __swig_destroy__ = _libBornAgainSample.delete_IRotation

# Register IRotation in _libBornAgainSample:
_libBornAgainSample.IRotation_swigregister(IRotation)

def createProduct(left, right):
    r"""createProduct(IRotation left, IRotation right) -> IRotation"""
    return _libBornAgainSample.createProduct(left, right)
class IdentityRotation(IRotation):
    r"""Proxy of C++ IdentityRotation 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__(IdentityRotation self) -> IdentityRotation"""
        _libBornAgainSample.IdentityRotation_swiginit(self, _libBornAgainSample.new_IdentityRotation())

    def className(self):
        r"""className(IdentityRotation self) -> std::string"""
        return _libBornAgainSample.IdentityRotation_className(self)

    def rotMatrix(self):
        r"""rotMatrix(IdentityRotation self) -> RotMatrix"""
        return _libBornAgainSample.IdentityRotation_rotMatrix(self)

    def isIdentity(self):
        r"""isIdentity(IdentityRotation self) -> bool"""
        return _libBornAgainSample.IdentityRotation_isIdentity(self)
    __swig_destroy__ = _libBornAgainSample.delete_IdentityRotation

# Register IdentityRotation in _libBornAgainSample:
_libBornAgainSample.IdentityRotation_swigregister(IdentityRotation)
class RotationX(IRotation):
    r"""Proxy of C++ RotationX 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__(RotationX self, vdouble1d_T P) -> RotationX
        __init__(RotationX self, double angle) -> RotationX
        """
        _libBornAgainSample.RotationX_swiginit(self, _libBornAgainSample.new_RotationX(*args))

    def className(self):
        r"""className(RotationX self) -> std::string"""
        return _libBornAgainSample.RotationX_className(self)

    def parDefs(self):
        r"""parDefs(RotationX self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.RotationX_parDefs(self)

    def angle(self):
        r"""angle(RotationX self) -> double"""
        return _libBornAgainSample.RotationX_angle(self)

    def rotMatrix(self):
        r"""rotMatrix(RotationX self) -> RotMatrix"""
        return _libBornAgainSample.RotationX_rotMatrix(self)
    __swig_destroy__ = _libBornAgainSample.delete_RotationX

# Register RotationX in _libBornAgainSample:
_libBornAgainSample.RotationX_swigregister(RotationX)
class RotationY(IRotation):
    r"""Proxy of C++ RotationY 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__(RotationY self, vdouble1d_T P) -> RotationY
        __init__(RotationY self, double angle) -> RotationY
        """
        _libBornAgainSample.RotationY_swiginit(self, _libBornAgainSample.new_RotationY(*args))

    def className(self):
        r"""className(RotationY self) -> std::string"""
        return _libBornAgainSample.RotationY_className(self)

    def parDefs(self):
        r"""parDefs(RotationY self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.RotationY_parDefs(self)

    def angle(self):
        r"""angle(RotationY self) -> double"""
        return _libBornAgainSample.RotationY_angle(self)

    def rotMatrix(self):
        r"""rotMatrix(RotationY self) -> RotMatrix"""
        return _libBornAgainSample.RotationY_rotMatrix(self)
    __swig_destroy__ = _libBornAgainSample.delete_RotationY

# Register RotationY in _libBornAgainSample:
_libBornAgainSample.RotationY_swigregister(RotationY)
class RotationZ(IRotation):
    r"""Proxy of C++ RotationZ 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__(RotationZ self, vdouble1d_T P) -> RotationZ
        __init__(RotationZ self, double angle) -> RotationZ
        """
        _libBornAgainSample.RotationZ_swiginit(self, _libBornAgainSample.new_RotationZ(*args))

    def className(self):
        r"""className(RotationZ self) -> std::string"""
        return _libBornAgainSample.RotationZ_className(self)

    def parDefs(self):
        r"""parDefs(RotationZ self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.RotationZ_parDefs(self)

    def angle(self):
        r"""angle(RotationZ self) -> double"""
        return _libBornAgainSample.RotationZ_angle(self)

    def rotMatrix(self):
        r"""rotMatrix(RotationZ self) -> RotMatrix"""
        return _libBornAgainSample.RotationZ_rotMatrix(self)
    __swig_destroy__ = _libBornAgainSample.delete_RotationZ

# Register RotationZ in _libBornAgainSample:
_libBornAgainSample.RotationZ_swigregister(RotationZ)
class RotationEuler(IRotation):
    r"""Proxy of C++ RotationEuler 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__(RotationEuler self, vdouble1d_T P) -> RotationEuler
        __init__(RotationEuler self, double alpha, double beta, double gamma) -> RotationEuler
        """
        _libBornAgainSample.RotationEuler_swiginit(self, _libBornAgainSample.new_RotationEuler(*args))

    def className(self):
        r"""className(RotationEuler self) -> std::string"""
        return _libBornAgainSample.RotationEuler_className(self)

    def parDefs(self):
        r"""parDefs(RotationEuler self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.RotationEuler_parDefs(self)

    def alpha(self):
        r"""alpha(RotationEuler self) -> double"""
        return _libBornAgainSample.RotationEuler_alpha(self)

    def beta(self):
        r"""beta(RotationEuler self) -> double"""
        return _libBornAgainSample.RotationEuler_beta(self)

    def gamma(self):
        r"""gamma(RotationEuler self) -> double"""
        return _libBornAgainSample.RotationEuler_gamma(self)

    def rotMatrix(self):
        r"""rotMatrix(RotationEuler self) -> RotMatrix"""
        return _libBornAgainSample.RotationEuler_rotMatrix(self)
    __swig_destroy__ = _libBornAgainSample.delete_RotationEuler

# Register RotationEuler in _libBornAgainSample:
_libBornAgainSample.RotationEuler_swigregister(RotationEuler)
class Crystal(ISampleNode):
    r"""Proxy of C++ Crystal 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, 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

    def className(self):
        r"""className(Crystal self) -> std::string"""
        return _libBornAgainSample.Crystal_className(self)

    def parDefs(self):
        r"""parDefs(Crystal self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Crystal_parDefs(self)

    def basis(self):
        r"""basis(Crystal self) -> IParticle"""
        return _libBornAgainSample.Crystal_basis(self)

    def lattice(self):
        r"""lattice(Crystal self) -> Lattice3D"""
        return _libBornAgainSample.Crystal_lattice(self)

    def position_variance(self):
        r"""position_variance(Crystal self) -> double"""
        return _libBornAgainSample.Crystal_position_variance(self)

    def transformed(self, translation, rotation):
        r"""transformed(Crystal self, R3 translation, IRotation rotation) -> Crystal"""
        return _libBornAgainSample.Crystal_transformed(self, translation, rotation)

    def validate(self):
        r"""validate(Crystal self) -> std::string"""
        return _libBornAgainSample.Crystal_validate(self)

# Register Crystal in _libBornAgainSample:
_libBornAgainSample.Crystal_swigregister(Crystal)
class IParticle(ISampleNode):
    r"""Proxy of C++ IParticle 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_IParticle

    def translate(self, *args):
        r"""
        translate(IParticle self, R3 translation) -> IParticle
        translate(IParticle self, double x, double y, double z) -> IParticle
        """
        return _libBornAgainSample.IParticle_translate(self, *args)

    def rotate(self, rotation):
        r"""rotate(IParticle self, IRotation rotation) -> IParticle"""
        return _libBornAgainSample.IParticle_rotate(self, rotation)

    def setAbundance(self, abundance):
        r"""setAbundance(IParticle self, double abundance)"""
        return _libBornAgainSample.IParticle_setAbundance(self, abundance)

# Register IParticle in _libBornAgainSample:
_libBornAgainSample.IParticle_swigregister(IParticle)
class Mesocrystal(IParticle):
    r"""Proxy of C++ Mesocrystal 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, crystal, formfactor):
        r"""__init__(Mesocrystal self, Crystal crystal, IFormfactor formfactor) -> Mesocrystal"""
        _libBornAgainSample.Mesocrystal_swiginit(self, _libBornAgainSample.new_Mesocrystal(crystal, formfactor))
    __swig_destroy__ = _libBornAgainSample.delete_Mesocrystal

    def className(self):
        r"""className(Mesocrystal self) -> std::string"""
        return _libBornAgainSample.Mesocrystal_className(self)

# Register Mesocrystal in _libBornAgainSample:
_libBornAgainSample.Mesocrystal_swigregister(Mesocrystal)
class Compound(IParticle):
    r"""Proxy of C++ Compound 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__(Compound self) -> Compound"""
        _libBornAgainSample.Compound_swiginit(self, _libBornAgainSample.new_Compound())
    __swig_destroy__ = _libBornAgainSample.delete_Compound

    def className(self):
        r"""className(Compound self) -> std::string"""
        return _libBornAgainSample.Compound_className(self)

    def addComponent(self, *args):
        r"""
        addComponent(Compound self, IParticle particle)
        addComponent(Compound self, IParticle particle, R3 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)

# Register Compound in _libBornAgainSample:
_libBornAgainSample.Compound_swigregister(Compound)
class CoreAndShell(IParticle):
    r"""Proxy of C++ CoreAndShell 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, core, shell):
        r"""__init__(CoreAndShell self, Particle core, Particle shell) -> CoreAndShell"""
        _libBornAgainSample.CoreAndShell_swiginit(self, _libBornAgainSample.new_CoreAndShell(core, shell))
    __swig_destroy__ = _libBornAgainSample.delete_CoreAndShell

    def className(self):
        r"""className(CoreAndShell self) -> std::string"""
        return _libBornAgainSample.CoreAndShell_className(self)

# Register CoreAndShell in _libBornAgainSample:
_libBornAgainSample.CoreAndShell_swigregister(CoreAndShell)
class IProfile1D(libBornAgainParam.INode):
    r"""Proxy of C++ IProfile1D 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 parDefs(self):
        r"""parDefs(IProfile1D self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.IProfile1D_parDefs(self)

    def standardizedFT(self, q):
        r"""standardizedFT(IProfile1D self, double q) -> double"""
        return _libBornAgainSample.IProfile1D_standardizedFT(self, q)

    def decayFT(self, q):
        r"""decayFT(IProfile1D self, double q) -> double"""
        return _libBornAgainSample.IProfile1D_decayFT(self, q)

    def omega(self):
        r"""omega(IProfile1D self) -> double"""
        return _libBornAgainSample.IProfile1D_omega(self)

    def decayLength(self):
        r"""decayLength(IProfile1D self) -> double"""
        return _libBornAgainSample.IProfile1D_decayLength(self)

    def qSecondDerivative(self):
        r"""qSecondDerivative(IProfile1D self) -> double"""
        return _libBornAgainSample.IProfile1D_qSecondDerivative(self)

    def validate(self):
        r"""validate(IProfile1D self) -> std::string"""
        return _libBornAgainSample.IProfile1D_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_IProfile1D

# Register IProfile1D in _libBornAgainSample:
_libBornAgainSample.IProfile1D_swigregister(IProfile1D)
class Profile1DCauchy(IProfile1D):
    r"""Proxy of C++ Profile1DCauchy 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__(Profile1DCauchy self, vdouble1d_T P) -> Profile1DCauchy
        __init__(Profile1DCauchy self, double omega) -> Profile1DCauchy
        """
        _libBornAgainSample.Profile1DCauchy_swiginit(self, _libBornAgainSample.new_Profile1DCauchy(*args))

    def className(self):
        r"""className(Profile1DCauchy self) -> std::string"""
        return _libBornAgainSample.Profile1DCauchy_className(self)

    def standardizedFT(self, q):
        r"""standardizedFT(Profile1DCauchy self, double q) -> double"""
        return _libBornAgainSample.Profile1DCauchy_standardizedFT(self, q)

    def decayFT(self, q):
        r"""decayFT(Profile1DCauchy self, double q) -> double"""
        return _libBornAgainSample.Profile1DCauchy_decayFT(self, q)

    def qSecondDerivative(self):
        r"""qSecondDerivative(Profile1DCauchy self) -> double"""
        return _libBornAgainSample.Profile1DCauchy_qSecondDerivative(self)
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DCauchy

# Register Profile1DCauchy in _libBornAgainSample:
_libBornAgainSample.Profile1DCauchy_swigregister(Profile1DCauchy)
class Profile1DGauss(IProfile1D):
    r"""Proxy of C++ Profile1DGauss 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__(Profile1DGauss self, vdouble1d_T P) -> Profile1DGauss
        __init__(Profile1DGauss self, double omega) -> Profile1DGauss
        """
        _libBornAgainSample.Profile1DGauss_swiginit(self, _libBornAgainSample.new_Profile1DGauss(*args))

    def className(self):
        r"""className(Profile1DGauss self) -> std::string"""
        return _libBornAgainSample.Profile1DGauss_className(self)

    def standardizedFT(self, q):
        r"""standardizedFT(Profile1DGauss self, double q) -> double"""
        return _libBornAgainSample.Profile1DGauss_standardizedFT(self, q)

    def decayFT(self, q):
        r"""decayFT(Profile1DGauss self, double q) -> double"""
        return _libBornAgainSample.Profile1DGauss_decayFT(self, q)

    def qSecondDerivative(self):
        r"""qSecondDerivative(Profile1DGauss self) -> double"""
        return _libBornAgainSample.Profile1DGauss_qSecondDerivative(self)
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DGauss

# Register Profile1DGauss in _libBornAgainSample:
_libBornAgainSample.Profile1DGauss_swigregister(Profile1DGauss)
class Profile1DGate(IProfile1D):
    r"""Proxy of C++ Profile1DGate 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__(Profile1DGate self, vdouble1d_T P) -> Profile1DGate
        __init__(Profile1DGate self, double omega) -> Profile1DGate
        """
        _libBornAgainSample.Profile1DGate_swiginit(self, _libBornAgainSample.new_Profile1DGate(*args))

    def className(self):
        r"""className(Profile1DGate self) -> std::string"""
        return _libBornAgainSample.Profile1DGate_className(self)

    def standardizedFT(self, q):
        r"""standardizedFT(Profile1DGate self, double q) -> double"""
        return _libBornAgainSample.Profile1DGate_standardizedFT(self, q)

    def decayFT(self, q):
        r"""decayFT(Profile1DGate self, double q) -> double"""
        return _libBornAgainSample.Profile1DGate_decayFT(self, q)

    def qSecondDerivative(self):
        r"""qSecondDerivative(Profile1DGate self) -> double"""
        return _libBornAgainSample.Profile1DGate_qSecondDerivative(self)
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DGate

# Register Profile1DGate in _libBornAgainSample:
_libBornAgainSample.Profile1DGate_swigregister(Profile1DGate)
class Profile1DTriangle(IProfile1D):
    r"""Proxy of C++ Profile1DTriangle 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__(Profile1DTriangle self, vdouble1d_T P) -> Profile1DTriangle
        __init__(Profile1DTriangle self, double omega) -> Profile1DTriangle
        """
        _libBornAgainSample.Profile1DTriangle_swiginit(self, _libBornAgainSample.new_Profile1DTriangle(*args))

    def className(self):
        r"""className(Profile1DTriangle self) -> std::string"""
        return _libBornAgainSample.Profile1DTriangle_className(self)

    def standardizedFT(self, q):
        r"""standardizedFT(Profile1DTriangle self, double q) -> double"""
        return _libBornAgainSample.Profile1DTriangle_standardizedFT(self, q)

    def decayFT(self, q):
        r"""decayFT(Profile1DTriangle self, double q) -> double"""
        return _libBornAgainSample.Profile1DTriangle_decayFT(self, q)

    def qSecondDerivative(self):
        r"""qSecondDerivative(Profile1DTriangle self) -> double"""
        return _libBornAgainSample.Profile1DTriangle_qSecondDerivative(self)
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DTriangle

# Register Profile1DTriangle in _libBornAgainSample:
_libBornAgainSample.Profile1DTriangle_swigregister(Profile1DTriangle)
class Profile1DCosine(IProfile1D):
    r"""Proxy of C++ Profile1DCosine 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__(Profile1DCosine self, vdouble1d_T P) -> Profile1DCosine
        __init__(Profile1DCosine self, double omega) -> Profile1DCosine
        """
        _libBornAgainSample.Profile1DCosine_swiginit(self, _libBornAgainSample.new_Profile1DCosine(*args))

    def className(self):
        r"""className(Profile1DCosine self) -> std::string"""
        return _libBornAgainSample.Profile1DCosine_className(self)

    def standardizedFT(self, q):
        r"""standardizedFT(Profile1DCosine self, double q) -> double"""
        return _libBornAgainSample.Profile1DCosine_standardizedFT(self, q)

    def decayFT(self, q):
        r"""decayFT(Profile1DCosine self, double q) -> double"""
        return _libBornAgainSample.Profile1DCosine_decayFT(self, q)

    def qSecondDerivative(self):
        r"""qSecondDerivative(Profile1DCosine self) -> double"""
        return _libBornAgainSample.Profile1DCosine_qSecondDerivative(self)
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DCosine

# Register Profile1DCosine in _libBornAgainSample:
_libBornAgainSample.Profile1DCosine_swigregister(Profile1DCosine)
class Profile1DVoigt(IProfile1D):
    r"""Proxy of C++ Profile1DVoigt 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__(Profile1DVoigt self, vdouble1d_T P) -> Profile1DVoigt
        __init__(Profile1DVoigt self, double omega, double eta) -> Profile1DVoigt
        """
        _libBornAgainSample.Profile1DVoigt_swiginit(self, _libBornAgainSample.new_Profile1DVoigt(*args))

    def className(self):
        r"""className(Profile1DVoigt self) -> std::string"""
        return _libBornAgainSample.Profile1DVoigt_className(self)

    def parDefs(self):
        r"""parDefs(Profile1DVoigt self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Profile1DVoigt_parDefs(self)

    def standardizedFT(self, q):
        r"""standardizedFT(Profile1DVoigt self, double q) -> double"""
        return _libBornAgainSample.Profile1DVoigt_standardizedFT(self, q)

    def decayFT(self, q):
        r"""decayFT(Profile1DVoigt self, double q) -> double"""
        return _libBornAgainSample.Profile1DVoigt_decayFT(self, q)

    def eta(self):
        r"""eta(Profile1DVoigt self) -> double"""
        return _libBornAgainSample.Profile1DVoigt_eta(self)

    def qSecondDerivative(self):
        r"""qSecondDerivative(Profile1DVoigt self) -> double"""
        return _libBornAgainSample.Profile1DVoigt_qSecondDerivative(self)

    def validate(self):
        r"""validate(Profile1DVoigt self) -> std::string"""
        return _libBornAgainSample.Profile1DVoigt_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_Profile1DVoigt

# Register Profile1DVoigt in _libBornAgainSample:
_libBornAgainSample.Profile1DVoigt_swigregister(Profile1DVoigt)
class IProfile2D(libBornAgainParam.INode):
    r"""Proxy of C++ IProfile2D 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 parDefs(self):
        r"""parDefs(IProfile2D self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.IProfile2D_parDefs(self)

    def omegaX(self):
        r"""omegaX(IProfile2D self) -> double"""
        return _libBornAgainSample.IProfile2D_omegaX(self)

    def omegaY(self):
        r"""omegaY(IProfile2D self) -> double"""
        return _libBornAgainSample.IProfile2D_omegaY(self)

    def decayLengthX(self):
        r"""decayLengthX(IProfile2D self) -> double"""
        return _libBornAgainSample.IProfile2D_decayLengthX(self)

    def decayLengthY(self):
        r"""decayLengthY(IProfile2D self) -> double"""
        return _libBornAgainSample.IProfile2D_decayLengthY(self)

    def gamma(self):
        r"""gamma(IProfile2D self) -> double"""
        return _libBornAgainSample.IProfile2D_gamma(self)

    def delta(self):
        r"""delta(IProfile2D self) -> double"""
        return _libBornAgainSample.IProfile2D_delta(self)

    def standardizedFT2D(self, qx, qy):
        r"""standardizedFT2D(IProfile2D self, double qx, double qy) -> double"""
        return _libBornAgainSample.IProfile2D_standardizedFT2D(self, qx, qy)

    def decayFT2D(self, qx, qy):
        r"""decayFT2D(IProfile2D self, double qx, double qy) -> double"""
        return _libBornAgainSample.IProfile2D_decayFT2D(self, qx, qy)

    def validate(self):
        r"""validate(IProfile2D self) -> std::string"""
        return _libBornAgainSample.IProfile2D_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_IProfile2D

# Register IProfile2D in _libBornAgainSample:
_libBornAgainSample.IProfile2D_swigregister(IProfile2D)
class Profile2DCauchy(IProfile2D):
    r"""Proxy of C++ Profile2DCauchy 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__(Profile2DCauchy self, vdouble1d_T P) -> Profile2DCauchy
        __init__(Profile2DCauchy self, double omega_x, double omega_y, double gamma) -> Profile2DCauchy
        """
        _libBornAgainSample.Profile2DCauchy_swiginit(self, _libBornAgainSample.new_Profile2DCauchy(*args))

    def className(self):
        r"""className(Profile2DCauchy self) -> std::string"""
        return _libBornAgainSample.Profile2DCauchy_className(self)

    def standardizedFT2D(self, qx, qy):
        r"""standardizedFT2D(Profile2DCauchy self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DCauchy_standardizedFT2D(self, qx, qy)

    def decayFT2D(self, qx, qy):
        r"""decayFT2D(Profile2DCauchy self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DCauchy_decayFT2D(self, qx, qy)
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DCauchy

# Register Profile2DCauchy in _libBornAgainSample:
_libBornAgainSample.Profile2DCauchy_swigregister(Profile2DCauchy)
class Profile2DGauss(IProfile2D):
    r"""Proxy of C++ Profile2DGauss 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__(Profile2DGauss self, vdouble1d_T P) -> Profile2DGauss
        __init__(Profile2DGauss self, double omega_x, double omega_y, double gamma) -> Profile2DGauss
        """
        _libBornAgainSample.Profile2DGauss_swiginit(self, _libBornAgainSample.new_Profile2DGauss(*args))

    def className(self):
        r"""className(Profile2DGauss self) -> std::string"""
        return _libBornAgainSample.Profile2DGauss_className(self)

    def standardizedFT2D(self, qx, qy):
        r"""standardizedFT2D(Profile2DGauss self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DGauss_standardizedFT2D(self, qx, qy)

    def decayFT2D(self, qx, qy):
        r"""decayFT2D(Profile2DGauss self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DGauss_decayFT2D(self, qx, qy)
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DGauss

# Register Profile2DGauss in _libBornAgainSample:
_libBornAgainSample.Profile2DGauss_swigregister(Profile2DGauss)
class Profile2DGate(IProfile2D):
    r"""Proxy of C++ Profile2DGate 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__(Profile2DGate self, vdouble1d_T P) -> Profile2DGate
        __init__(Profile2DGate self, double omega_x, double omega_y, double gamma) -> Profile2DGate
        """
        _libBornAgainSample.Profile2DGate_swiginit(self, _libBornAgainSample.new_Profile2DGate(*args))

    def className(self):
        r"""className(Profile2DGate self) -> std::string"""
        return _libBornAgainSample.Profile2DGate_className(self)

    def standardizedFT2D(self, qx, qy):
        r"""standardizedFT2D(Profile2DGate self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DGate_standardizedFT2D(self, qx, qy)

    def decayFT2D(self, qx, qy):
        r"""decayFT2D(Profile2DGate self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DGate_decayFT2D(self, qx, qy)
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DGate

# Register Profile2DGate in _libBornAgainSample:
_libBornAgainSample.Profile2DGate_swigregister(Profile2DGate)
class Profile2DCone(IProfile2D):
    r"""Proxy of C++ Profile2DCone 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__(Profile2DCone self, vdouble1d_T P) -> Profile2DCone
        __init__(Profile2DCone self, double omega_x, double omega_y, double gamma) -> Profile2DCone
        """
        _libBornAgainSample.Profile2DCone_swiginit(self, _libBornAgainSample.new_Profile2DCone(*args))

    def className(self):
        r"""className(Profile2DCone self) -> std::string"""
        return _libBornAgainSample.Profile2DCone_className(self)

    def standardizedFT2D(self, qx, qy):
        r"""standardizedFT2D(Profile2DCone self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DCone_standardizedFT2D(self, qx, qy)

    def decayFT2D(self, qx, qy):
        r"""decayFT2D(Profile2DCone self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DCone_decayFT2D(self, qx, qy)
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DCone

# Register Profile2DCone in _libBornAgainSample:
_libBornAgainSample.Profile2DCone_swigregister(Profile2DCone)
class Profile2DVoigt(IProfile2D):
    r"""Proxy of C++ Profile2DVoigt 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__(Profile2DVoigt self, vdouble1d_T P) -> Profile2DVoigt
        __init__(Profile2DVoigt self, double omega_x, double omega_y, double gamma, double eta) -> Profile2DVoigt
        """
        _libBornAgainSample.Profile2DVoigt_swiginit(self, _libBornAgainSample.new_Profile2DVoigt(*args))

    def className(self):
        r"""className(Profile2DVoigt self) -> std::string"""
        return _libBornAgainSample.Profile2DVoigt_className(self)

    def parDefs(self):
        r"""parDefs(Profile2DVoigt self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Profile2DVoigt_parDefs(self)

    def standardizedFT2D(self, qx, qy):
        r"""standardizedFT2D(Profile2DVoigt self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DVoigt_standardizedFT2D(self, qx, qy)

    def decayFT2D(self, qx, qy):
        r"""decayFT2D(Profile2DVoigt self, double qx, double qy) -> double"""
        return _libBornAgainSample.Profile2DVoigt_decayFT2D(self, qx, qy)

    def eta(self):
        r"""eta(Profile2DVoigt self) -> double"""
        return _libBornAgainSample.Profile2DVoigt_eta(self)

    def validate(self):
        r"""validate(Profile2DVoigt self) -> std::string"""
        return _libBornAgainSample.Profile2DVoigt_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_Profile2DVoigt

# Register Profile2DVoigt in _libBornAgainSample:
_libBornAgainSample.Profile2DVoigt_swigregister(Profile2DVoigt)
class IPeakShape(libBornAgainParam.INode):
    r"""Proxy of C++ IPeakShape 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_IPeakShape

    def peakDistribution(self, q, q_lattice_point):
        r"""peakDistribution(IPeakShape self, R3 q, R3 q_lattice_point) -> double"""
        return _libBornAgainSample.IPeakShape_peakDistribution(self, q, q_lattice_point)

    def angularDisorder(self):
        r"""angularDisorder(IPeakShape self) -> bool"""
        return _libBornAgainSample.IPeakShape_angularDisorder(self)

# Register IPeakShape in _libBornAgainSample:
_libBornAgainSample.IPeakShape_swigregister(IPeakShape)
class IsotropicGaussPeakShape(IPeakShape):
    r"""Proxy of C++ IsotropicGaussPeakShape 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, 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

    def className(self):
        r"""className(IsotropicGaussPeakShape self) -> std::string"""
        return _libBornAgainSample.IsotropicGaussPeakShape_className(self)

    def parDefs(self):
        r"""parDefs(IsotropicGaussPeakShape self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.IsotropicGaussPeakShape_parDefs(self)

    def peakDistribution(self, q, q_lattice_point):
        r"""peakDistribution(IsotropicGaussPeakShape self, R3 q, R3 q_lattice_point) -> double"""
        return _libBornAgainSample.IsotropicGaussPeakShape_peakDistribution(self, q, q_lattice_point)

# Register IsotropicGaussPeakShape in _libBornAgainSample:
_libBornAgainSample.IsotropicGaussPeakShape_swigregister(IsotropicGaussPeakShape)
class IsotropicLorentzPeakShape(IPeakShape):
    r"""Proxy of C++ IsotropicLorentzPeakShape 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, 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

    def className(self):
        r"""className(IsotropicLorentzPeakShape self) -> std::string"""
        return _libBornAgainSample.IsotropicLorentzPeakShape_className(self)

    def parDefs(self):
        r"""parDefs(IsotropicLorentzPeakShape self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.IsotropicLorentzPeakShape_parDefs(self)

    def peakDistribution(self, q, q_lattice_point):
        r"""peakDistribution(IsotropicLorentzPeakShape self, R3 q, R3 q_lattice_point) -> double"""
        return _libBornAgainSample.IsotropicLorentzPeakShape_peakDistribution(self, q, q_lattice_point)

# Register IsotropicLorentzPeakShape in _libBornAgainSample:
_libBornAgainSample.IsotropicLorentzPeakShape_swigregister(IsotropicLorentzPeakShape)
class GaussFisherPeakShape(IPeakShape):
    r"""Proxy of C++ GaussFisherPeakShape 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, 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

    def className(self):
        r"""className(GaussFisherPeakShape self) -> std::string"""
        return _libBornAgainSample.GaussFisherPeakShape_className(self)

    def parDefs(self):
        r"""parDefs(GaussFisherPeakShape self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.GaussFisherPeakShape_parDefs(self)

    def peakDistribution(self, q, q_lattice_point):
        r"""peakDistribution(GaussFisherPeakShape self, R3 q, R3 q_lattice_point) -> double"""
        return _libBornAgainSample.GaussFisherPeakShape_peakDistribution(self, q, q_lattice_point)

    def angularDisorder(self):
        r"""angularDisorder(GaussFisherPeakShape self) -> bool"""
        return _libBornAgainSample.GaussFisherPeakShape_angularDisorder(self)

# Register GaussFisherPeakShape in _libBornAgainSample:
_libBornAgainSample.GaussFisherPeakShape_swigregister(GaussFisherPeakShape)
class LorentzFisherPeakShape(IPeakShape):
    r"""Proxy of C++ LorentzFisherPeakShape 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, 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

    def className(self):
        r"""className(LorentzFisherPeakShape self) -> std::string"""
        return _libBornAgainSample.LorentzFisherPeakShape_className(self)

    def parDefs(self):
        r"""parDefs(LorentzFisherPeakShape self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.LorentzFisherPeakShape_parDefs(self)

    def peakDistribution(self, q, q_lattice_point):
        r"""peakDistribution(LorentzFisherPeakShape self, R3 q, R3 q_lattice_point) -> double"""
        return _libBornAgainSample.LorentzFisherPeakShape_peakDistribution(self, q, q_lattice_point)

    def angularDisorder(self):
        r"""angularDisorder(LorentzFisherPeakShape self) -> bool"""
        return _libBornAgainSample.LorentzFisherPeakShape_angularDisorder(self)

# Register LorentzFisherPeakShape in _libBornAgainSample:
_libBornAgainSample.LorentzFisherPeakShape_swigregister(LorentzFisherPeakShape)
class MisesFisherGaussPeakShape(IPeakShape):
    r"""Proxy of C++ MisesFisherGaussPeakShape 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, max_intensity, radial_size, zenith, kappa_1, kappa_2):
        r"""__init__(MisesFisherGaussPeakShape self, double max_intensity, double radial_size, R3 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

    def className(self):
        r"""className(MisesFisherGaussPeakShape self) -> std::string"""
        return _libBornAgainSample.MisesFisherGaussPeakShape_className(self)

    def parDefs(self):
        r"""parDefs(MisesFisherGaussPeakShape self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.MisesFisherGaussPeakShape_parDefs(self)

    def peakDistribution(self, q, q_lattice_point):
        r"""peakDistribution(MisesFisherGaussPeakShape self, R3 q, R3 q_lattice_point) -> double"""
        return _libBornAgainSample.MisesFisherGaussPeakShape_peakDistribution(self, q, q_lattice_point)

    def angularDisorder(self):
        r"""angularDisorder(MisesFisherGaussPeakShape self) -> bool"""
        return _libBornAgainSample.MisesFisherGaussPeakShape_angularDisorder(self)

# Register MisesFisherGaussPeakShape in _libBornAgainSample:
_libBornAgainSample.MisesFisherGaussPeakShape_swigregister(MisesFisherGaussPeakShape)
class MisesGaussPeakShape(IPeakShape):
    r"""Proxy of C++ MisesGaussPeakShape 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, max_intensity, radial_size, zenith, kappa):
        r"""__init__(MisesGaussPeakShape self, double max_intensity, double radial_size, R3 zenith, double kappa) -> MisesGaussPeakShape"""
        _libBornAgainSample.MisesGaussPeakShape_swiginit(self, _libBornAgainSample.new_MisesGaussPeakShape(max_intensity, radial_size, zenith, kappa))
    __swig_destroy__ = _libBornAgainSample.delete_MisesGaussPeakShape

    def className(self):
        r"""className(MisesGaussPeakShape self) -> std::string"""
        return _libBornAgainSample.MisesGaussPeakShape_className(self)

    def parDefs(self):
        r"""parDefs(MisesGaussPeakShape self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.MisesGaussPeakShape_parDefs(self)

    def peakDistribution(self, q, q_lattice_point):
        r"""peakDistribution(MisesGaussPeakShape self, R3 q, R3 q_lattice_point) -> double"""
        return _libBornAgainSample.MisesGaussPeakShape_peakDistribution(self, q, q_lattice_point)

    def angularDisorder(self):
        r"""angularDisorder(MisesGaussPeakShape self) -> bool"""
        return _libBornAgainSample.MisesGaussPeakShape_angularDisorder(self)

# Register MisesGaussPeakShape in _libBornAgainSample:
_libBornAgainSample.MisesGaussPeakShape_swigregister(MisesGaussPeakShape)
class IInterference(libBornAgainParam.INode):
    r"""Proxy of C++ IInterference 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 structureFactor(self, q, outer_iff=1.0):
        r"""structureFactor(IInterference self, R3 q, double outer_iff=1.0) -> double"""
        return _libBornAgainSample.IInterference_structureFactor(self, q, outer_iff)

    def setPositionVariance(self, var):
        r"""setPositionVariance(IInterference self, double var)"""
        return _libBornAgainSample.IInterference_setPositionVariance(self, var)

    def positionVariance(self):
        r"""positionVariance(IInterference self) -> double"""
        return _libBornAgainSample.IInterference_positionVariance(self)

    def particleDensity(self):
        r"""particleDensity(IInterference self) -> double"""
        return _libBornAgainSample.IInterference_particleDensity(self)

    def supportsMultilayer(self):
        r"""supportsMultilayer(IInterference self) -> bool"""
        return _libBornAgainSample.IInterference_supportsMultilayer(self)

    def DWfactor(self, q):
        r"""DWfactor(IInterference self, R3 q) -> double"""
        return _libBornAgainSample.IInterference_DWfactor(self, q)
    __swig_destroy__ = _libBornAgainSample.delete_IInterference

# Register IInterference in _libBornAgainSample:
_libBornAgainSample.IInterference_swigregister(IInterference)
class Interference1DLattice(IInterference):
    r"""Proxy of C++ Interference1DLattice 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, length, xi):
        r"""__init__(Interference1DLattice self, double length, double xi) -> Interference1DLattice"""
        _libBornAgainSample.Interference1DLattice_swiginit(self, _libBornAgainSample.new_Interference1DLattice(length, xi))
    __swig_destroy__ = _libBornAgainSample.delete_Interference1DLattice

    def className(self):
        r"""className(Interference1DLattice self) -> std::string"""
        return _libBornAgainSample.Interference1DLattice_className(self)

    def parDefs(self):
        r"""parDefs(Interference1DLattice self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Interference1DLattice_parDefs(self)

    def setDecayFunction(self, decay):
        r"""setDecayFunction(Interference1DLattice self, IProfile1D decay)"""
        return _libBornAgainSample.Interference1DLattice_setDecayFunction(self, decay)

    def length(self):
        r"""length(Interference1DLattice self) -> double"""
        return _libBornAgainSample.Interference1DLattice_length(self)

    def xi(self):
        r"""xi(Interference1DLattice self) -> double"""
        return _libBornAgainSample.Interference1DLattice_xi(self)

    def validate(self):
        r"""validate(Interference1DLattice self) -> std::string"""
        return _libBornAgainSample.Interference1DLattice_validate(self)

# Register Interference1DLattice in _libBornAgainSample:
_libBornAgainSample.Interference1DLattice_swigregister(Interference1DLattice)
class Interference2DLattice(IInterference):
    r"""Proxy of C++ Interference2DLattice 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, lattice):
        r"""__init__(Interference2DLattice self, Lattice2D lattice) -> Interference2DLattice"""
        _libBornAgainSample.Interference2DLattice_swiginit(self, _libBornAgainSample.new_Interference2DLattice(lattice))
    __swig_destroy__ = _libBornAgainSample.delete_Interference2DLattice

    def className(self):
        r"""className(Interference2DLattice self) -> std::string"""
        return _libBornAgainSample.Interference2DLattice_className(self)

    def setDecayFunction(self, decay):
        r"""setDecayFunction(Interference2DLattice self, IProfile2D decay)"""
        return _libBornAgainSample.Interference2DLattice_setDecayFunction(self, decay)

    def setIntegrationOverXi(self, integrate_xi):
        r"""setIntegrationOverXi(Interference2DLattice self, bool integrate_xi)"""
        return _libBornAgainSample.Interference2DLattice_setIntegrationOverXi(self, integrate_xi)

    def integrationOverXi(self):
        r"""integrationOverXi(Interference2DLattice self) -> bool"""
        return _libBornAgainSample.Interference2DLattice_integrationOverXi(self)

    def lattice(self):
        r"""lattice(Interference2DLattice self) -> Lattice2D"""
        return _libBornAgainSample.Interference2DLattice_lattice(self)

    def particleDensity(self):
        r"""particleDensity(Interference2DLattice self) -> double"""
        return _libBornAgainSample.Interference2DLattice_particleDensity(self)

# Register Interference2DLattice in _libBornAgainSample:
_libBornAgainSample.Interference2DLattice_swigregister(Interference2DLattice)
class Interference2DParacrystal(IInterference):
    r"""Proxy of C++ Interference2DParacrystal 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, lattice, damping_length, domain_size_1, domain_size_2):
        r"""__init__(Interference2DParacrystal self, Lattice2D lattice, double damping_length, double domain_size_1, double domain_size_2) -> Interference2DParacrystal"""
        _libBornAgainSample.Interference2DParacrystal_swiginit(self, _libBornAgainSample.new_Interference2DParacrystal(lattice, damping_length, domain_size_1, domain_size_2))
    __swig_destroy__ = _libBornAgainSample.delete_Interference2DParacrystal

    def className(self):
        r"""className(Interference2DParacrystal self) -> std::string"""
        return _libBornAgainSample.Interference2DParacrystal_className(self)

    def parDefs(self):
        r"""parDefs(Interference2DParacrystal self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Interference2DParacrystal_parDefs(self)

    def setDomainSizes(self, size_1, size_2):
        r"""setDomainSizes(Interference2DParacrystal self, double size_1, double size_2)"""
        return _libBornAgainSample.Interference2DParacrystal_setDomainSizes(self, size_1, size_2)

    def setProbabilityDistributions(self, pdf_1, pdf_2):
        r"""setProbabilityDistributions(Interference2DParacrystal self, IProfile2D pdf_1, IProfile2D pdf_2)"""
        return _libBornAgainSample.Interference2DParacrystal_setProbabilityDistributions(self, pdf_1, pdf_2)

    def setDampingLength(self, damping_length):
        r"""setDampingLength(Interference2DParacrystal self, double damping_length)"""
        return _libBornAgainSample.Interference2DParacrystal_setDampingLength(self, damping_length)

    def domainSizes(self):
        r"""domainSizes(Interference2DParacrystal self) -> vdouble1d_T"""
        return _libBornAgainSample.Interference2DParacrystal_domainSizes(self)

    def setIntegrationOverXi(self, integrate_xi):
        r"""setIntegrationOverXi(Interference2DParacrystal self, bool integrate_xi)"""
        return _libBornAgainSample.Interference2DParacrystal_setIntegrationOverXi(self, integrate_xi)

    def integrationOverXi(self):
        r"""integrationOverXi(Interference2DParacrystal self) -> bool"""
        return _libBornAgainSample.Interference2DParacrystal_integrationOverXi(self)

    def dampingLength(self):
        r"""dampingLength(Interference2DParacrystal self) -> double"""
        return _libBornAgainSample.Interference2DParacrystal_dampingLength(self)

    def lattice(self):
        r"""lattice(Interference2DParacrystal self) -> Lattice2D"""
        return _libBornAgainSample.Interference2DParacrystal_lattice(self)

    def particleDensity(self):
        r"""particleDensity(Interference2DParacrystal self) -> double"""
        return _libBornAgainSample.Interference2DParacrystal_particleDensity(self)

    def pdf1(self):
        r"""pdf1(Interference2DParacrystal self) -> IProfile2D"""
        return _libBornAgainSample.Interference2DParacrystal_pdf1(self)

    def pdf2(self):
        r"""pdf2(Interference2DParacrystal self) -> IProfile2D"""
        return _libBornAgainSample.Interference2DParacrystal_pdf2(self)

    def validate(self):
        r"""validate(Interference2DParacrystal self) -> std::string"""
        return _libBornAgainSample.Interference2DParacrystal_validate(self)

# Register Interference2DParacrystal in _libBornAgainSample:
_libBornAgainSample.Interference2DParacrystal_swigregister(Interference2DParacrystal)
class Interference2DSuperLattice(IInterference):
    r"""Proxy of C++ Interference2DSuperLattice 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__(Interference2DSuperLattice self, Lattice2D lattice, unsigned int size_1, unsigned int size_2) -> Interference2DSuperLattice
        __init__(Interference2DSuperLattice self, double length_1, double length_2, double alpha, double xi, unsigned int size_1, unsigned int size_2) -> Interference2DSuperLattice
        """
        _libBornAgainSample.Interference2DSuperLattice_swiginit(self, _libBornAgainSample.new_Interference2DSuperLattice(*args))
    __swig_destroy__ = _libBornAgainSample.delete_Interference2DSuperLattice

    def className(self):
        r"""className(Interference2DSuperLattice self) -> std::string"""
        return _libBornAgainSample.Interference2DSuperLattice_className(self)

    def parDefs(self):
        r"""parDefs(Interference2DSuperLattice self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Interference2DSuperLattice_parDefs(self)

    def setSubstructureIFF(self, sub_iff):
        r"""setSubstructureIFF(Interference2DSuperLattice self, IInterference sub_iff)"""
        return _libBornAgainSample.Interference2DSuperLattice_setSubstructureIFF(self, sub_iff)

    def substructureIFF(self):
        r"""substructureIFF(Interference2DSuperLattice self) -> IInterference"""
        return _libBornAgainSample.Interference2DSuperLattice_substructureIFF(self)

    def structureFactor(self, q, outer_iff=1.0):
        r"""structureFactor(Interference2DSuperLattice self, R3 q, double outer_iff=1.0) -> double"""
        return _libBornAgainSample.Interference2DSuperLattice_structureFactor(self, q, outer_iff)

    def domainSize1(self):
        r"""domainSize1(Interference2DSuperLattice self) -> unsigned int"""
        return _libBornAgainSample.Interference2DSuperLattice_domainSize1(self)

    def domainSize2(self):
        r"""domainSize2(Interference2DSuperLattice self) -> unsigned int"""
        return _libBornAgainSample.Interference2DSuperLattice_domainSize2(self)

    def setIntegrationOverXi(self, integrate_xi):
        r"""setIntegrationOverXi(Interference2DSuperLattice self, bool integrate_xi)"""
        return _libBornAgainSample.Interference2DSuperLattice_setIntegrationOverXi(self, integrate_xi)

    def integrationOverXi(self):
        r"""integrationOverXi(Interference2DSuperLattice self) -> bool"""
        return _libBornAgainSample.Interference2DSuperLattice_integrationOverXi(self)

    def lattice(self):
        r"""lattice(Interference2DSuperLattice self) -> Lattice2D"""
        return _libBornAgainSample.Interference2DSuperLattice_lattice(self)

# Register Interference2DSuperLattice in _libBornAgainSample:
_libBornAgainSample.Interference2DSuperLattice_swigregister(Interference2DSuperLattice)
class InterferenceFinite2DLattice(IInterference):
    r"""Proxy of C++ InterferenceFinite2DLattice 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, lattice, N_1, N_2):
        r"""__init__(InterferenceFinite2DLattice self, Lattice2D lattice, unsigned int N_1, unsigned int N_2) -> InterferenceFinite2DLattice"""
        _libBornAgainSample.InterferenceFinite2DLattice_swiginit(self, _libBornAgainSample.new_InterferenceFinite2DLattice(lattice, N_1, N_2))
    __swig_destroy__ = _libBornAgainSample.delete_InterferenceFinite2DLattice

    def className(self):
        r"""className(InterferenceFinite2DLattice self) -> std::string"""
        return _libBornAgainSample.InterferenceFinite2DLattice_className(self)

    def numberUnitCells1(self):
        r"""numberUnitCells1(InterferenceFinite2DLattice self) -> unsigned int"""
        return _libBornAgainSample.InterferenceFinite2DLattice_numberUnitCells1(self)

    def numberUnitCells2(self):
        r"""numberUnitCells2(InterferenceFinite2DLattice self) -> unsigned int"""
        return _libBornAgainSample.InterferenceFinite2DLattice_numberUnitCells2(self)

    def setIntegrationOverXi(self, integrate_xi):
        r"""setIntegrationOverXi(InterferenceFinite2DLattice self, bool integrate_xi)"""
        return _libBornAgainSample.InterferenceFinite2DLattice_setIntegrationOverXi(self, integrate_xi)

    def integrationOverXi(self):
        r"""integrationOverXi(InterferenceFinite2DLattice self) -> bool"""
        return _libBornAgainSample.InterferenceFinite2DLattice_integrationOverXi(self)

    def lattice(self):
        r"""lattice(InterferenceFinite2DLattice self) -> Lattice2D"""
        return _libBornAgainSample.InterferenceFinite2DLattice_lattice(self)

    def particleDensity(self):
        r"""particleDensity(InterferenceFinite2DLattice self) -> double"""
        return _libBornAgainSample.InterferenceFinite2DLattice_particleDensity(self)

# Register InterferenceFinite2DLattice in _libBornAgainSample:
_libBornAgainSample.InterferenceFinite2DLattice_swigregister(InterferenceFinite2DLattice)
class InterferenceHardDisk(IInterference):
    r"""Proxy of C++ InterferenceHardDisk 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, radius, density, position_var=0):
        r"""__init__(InterferenceHardDisk self, double radius, double density, double position_var=0) -> InterferenceHardDisk"""
        _libBornAgainSample.InterferenceHardDisk_swiginit(self, _libBornAgainSample.new_InterferenceHardDisk(radius, density, position_var))
    __swig_destroy__ = _libBornAgainSample.delete_InterferenceHardDisk

    def parDefs(self):
        r"""parDefs(InterferenceHardDisk self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.InterferenceHardDisk_parDefs(self)

    def className(self):
        r"""className(InterferenceHardDisk self) -> std::string"""
        return _libBornAgainSample.InterferenceHardDisk_className(self)

    def particleDensity(self):
        r"""particleDensity(InterferenceHardDisk self) -> double"""
        return _libBornAgainSample.InterferenceHardDisk_particleDensity(self)

    def radius(self):
        r"""radius(InterferenceHardDisk self) -> double"""
        return _libBornAgainSample.InterferenceHardDisk_radius(self)

    def density(self):
        r"""density(InterferenceHardDisk self) -> double"""
        return _libBornAgainSample.InterferenceHardDisk_density(self)

    def validate(self):
        r"""validate(InterferenceHardDisk self) -> std::string"""
        return _libBornAgainSample.InterferenceHardDisk_validate(self)

# Register InterferenceHardDisk in _libBornAgainSample:
_libBornAgainSample.InterferenceHardDisk_swigregister(InterferenceHardDisk)
class InterferenceNone(IInterference):
    r"""Proxy of C++ InterferenceNone 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__(InterferenceNone self) -> InterferenceNone"""
        _libBornAgainSample.InterferenceNone_swiginit(self, _libBornAgainSample.new_InterferenceNone())

    def className(self):
        r"""className(InterferenceNone self) -> std::string"""
        return _libBornAgainSample.InterferenceNone_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_InterferenceNone

# Register InterferenceNone in _libBornAgainSample:
_libBornAgainSample.InterferenceNone_swigregister(InterferenceNone)
class InterferenceRadialParacrystal(IInterference):
    r"""Proxy of C++ InterferenceRadialParacrystal 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, peak_distance, damping_length):
        r"""__init__(InterferenceRadialParacrystal self, double peak_distance, double damping_length) -> InterferenceRadialParacrystal"""
        _libBornAgainSample.InterferenceRadialParacrystal_swiginit(self, _libBornAgainSample.new_InterferenceRadialParacrystal(peak_distance, damping_length))

    def className(self):
        r"""className(InterferenceRadialParacrystal self) -> std::string"""
        return _libBornAgainSample.InterferenceRadialParacrystal_className(self)

    def parDefs(self):
        r"""parDefs(InterferenceRadialParacrystal self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.InterferenceRadialParacrystal_parDefs(self)

    def setKappa(self, kappa):
        r"""setKappa(InterferenceRadialParacrystal self, double kappa)"""
        return _libBornAgainSample.InterferenceRadialParacrystal_setKappa(self, kappa)

    def kappa(self):
        r"""kappa(InterferenceRadialParacrystal self) -> double"""
        return _libBornAgainSample.InterferenceRadialParacrystal_kappa(self)

    def setDomainSize(self, size):
        r"""setDomainSize(InterferenceRadialParacrystal self, double size)"""
        return _libBornAgainSample.InterferenceRadialParacrystal_setDomainSize(self, size)

    def domainSize(self):
        r"""domainSize(InterferenceRadialParacrystal self) -> double"""
        return _libBornAgainSample.InterferenceRadialParacrystal_domainSize(self)

    def FTPDF(self, qpar):
        r"""FTPDF(InterferenceRadialParacrystal self, double qpar) -> complex_t"""
        return _libBornAgainSample.InterferenceRadialParacrystal_FTPDF(self, qpar)

    def setProbabilityDistribution(self, pdf):
        r"""setProbabilityDistribution(InterferenceRadialParacrystal self, IProfile1D pdf)"""
        return _libBornAgainSample.InterferenceRadialParacrystal_setProbabilityDistribution(self, pdf)

    def peakDistance(self):
        r"""peakDistance(InterferenceRadialParacrystal self) -> double"""
        return _libBornAgainSample.InterferenceRadialParacrystal_peakDistance(self)

    def dampingLength(self):
        r"""dampingLength(InterferenceRadialParacrystal self) -> double"""
        return _libBornAgainSample.InterferenceRadialParacrystal_dampingLength(self)

    def randomSample(self, seed):
        r"""randomSample(InterferenceRadialParacrystal self, int seed) -> double"""
        return _libBornAgainSample.InterferenceRadialParacrystal_randomSample(self, seed)

    def validate(self):
        r"""validate(InterferenceRadialParacrystal self) -> std::string"""
        return _libBornAgainSample.InterferenceRadialParacrystal_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_InterferenceRadialParacrystal

# Register InterferenceRadialParacrystal in _libBornAgainSample:
_libBornAgainSample.InterferenceRadialParacrystal_swigregister(InterferenceRadialParacrystal)
class ParticleLayout(ISampleNode):
    r"""Proxy of C++ ParticleLayout 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__(ParticleLayout self) -> ParticleLayout
        __init__(ParticleLayout self, IParticle particle) -> ParticleLayout
        """
        _libBornAgainSample.ParticleLayout_swiginit(self, _libBornAgainSample.new_ParticleLayout(*args))
    __swig_destroy__ = _libBornAgainSample.delete_ParticleLayout

    def className(self):
        r"""className(ParticleLayout self) -> std::string"""
        return _libBornAgainSample.ParticleLayout_className(self)

    def addParticle(self, particle, abundance=-1.0):
        r"""addParticle(ParticleLayout self, IParticle particle, double abundance=-1.0)"""
        return _libBornAgainSample.ParticleLayout_addParticle(self, particle, abundance)

    def setInterference(self, interparticle):
        r"""setInterference(ParticleLayout self, IInterference interparticle)"""
        return _libBornAgainSample.ParticleLayout_setInterference(self, interparticle)

    def setTotalParticleSurfaceDensity(self, particle_density):
        r"""setTotalParticleSurfaceDensity(ParticleLayout self, double particle_density)"""
        return _libBornAgainSample.ParticleLayout_setTotalParticleSurfaceDensity(self, particle_density)

    def setAbsoluteWeight(self, weight):
        r"""setAbsoluteWeight(ParticleLayout self, double weight)"""
        return _libBornAgainSample.ParticleLayout_setAbsoluteWeight(self, weight)

# Register ParticleLayout in _libBornAgainSample:
_libBornAgainSample.ParticleLayout_swigregister(ParticleLayout)
class Roughness(ISampleNode):
    r"""Proxy of C++ Roughness 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, 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))

    def className(self):
        r"""className(Roughness self) -> std::string"""
        return _libBornAgainSample.Roughness_className(self)

    def autocorrelationModel(self):
        r"""autocorrelationModel(Roughness self) -> AutocorrelationModel"""
        return _libBornAgainSample.Roughness_autocorrelationModel(self)

    def transient(self):
        r"""transient(Roughness self) -> TransientModel"""
        return _libBornAgainSample.Roughness_transient(self)

    def crosscorrelationModel(self):
        r"""crosscorrelationModel(Roughness self) -> CrosscorrelationModel"""
        return _libBornAgainSample.Roughness_crosscorrelationModel(self)
    __swig_destroy__ = _libBornAgainSample.delete_Roughness

# Register Roughness in _libBornAgainSample:
_libBornAgainSample.Roughness_swigregister(Roughness)
class RoughnessMap(object):
    r"""Proxy of C++ RoughnessMap 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, x_points, y_points, Lx, Ly, sample, i_layer, seed=-1):
        r"""__init__(RoughnessMap self, size_t x_points, size_t y_points, double Lx, double Ly, Sample sample, int i_layer, int seed=-1) -> RoughnessMap"""
        _libBornAgainSample.RoughnessMap_swiginit(self, _libBornAgainSample.new_RoughnessMap(x_points, y_points, Lx, Ly, sample, i_layer, seed))

    def generateMap(self):
        r"""generateMap(RoughnessMap self) -> double2d_t"""
        return _libBornAgainSample.RoughnessMap_generateMap(self)

    def generate(self):
        r"""generate(RoughnessMap self) -> Arrayf64Wrapper"""
        return _libBornAgainSample.RoughnessMap_generate(self)
    __swig_destroy__ = _libBornAgainSample.delete_RoughnessMap

# Register RoughnessMap in _libBornAgainSample:
_libBornAgainSample.RoughnessMap_swigregister(RoughnessMap)
class ILayer(ISampleNode):
    r"""Proxy of C++ ILayer 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 checkMaterials(self, wavelength):
        r"""checkMaterials(ILayer self, double wavelength)"""
        return _libBornAgainSample.ILayer_checkMaterials(self, wavelength)
    __swig_destroy__ = _libBornAgainSample.delete_ILayer

# Register ILayer in _libBornAgainSample:
_libBornAgainSample.ILayer_swigregister(ILayer)
class Layer(ILayer):
    r"""Proxy of C++ Layer 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__(Layer self, Material material, double thickness=0, Roughness roughness=None) -> Layer
        __init__(Layer self, Material material, Roughness roughness) -> Layer
        """
        _libBornAgainSample.Layer_swiginit(self, _libBornAgainSample.new_Layer(*args))
    __swig_destroy__ = _libBornAgainSample.delete_Layer

    def className(self):
        r"""className(Layer self) -> std::string"""
        return _libBornAgainSample.Layer_className(self)

    def checkMaterials(self, wavelength):
        r"""checkMaterials(Layer self, double wavelength)"""
        return _libBornAgainSample.Layer_checkMaterials(self, wavelength)

    def addLayout(self, layout):
        r"""addLayout(Layer self, ParticleLayout layout)"""
        return _libBornAgainSample.Layer_addLayout(self, layout)

    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, numRepetitions=1):
        r"""__init__(LayerStack self, size_t numRepetitions=1) -> LayerStack"""
        _libBornAgainSample.LayerStack_swiginit(self, _libBornAgainSample.new_LayerStack(numRepetitions))
    __swig_destroy__ = _libBornAgainSample.delete_LayerStack

    def className(self):
        r"""className(LayerStack self) -> std::string"""
        return _libBornAgainSample.LayerStack_className(self)

    def checkMaterials(self, wavelength):
        r"""checkMaterials(LayerStack self, double wavelength)"""
        return _libBornAgainSample.LayerStack_checkMaterials(self, wavelength)

    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)

    def setNumberOfPeriods(self, n):
        r"""setNumberOfPeriods(LayerStack self, size_t n)"""
        return _libBornAgainSample.LayerStack_setNumberOfPeriods(self, n)

    def numberOfPeriods(self):
        r"""numberOfPeriods(LayerStack self) -> size_t"""
        return _libBornAgainSample.LayerStack_numberOfPeriods(self)

# Register LayerStack in _libBornAgainSample:
_libBornAgainSample.LayerStack_swigregister(LayerStack)
class Sample(ISampleNode):
    r"""Proxy of C++ Sample 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__(Sample self) -> Sample"""
        _libBornAgainSample.Sample_swiginit(self, _libBornAgainSample.new_Sample())
    __swig_destroy__ = _libBornAgainSample.delete_Sample

    def className(self):
        r"""className(Sample self) -> std::string"""
        return _libBornAgainSample.Sample_className(self)

    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"""setExternalField(Sample self, R3 ext_field)"""
        return _libBornAgainSample.Sample_setExternalField(self, ext_field)

    def setName(self, name):
        r"""setName(Sample self, std::string const & name)"""
        return _libBornAgainSample.Sample_setName(self, name)

    def roughnessSpectrum(self, spatial_f, i_layer):
        r"""roughnessSpectrum(Sample self, double spatial_f, int i_layer) -> double"""
        return _libBornAgainSample.Sample_roughnessSpectrum(self, spatial_f, i_layer)

    def roughnessRMS(self, i_layer):
        r"""roughnessRMS(Sample self, size_t i_layer) -> double"""
        return _libBornAgainSample.Sample_roughnessRMS(self, i_layer)

# Register Sample in _libBornAgainSample:
_libBornAgainSample.Sample_swigregister(Sample)
class AutocorrelationModel(libBornAgainParam.INode):
    r"""Proxy of C++ AutocorrelationModel 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 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)

    def parDefs(self):
        r"""parDefs(AutocorrelationModel self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.AutocorrelationModel_parDefs(self)
    __swig_destroy__ = _libBornAgainSample.delete_AutocorrelationModel

# Register AutocorrelationModel in _libBornAgainSample:
_libBornAgainSample.AutocorrelationModel_swigregister(AutocorrelationModel)
class SelfAffineFractalModel(AutocorrelationModel):
    r"""Proxy of C++ SelfAffineFractalModel 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, 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 className(self):
        r"""className(SelfAffineFractalModel self) -> std::string"""
        return _libBornAgainSample.SelfAffineFractalModel_className(self)

    def parDefs(self):
        r"""parDefs(SelfAffineFractalModel self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SelfAffineFractalModel_parDefs(self)

    def validate(self):
        r"""validate(SelfAffineFractalModel self) -> std::string"""
        return _libBornAgainSample.SelfAffineFractalModel_validate(self)

    def spectralFunction(self, spatial_f):
        r"""spectralFunction(SelfAffineFractalModel self, double spatial_f) -> double"""
        return _libBornAgainSample.SelfAffineFractalModel_spectralFunction(self, spatial_f)

    def rms(self):
        r"""rms(SelfAffineFractalModel self) -> double"""
        return _libBornAgainSample.SelfAffineFractalModel_rms(self)

    def setSigma(self, sigma):
        r"""setSigma(SelfAffineFractalModel self, double sigma)"""
        return _libBornAgainSample.SelfAffineFractalModel_setSigma(self, sigma)

    def sigma(self):
        r"""sigma(SelfAffineFractalModel self) -> double"""
        return _libBornAgainSample.SelfAffineFractalModel_sigma(self)

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

    def hurst(self):
        r"""hurst(SelfAffineFractalModel self) -> double"""
        return _libBornAgainSample.SelfAffineFractalModel_hurst(self)

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

    def lateralCorrLength(self):
        r"""lateralCorrLength(SelfAffineFractalModel self) -> double"""
        return _libBornAgainSample.SelfAffineFractalModel_lateralCorrLength(self)
    __swig_destroy__ = _libBornAgainSample.delete_SelfAffineFractalModel

# Register SelfAffineFractalModel in _libBornAgainSample:
_libBornAgainSample.SelfAffineFractalModel_swigregister(SelfAffineFractalModel)
class LinearGrowthModel(AutocorrelationModel):
    r"""Proxy of C++ LinearGrowthModel 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, 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 className(self):
        r"""className(LinearGrowthModel self) -> std::string"""
        return _libBornAgainSample.LinearGrowthModel_className(self)

    def parDefs(self):
        r"""parDefs(LinearGrowthModel self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.LinearGrowthModel_parDefs(self)

    def validate(self):
        r"""validate(LinearGrowthModel self) -> std::string"""
        return _libBornAgainSample.LinearGrowthModel_validate(self)

    def spectralFunction(self, spectrum_below, thickness, spatial_f):
        r"""spectralFunction(LinearGrowthModel self, double spectrum_below, double thickness, double spatial_f) -> double"""
        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 damp1(self):
        r"""damp1(LinearGrowthModel self) -> double"""
        return _libBornAgainSample.LinearGrowthModel_damp1(self)

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

    def damp2(self):
        r"""damp2(LinearGrowthModel self) -> double"""
        return _libBornAgainSample.LinearGrowthModel_damp2(self)

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

    def damp3(self):
        r"""damp3(LinearGrowthModel self) -> double"""
        return _libBornAgainSample.LinearGrowthModel_damp3(self)

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

    def damp4(self):
        r"""damp4(LinearGrowthModel self) -> double"""
        return _libBornAgainSample.LinearGrowthModel_damp4(self)
    __swig_destroy__ = _libBornAgainSample.delete_LinearGrowthModel

# Register LinearGrowthModel in _libBornAgainSample:
_libBornAgainSample.LinearGrowthModel_swigregister(LinearGrowthModel)
class TransientModel(libBornAgainParam.INode):
    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 - class is abstract")
    __repr__ = _swig_repr

    def transient(self, x, sigma):
        r"""transient(TransientModel self, double x, double sigma) -> double"""
        return _libBornAgainSample.TransientModel_transient(self, x, sigma)

    def distribution(self, x, sigma):
        r"""distribution(TransientModel self, double x, double sigma) -> double"""
        return _libBornAgainSample.TransientModel_distribution(self, x, sigma)

    def sigmaRange(self):
        r"""sigmaRange(TransientModel self) -> double"""
        return _libBornAgainSample.TransientModel_sigmaRange(self)
    __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())

    def transient(self, x, sigma):
        r"""transient(ErfTransient self, double x, double sigma) -> double"""
        return _libBornAgainSample.ErfTransient_transient(self, x, sigma)

    def distribution(self, x, sigma):
        r"""distribution(ErfTransient self, double x, double sigma) -> double"""
        return _libBornAgainSample.ErfTransient_distribution(self, x, sigma)

    def sigmaRange(self):
        r"""sigmaRange(ErfTransient self) -> double"""
        return _libBornAgainSample.ErfTransient_sigmaRange(self)

    def className(self):
        r"""className(ErfTransient self) -> std::string"""
        return _libBornAgainSample.ErfTransient_className(self)
    __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())

    def transient(self, x, sigma):
        r"""transient(TanhTransient self, double x, double sigma) -> double"""
        return _libBornAgainSample.TanhTransient_transient(self, x, sigma)

    def distribution(self, x, sigma):
        r"""distribution(TanhTransient self, double x, double sigma) -> double"""
        return _libBornAgainSample.TanhTransient_distribution(self, x, sigma)

    def sigmaRange(self):
        r"""sigmaRange(TanhTransient self) -> double"""
        return _libBornAgainSample.TanhTransient_sigmaRange(self)

    def className(self):
        r"""className(TanhTransient self) -> std::string"""
        return _libBornAgainSample.TanhTransient_className(self)
    __swig_destroy__ = _libBornAgainSample.delete_TanhTransient

# Register TanhTransient in _libBornAgainSample:
_libBornAgainSample.TanhTransient_swigregister(TanhTransient)
class CrosscorrelationModel(libBornAgainParam.INode):
    r"""Proxy of C++ CrosscorrelationModel 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_CrosscorrelationModel

# Register CrosscorrelationModel in _libBornAgainSample:
_libBornAgainSample.CrosscorrelationModel_swigregister(CrosscorrelationModel)
class SpatialFrequencyCrosscorrelation(CrosscorrelationModel):
    r"""Proxy of C++ SpatialFrequencyCrosscorrelation 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, 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 className(self):
        r"""className(SpatialFrequencyCrosscorrelation self) -> std::string"""
        return _libBornAgainSample.SpatialFrequencyCrosscorrelation_className(self)

    def validate(self):
        r"""validate(SpatialFrequencyCrosscorrelation self) -> std::string"""
        return _libBornAgainSample.SpatialFrequencyCrosscorrelation_validate(self)

    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)

    def parDefs(self):
        r"""parDefs(SpatialFrequencyCrosscorrelation self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SpatialFrequencyCrosscorrelation_parDefs(self)

    def baseCrossCorrDepth(self):
        r"""baseCrossCorrDepth(SpatialFrequencyCrosscorrelation self) -> double"""
        return _libBornAgainSample.SpatialFrequencyCrosscorrelation_baseCrossCorrDepth(self)

    def baseSpatialFrequency(self):
        r"""baseSpatialFrequency(SpatialFrequencyCrosscorrelation self) -> double"""
        return _libBornAgainSample.SpatialFrequencyCrosscorrelation_baseSpatialFrequency(self)

    def power(self):
        r"""power(SpatialFrequencyCrosscorrelation self) -> double"""
        return _libBornAgainSample.SpatialFrequencyCrosscorrelation_power(self)
    __swig_destroy__ = _libBornAgainSample.delete_SpatialFrequencyCrosscorrelation

# Register SpatialFrequencyCrosscorrelation in _libBornAgainSample:
_libBornAgainSample.SpatialFrequencyCrosscorrelation_swigregister(SpatialFrequencyCrosscorrelation)
class CommonDepthCrosscorrelation(SpatialFrequencyCrosscorrelation):
    r"""Proxy of C++ CommonDepthCrosscorrelation 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, cross_corr_depth):
        r"""__init__(CommonDepthCrosscorrelation self, double cross_corr_depth) -> CommonDepthCrosscorrelation"""
        _libBornAgainSample.CommonDepthCrosscorrelation_swiginit(self, _libBornAgainSample.new_CommonDepthCrosscorrelation(cross_corr_depth))

    def className(self):
        r"""className(CommonDepthCrosscorrelation self) -> std::string"""
        return _libBornAgainSample.CommonDepthCrosscorrelation_className(self)

    def parDefs(self):
        r"""parDefs(CommonDepthCrosscorrelation self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.CommonDepthCrosscorrelation_parDefs(self)

    def crossCorrDepth(self):
        r"""crossCorrDepth(CommonDepthCrosscorrelation self) -> double"""
        return _libBornAgainSample.CommonDepthCrosscorrelation_crossCorrDepth(self)
    __swig_destroy__ = _libBornAgainSample.delete_CommonDepthCrosscorrelation

# Register CommonDepthCrosscorrelation in _libBornAgainSample:
_libBornAgainSample.CommonDepthCrosscorrelation_swigregister(CommonDepthCrosscorrelation)
class IFormfactorPolyhedron(IFormfactor):
    r"""Proxy of C++ IFormfactorPolyhedron 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_IFormfactorPolyhedron

    def volume(self):
        r"""volume(IFormfactorPolyhedron self) -> double"""
        return _libBornAgainSample.IFormfactorPolyhedron_volume(self)

    def radialExtension(self):
        r"""radialExtension(IFormfactorPolyhedron self) -> double"""
        return _libBornAgainSample.IFormfactorPolyhedron_radialExtension(self)

    def formfactor(self, q):
        r"""formfactor(IFormfactorPolyhedron self, C3 q) -> complex_t"""
        return _libBornAgainSample.IFormfactorPolyhedron_formfactor(self, q)

    def spanZ(self, rotation):
        r"""spanZ(IFormfactorPolyhedron self, IRotation rotation) -> Span"""
        return _libBornAgainSample.IFormfactorPolyhedron_spanZ(self, rotation)

# Register IFormfactorPolyhedron in _libBornAgainSample:
_libBornAgainSample.IFormfactorPolyhedron_swigregister(IFormfactorPolyhedron)
class IFormfactorPrism(IFormfactorPolyhedron):
    r"""Proxy of C++ IFormfactorPrism 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_IFormfactorPrism

    def height(self):
        r"""height(IFormfactorPrism self) -> double"""
        return _libBornAgainSample.IFormfactorPrism_height(self)

# Register IFormfactorPrism in _libBornAgainSample:
_libBornAgainSample.IFormfactorPrism_swigregister(IFormfactorPrism)
class IProfileRipple(IFormfactor):
    r"""Proxy of C++ IProfileRipple 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 length(self):
        r"""length(IProfileRipple self) -> double"""
        return _libBornAgainSample.IProfileRipple_length(self)

    def height(self):
        r"""height(IProfileRipple self) -> double"""
        return _libBornAgainSample.IProfileRipple_height(self)

    def width(self):
        r"""width(IProfileRipple self) -> double"""
        return _libBornAgainSample.IProfileRipple_width(self)

    def radialExtension(self):
        r"""radialExtension(IProfileRipple self) -> double"""
        return _libBornAgainSample.IProfileRipple_radialExtension(self)

    def formfactor(self, q):
        r"""formfactor(IProfileRipple self, C3 q) -> complex_t"""
        return _libBornAgainSample.IProfileRipple_formfactor(self, q)

    def validate(self):
        r"""validate(IProfileRipple self) -> std::string"""
        return _libBornAgainSample.IProfileRipple_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_IProfileRipple

# Register IProfileRipple in _libBornAgainSample:
_libBornAgainSample.IProfileRipple_swigregister(IProfileRipple)
class IProfileRectangularRipple(IProfileRipple):
    r"""Proxy of C++ IProfileRectangularRipple 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_IProfileRectangularRipple

# Register IProfileRectangularRipple in _libBornAgainSample:
_libBornAgainSample.IProfileRectangularRipple_swigregister(IProfileRectangularRipple)
class ICosineRipple(IProfileRipple):
    r"""Proxy of C++ ICosineRipple 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_ICosineRipple

# Register ICosineRipple in _libBornAgainSample:
_libBornAgainSample.ICosineRipple_swigregister(ICosineRipple)
class ISawtoothRipple(IProfileRipple):
    r"""Proxy of C++ ISawtoothRipple 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 asymmetry(self):
        r"""asymmetry(ISawtoothRipple self) -> double"""
        return _libBornAgainSample.ISawtoothRipple_asymmetry(self)
    __swig_destroy__ = _libBornAgainSample.delete_ISawtoothRipple

# Register ISawtoothRipple in _libBornAgainSample:
_libBornAgainSample.ISawtoothRipple_swigregister(ISawtoothRipple)
class Box(IFormfactorPrism):
    r"""Proxy of C++ Box 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__(Box self, double length, double width, double height) -> Box
        __init__(Box self, vdouble1d_T P) -> Box
        """
        _libBornAgainSample.Box_swiginit(self, _libBornAgainSample.new_Box(*args))

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

    def parDefs(self):
        r"""parDefs(Box self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Box_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Box_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Box

# Register Box in _libBornAgainSample:
_libBornAgainSample.Box_swigregister(Box)
class Prism3(IFormfactorPrism):
    r"""Proxy of C++ Prism3 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__(Prism3 self, double base_edge, double height) -> Prism3
        __init__(Prism3 self, vdouble1d_T P) -> Prism3
        """
        _libBornAgainSample.Prism3_swiginit(self, _libBornAgainSample.new_Prism3(*args))

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

    def parDefs(self):
        r"""parDefs(Prism3 self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Prism3_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Prism3_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Prism3

# Register Prism3 in _libBornAgainSample:
_libBornAgainSample.Prism3_swigregister(Prism3)
class Prism6(IFormfactorPrism):
    r"""Proxy of C++ Prism6 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__(Prism6 self, double base_edge, double height) -> Prism6
        __init__(Prism6 self, vdouble1d_T P) -> Prism6
        """
        _libBornAgainSample.Prism6_swiginit(self, _libBornAgainSample.new_Prism6(*args))

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

    def parDefs(self):
        r"""parDefs(Prism6 self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Prism6_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Prism6_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Prism6

# Register Prism6 in _libBornAgainSample:
_libBornAgainSample.Prism6_swigregister(Prism6)
class PlatonicTetrahedron(IFormfactorPolyhedron):
    r"""Proxy of C++ PlatonicTetrahedron 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__(PlatonicTetrahedron self, double edge) -> PlatonicTetrahedron
        __init__(PlatonicTetrahedron self, vdouble1d_T P) -> PlatonicTetrahedron
        """
        _libBornAgainSample.PlatonicTetrahedron_swiginit(self, _libBornAgainSample.new_PlatonicTetrahedron(*args))

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

    def parDefs(self):
        r"""parDefs(PlatonicTetrahedron self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.PlatonicTetrahedron_parDefs(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 position) -> bool"""
        return _libBornAgainSample.PlatonicTetrahedron_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_PlatonicTetrahedron

# Register PlatonicTetrahedron in _libBornAgainSample:
_libBornAgainSample.PlatonicTetrahedron_swigregister(PlatonicTetrahedron)
class PlatonicOctahedron(IFormfactorPolyhedron):
    r"""Proxy of C++ PlatonicOctahedron 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__(PlatonicOctahedron self, double edge) -> PlatonicOctahedron
        __init__(PlatonicOctahedron self, vdouble1d_T P) -> PlatonicOctahedron
        """
        _libBornAgainSample.PlatonicOctahedron_swiginit(self, _libBornAgainSample.new_PlatonicOctahedron(*args))

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

    def parDefs(self):
        r"""parDefs(PlatonicOctahedron self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.PlatonicOctahedron_parDefs(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 position) -> bool"""
        return _libBornAgainSample.PlatonicOctahedron_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_PlatonicOctahedron

# Register PlatonicOctahedron in _libBornAgainSample:
_libBornAgainSample.PlatonicOctahedron_swigregister(PlatonicOctahedron)
class Dodecahedron(IFormfactorPolyhedron):
    r"""Proxy of C++ Dodecahedron 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__(Dodecahedron self, double edge) -> Dodecahedron
        __init__(Dodecahedron self, vdouble1d_T P) -> Dodecahedron
        """
        _libBornAgainSample.Dodecahedron_swiginit(self, _libBornAgainSample.new_Dodecahedron(*args))

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

    def parDefs(self):
        r"""parDefs(Dodecahedron self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Dodecahedron_parDefs(self)

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

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

# Register Dodecahedron in _libBornAgainSample:
_libBornAgainSample.Dodecahedron_swigregister(Dodecahedron)
class Icosahedron(IFormfactorPolyhedron):
    r"""Proxy of C++ Icosahedron 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__(Icosahedron self, double edge) -> Icosahedron
        __init__(Icosahedron self, vdouble1d_T P) -> Icosahedron
        """
        _libBornAgainSample.Icosahedron_swiginit(self, _libBornAgainSample.new_Icosahedron(*args))

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

    def parDefs(self):
        r"""parDefs(Icosahedron self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Icosahedron_parDefs(self)

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

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

# Register Icosahedron in _libBornAgainSample:
_libBornAgainSample.Icosahedron_swigregister(Icosahedron)
class Pyramid2(IFormfactorPolyhedron):
    r"""Proxy of C++ Pyramid2 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__(Pyramid2 self, double length, double width, double height, double alpha) -> Pyramid2
        __init__(Pyramid2 self, vdouble1d_T P) -> Pyramid2
        """
        _libBornAgainSample.Pyramid2_swiginit(self, _libBornAgainSample.new_Pyramid2(*args))

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

    def parDefs(self):
        r"""parDefs(Pyramid2 self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Pyramid2_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Pyramid2_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid2

# Register Pyramid2 in _libBornAgainSample:
_libBornAgainSample.Pyramid2_swigregister(Pyramid2)
class Pyramid3(IFormfactorPolyhedron):
    r"""Proxy of C++ Pyramid3 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__(Pyramid3 self, double base_edge, double height, double alpha) -> Pyramid3
        __init__(Pyramid3 self, vdouble1d_T P) -> Pyramid3
        """
        _libBornAgainSample.Pyramid3_swiginit(self, _libBornAgainSample.new_Pyramid3(*args))

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

    def parDefs(self):
        r"""parDefs(Pyramid3 self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Pyramid3_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Pyramid3_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid3

# Register Pyramid3 in _libBornAgainSample:
_libBornAgainSample.Pyramid3_swigregister(Pyramid3)
class Pyramid4(IFormfactorPolyhedron):
    r"""Proxy of C++ Pyramid4 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__(Pyramid4 self, double base_edge, double height, double alpha) -> Pyramid4
        __init__(Pyramid4 self, vdouble1d_T P) -> Pyramid4
        """
        _libBornAgainSample.Pyramid4_swiginit(self, _libBornAgainSample.new_Pyramid4(*args))

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

    def parDefs(self):
        r"""parDefs(Pyramid4 self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Pyramid4_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Pyramid4_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid4

# Register Pyramid4 in _libBornAgainSample:
_libBornAgainSample.Pyramid4_swigregister(Pyramid4)
class Pyramid6(IFormfactorPolyhedron):
    r"""Proxy of C++ Pyramid6 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__(Pyramid6 self, double base_edge, double height, double alpha) -> Pyramid6
        __init__(Pyramid6 self, vdouble1d_T P) -> Pyramid6
        """
        _libBornAgainSample.Pyramid6_swiginit(self, _libBornAgainSample.new_Pyramid6(*args))

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

    def parDefs(self):
        r"""parDefs(Pyramid6 self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Pyramid6_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Pyramid6_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Pyramid6

# Register Pyramid6 in _libBornAgainSample:
_libBornAgainSample.Pyramid6_swigregister(Pyramid6)
class Bipyramid4(IFormfactorPolyhedron):
    r"""Proxy of C++ Bipyramid4 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__(Bipyramid4 self, double length, double base_height, double height_ratio, double alpha) -> Bipyramid4
        __init__(Bipyramid4 self, vdouble1d_T P) -> Bipyramid4
        """
        _libBornAgainSample.Bipyramid4_swiginit(self, _libBornAgainSample.new_Bipyramid4(*args))

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

    def parDefs(self):
        r"""parDefs(Bipyramid4 self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Bipyramid4_parDefs(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 position) -> bool"""
        return _libBornAgainSample.Bipyramid4_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Bipyramid4

# Register Bipyramid4 in _libBornAgainSample:
_libBornAgainSample.Bipyramid4_swigregister(Bipyramid4)
class CantellatedCube(IFormfactorPolyhedron):
    r"""Proxy of C++ CantellatedCube 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__(CantellatedCube self, double length, double removed_length) -> CantellatedCube
        __init__(CantellatedCube self, vdouble1d_T P) -> CantellatedCube
        """
        _libBornAgainSample.CantellatedCube_swiginit(self, _libBornAgainSample.new_CantellatedCube(*args))

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

    def parDefs(self):
        r"""parDefs(CantellatedCube self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.CantellatedCube_parDefs(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 position) -> bool"""
        return _libBornAgainSample.CantellatedCube_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_CantellatedCube

# Register CantellatedCube in _libBornAgainSample:
_libBornAgainSample.CantellatedCube_swigregister(CantellatedCube)
class TruncatedCube(IFormfactorPolyhedron):
    r"""Proxy of C++ TruncatedCube 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__(TruncatedCube self, double length, double removed_length) -> TruncatedCube
        __init__(TruncatedCube self, vdouble1d_T P) -> TruncatedCube
        """
        _libBornAgainSample.TruncatedCube_swiginit(self, _libBornAgainSample.new_TruncatedCube(*args))

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

    def parDefs(self):
        r"""parDefs(TruncatedCube self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.TruncatedCube_parDefs(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 position) -> bool"""
        return _libBornAgainSample.TruncatedCube_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_TruncatedCube

# Register TruncatedCube in _libBornAgainSample:
_libBornAgainSample.TruncatedCube_swigregister(TruncatedCube)
class Cone(IFormfactor):
    r"""Proxy of C++ Cone 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__(Cone self, double radius, double height, double alpha) -> Cone
        __init__(Cone self, vdouble1d_T P) -> Cone
        """
        _libBornAgainSample.Cone_swiginit(self, _libBornAgainSample.new_Cone(*args))

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

    def parDefs(self):
        r"""parDefs(Cone self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Cone_parDefs(self)

    def radius(self):
        r"""radius(Cone self) -> double"""
        return _libBornAgainSample.Cone_radius(self)

    def height(self):
        r"""height(Cone self) -> double"""
        return _libBornAgainSample.Cone_height(self)

    def alpha(self):
        r"""alpha(Cone self) -> double"""
        return _libBornAgainSample.Cone_alpha(self)

    def radialExtension(self):
        r"""radialExtension(Cone self) -> double"""
        return _libBornAgainSample.Cone_radialExtension(self)

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

    def validate(self):
        r"""validate(Cone self) -> std::string"""
        return _libBornAgainSample.Cone_validate(self)

    def contains(self, position):
        r"""contains(Cone self, R3 position) -> bool"""
        return _libBornAgainSample.Cone_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Cone

# Register Cone in _libBornAgainSample:
_libBornAgainSample.Cone_swigregister(Cone)
class Cylinder(IFormfactor):
    r"""Proxy of C++ Cylinder 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__(Cylinder self, double radius, double height) -> Cylinder
        __init__(Cylinder self, vdouble1d_T P) -> Cylinder
        """
        _libBornAgainSample.Cylinder_swiginit(self, _libBornAgainSample.new_Cylinder(*args))

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

    def parDefs(self):
        r"""parDefs(Cylinder self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Cylinder_parDefs(self)

    def height(self):
        r"""height(Cylinder self) -> double"""
        return _libBornAgainSample.Cylinder_height(self)

    def radius(self):
        r"""radius(Cylinder self) -> double"""
        return _libBornAgainSample.Cylinder_radius(self)

    def radialExtension(self):
        r"""radialExtension(Cylinder self) -> double"""
        return _libBornAgainSample.Cylinder_radialExtension(self)

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

    def validate(self):
        r"""validate(Cylinder self) -> std::string"""
        return _libBornAgainSample.Cylinder_validate(self)

    def contains(self, position):
        r"""contains(Cylinder self, R3 position) -> bool"""
        return _libBornAgainSample.Cylinder_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Cylinder

# Register Cylinder in _libBornAgainSample:
_libBornAgainSample.Cylinder_swigregister(Cylinder)
class EllipsoidalCylinder(IFormfactor):
    r"""Proxy of C++ EllipsoidalCylinder 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__(EllipsoidalCylinder self, double radius_x, double radius_y, double height) -> EllipsoidalCylinder
        __init__(EllipsoidalCylinder self, vdouble1d_T P) -> EllipsoidalCylinder
        """
        _libBornAgainSample.EllipsoidalCylinder_swiginit(self, _libBornAgainSample.new_EllipsoidalCylinder(*args))

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

    def parDefs(self):
        r"""parDefs(EllipsoidalCylinder self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.EllipsoidalCylinder_parDefs(self)

    def radiusX(self):
        r"""radiusX(EllipsoidalCylinder self) -> double"""
        return _libBornAgainSample.EllipsoidalCylinder_radiusX(self)

    def radiusY(self):
        r"""radiusY(EllipsoidalCylinder self) -> double"""
        return _libBornAgainSample.EllipsoidalCylinder_radiusY(self)

    def height(self):
        r"""height(EllipsoidalCylinder self) -> double"""
        return _libBornAgainSample.EllipsoidalCylinder_height(self)

    def radialExtension(self):
        r"""radialExtension(EllipsoidalCylinder self) -> double"""
        return _libBornAgainSample.EllipsoidalCylinder_radialExtension(self)

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

    def validate(self):
        r"""validate(EllipsoidalCylinder self) -> std::string"""
        return _libBornAgainSample.EllipsoidalCylinder_validate(self)

    def contains(self, position):
        r"""contains(EllipsoidalCylinder self, R3 position) -> bool"""
        return _libBornAgainSample.EllipsoidalCylinder_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_EllipsoidalCylinder

# Register EllipsoidalCylinder in _libBornAgainSample:
_libBornAgainSample.EllipsoidalCylinder_swigregister(EllipsoidalCylinder)
class HemiEllipsoid(IFormfactor):
    r"""Proxy of C++ HemiEllipsoid 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__(HemiEllipsoid self, double radius_x, double radius_y, double radius_z) -> HemiEllipsoid
        __init__(HemiEllipsoid self, vdouble1d_T P) -> HemiEllipsoid
        """
        _libBornAgainSample.HemiEllipsoid_swiginit(self, _libBornAgainSample.new_HemiEllipsoid(*args))
    __swig_destroy__ = _libBornAgainSample.delete_HemiEllipsoid

    def className(self):
        r"""className(HemiEllipsoid self) -> std::string"""
        return _libBornAgainSample.HemiEllipsoid_className(self)

    def parDefs(self):
        r"""parDefs(HemiEllipsoid self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.HemiEllipsoid_parDefs(self)

    def radiusX(self):
        r"""radiusX(HemiEllipsoid self) -> double"""
        return _libBornAgainSample.HemiEllipsoid_radiusX(self)

    def radiusY(self):
        r"""radiusY(HemiEllipsoid self) -> double"""
        return _libBornAgainSample.HemiEllipsoid_radiusY(self)

    def radiusZ(self):
        r"""radiusZ(HemiEllipsoid self) -> double"""
        return _libBornAgainSample.HemiEllipsoid_radiusZ(self)

    def radialExtension(self):
        r"""radialExtension(HemiEllipsoid self) -> double"""
        return _libBornAgainSample.HemiEllipsoid_radialExtension(self)

    def formfactor(self, q):
        r"""formfactor(HemiEllipsoid self, C3 q) -> complex_t"""
        return _libBornAgainSample.HemiEllipsoid_formfactor(self, q)

    def validate(self):
        r"""validate(HemiEllipsoid self) -> std::string"""
        return _libBornAgainSample.HemiEllipsoid_validate(self)

    def contains(self, position):
        r"""contains(HemiEllipsoid self, R3 position) -> bool"""
        return _libBornAgainSample.HemiEllipsoid_contains(self, position)

# Register HemiEllipsoid in _libBornAgainSample:
_libBornAgainSample.HemiEllipsoid_swigregister(HemiEllipsoid)
class HorizontalCylinder(IFormfactor):
    r"""Proxy of C++ HorizontalCylinder 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__(HorizontalCylinder self, double radius, double length, double slice_bottom, double slice_top) -> HorizontalCylinder
        __init__(HorizontalCylinder self, double radius, double length) -> HorizontalCylinder
        __init__(HorizontalCylinder self, vdouble1d_T P) -> HorizontalCylinder
        """
        _libBornAgainSample.HorizontalCylinder_swiginit(self, _libBornAgainSample.new_HorizontalCylinder(*args))

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

    def parDefs(self):
        r"""parDefs(HorizontalCylinder self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.HorizontalCylinder_parDefs(self)

    def length(self):
        r"""length(HorizontalCylinder self) -> double"""
        return _libBornAgainSample.HorizontalCylinder_length(self)

    def radius(self):
        r"""radius(HorizontalCylinder self) -> double"""
        return _libBornAgainSample.HorizontalCylinder_radius(self)

    def slice_bottom(self):
        r"""slice_bottom(HorizontalCylinder self) -> double"""
        return _libBornAgainSample.HorizontalCylinder_slice_bottom(self)

    def slice_top(self):
        r"""slice_top(HorizontalCylinder self) -> double"""
        return _libBornAgainSample.HorizontalCylinder_slice_top(self)

    def height(self):
        r"""height(HorizontalCylinder self) -> double"""
        return _libBornAgainSample.HorizontalCylinder_height(self)

    def radialExtension(self):
        r"""radialExtension(HorizontalCylinder self) -> double"""
        return _libBornAgainSample.HorizontalCylinder_radialExtension(self)

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

    def validate(self):
        r"""validate(HorizontalCylinder self) -> std::string"""
        return _libBornAgainSample.HorizontalCylinder_validate(self)

    def contains(self, position):
        r"""contains(HorizontalCylinder self, R3 position) -> bool"""
        return _libBornAgainSample.HorizontalCylinder_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_HorizontalCylinder

# Register HorizontalCylinder in _libBornAgainSample:
_libBornAgainSample.HorizontalCylinder_swigregister(HorizontalCylinder)
class Sphere(IFormfactor):
    r"""Proxy of C++ Sphere 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__(Sphere self, double radius, bool position_at_center=False) -> Sphere
        __init__(Sphere self, vdouble1d_T P, bool position_at_center=False) -> Sphere
        """
        _libBornAgainSample.Sphere_swiginit(self, _libBornAgainSample.new_Sphere(*args))

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

    def parDefs(self):
        r"""parDefs(Sphere self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Sphere_parDefs(self)

    def radius(self):
        r"""radius(Sphere self) -> double"""
        return _libBornAgainSample.Sphere_radius(self)

    def height(self):
        r"""height(Sphere self) -> double"""
        return _libBornAgainSample.Sphere_height(self)

    def radialExtension(self):
        r"""radialExtension(Sphere self) -> double"""
        return _libBornAgainSample.Sphere_radialExtension(self)

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

    def spanZ(self, rotation):
        r"""spanZ(Sphere self, IRotation rotation) -> Span"""
        return _libBornAgainSample.Sphere_spanZ(self, rotation)

    def validate(self):
        r"""validate(Sphere self) -> std::string"""
        return _libBornAgainSample.Sphere_validate(self)

    def contains(self, position):
        r"""contains(Sphere self, R3 position) -> bool"""
        return _libBornAgainSample.Sphere_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Sphere

# Register Sphere in _libBornAgainSample:
_libBornAgainSample.Sphere_swigregister(Sphere)
class SphericalSegment(IFormfactor):
    r"""Proxy of C++ SphericalSegment 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__(SphericalSegment self, double radius, double top_cut, double bottom_cut) -> SphericalSegment
        __init__(SphericalSegment self, vdouble1d_T P) -> SphericalSegment
        """
        _libBornAgainSample.SphericalSegment_swiginit(self, _libBornAgainSample.new_SphericalSegment(*args))

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

    def parDefs(self):
        r"""parDefs(SphericalSegment self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SphericalSegment_parDefs(self)

    def radius(self):
        r"""radius(SphericalSegment self) -> double"""
        return _libBornAgainSample.SphericalSegment_radius(self)

    def cutFromTop(self):
        r"""cutFromTop(SphericalSegment self) -> double"""
        return _libBornAgainSample.SphericalSegment_cutFromTop(self)

    def cutFromBottom(self):
        r"""cutFromBottom(SphericalSegment self) -> double"""
        return _libBornAgainSample.SphericalSegment_cutFromBottom(self)

    def radialExtension(self):
        r"""radialExtension(SphericalSegment self) -> double"""
        return _libBornAgainSample.SphericalSegment_radialExtension(self)

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

    def validate(self):
        r"""validate(SphericalSegment self) -> std::string"""
        return _libBornAgainSample.SphericalSegment_validate(self)

    def contains(self, position):
        r"""contains(SphericalSegment self, R3 position) -> bool"""
        return _libBornAgainSample.SphericalSegment_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_SphericalSegment

# Register SphericalSegment in _libBornAgainSample:
_libBornAgainSample.SphericalSegment_swigregister(SphericalSegment)
class Spheroid(IFormfactor):
    r"""Proxy of C++ Spheroid 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__(Spheroid self, double radius_xy, double radius_z) -> Spheroid
        __init__(Spheroid self, vdouble1d_T P) -> Spheroid
        """
        _libBornAgainSample.Spheroid_swiginit(self, _libBornAgainSample.new_Spheroid(*args))

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

    def parDefs(self):
        r"""parDefs(Spheroid self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.Spheroid_parDefs(self)

    def radiusXY(self):
        r"""radiusXY(Spheroid self) -> double"""
        return _libBornAgainSample.Spheroid_radiusXY(self)

    def radiusZ(self):
        r"""radiusZ(Spheroid self) -> double"""
        return _libBornAgainSample.Spheroid_radiusZ(self)

    def radialExtension(self):
        r"""radialExtension(Spheroid self) -> double"""
        return _libBornAgainSample.Spheroid_radialExtension(self)

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

    def validate(self):
        r"""validate(Spheroid self) -> std::string"""
        return _libBornAgainSample.Spheroid_validate(self)

    def contains(self, position):
        r"""contains(Spheroid self, R3 position) -> bool"""
        return _libBornAgainSample.Spheroid_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_Spheroid

# Register Spheroid in _libBornAgainSample:
_libBornAgainSample.Spheroid_swigregister(Spheroid)
class SpheroidalSegment(IFormfactor):
    r"""Proxy of C++ SpheroidalSegment 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__(SpheroidalSegment self, double radius_xy, double radius_z, double rm_top, double rm_bottom) -> SpheroidalSegment
        __init__(SpheroidalSegment self, vdouble1d_T P) -> SpheroidalSegment
        """
        _libBornAgainSample.SpheroidalSegment_swiginit(self, _libBornAgainSample.new_SpheroidalSegment(*args))

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

    def parDefs(self):
        r"""parDefs(SpheroidalSegment self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SpheroidalSegment_parDefs(self)

    def radiusXY(self):
        r"""radiusXY(SpheroidalSegment self) -> double"""
        return _libBornAgainSample.SpheroidalSegment_radiusXY(self)

    def radiusZ(self):
        r"""radiusZ(SpheroidalSegment self) -> double"""
        return _libBornAgainSample.SpheroidalSegment_radiusZ(self)

    def cutFromTop(self):
        r"""cutFromTop(SpheroidalSegment self) -> double"""
        return _libBornAgainSample.SpheroidalSegment_cutFromTop(self)

    def cutFromBottom(self):
        r"""cutFromBottom(SpheroidalSegment self) -> double"""
        return _libBornAgainSample.SpheroidalSegment_cutFromBottom(self)

    def height(self):
        r"""height(SpheroidalSegment self) -> double"""
        return _libBornAgainSample.SpheroidalSegment_height(self)

    def radialExtension(self):
        r"""radialExtension(SpheroidalSegment self) -> double"""
        return _libBornAgainSample.SpheroidalSegment_radialExtension(self)

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

    def validate(self):
        r"""validate(SpheroidalSegment self) -> std::string"""
        return _libBornAgainSample.SpheroidalSegment_validate(self)

    def contains(self, position):
        r"""contains(SpheroidalSegment self, R3 position) -> bool"""
        return _libBornAgainSample.SpheroidalSegment_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_SpheroidalSegment

# Register SpheroidalSegment in _libBornAgainSample:
_libBornAgainSample.SpheroidalSegment_swigregister(SpheroidalSegment)
class BarGauss(IProfileRectangularRipple):
    r"""Proxy of C++ BarGauss 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__(BarGauss self, double length, double width, double height) -> BarGauss
        __init__(BarGauss self, vdouble1d_T P) -> BarGauss
        """
        _libBornAgainSample.BarGauss_swiginit(self, _libBornAgainSample.new_BarGauss(*args))

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

    def parDefs(self):
        r"""parDefs(BarGauss self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.BarGauss_parDefs(self)

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

# Register BarGauss in _libBornAgainSample:
_libBornAgainSample.BarGauss_swigregister(BarGauss)
class BarLorentz(IProfileRectangularRipple):
    r"""Proxy of C++ BarLorentz 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__(BarLorentz self, double length, double width, double height) -> BarLorentz
        __init__(BarLorentz self, vdouble1d_T P) -> BarLorentz
        """
        _libBornAgainSample.BarLorentz_swiginit(self, _libBornAgainSample.new_BarLorentz(*args))

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

    def parDefs(self):
        r"""parDefs(BarLorentz self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.BarLorentz_parDefs(self)

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

# Register BarLorentz in _libBornAgainSample:
_libBornAgainSample.BarLorentz_swigregister(BarLorentz)
class CosineRippleBox(ICosineRipple):
    r"""Proxy of C++ CosineRippleBox 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__(CosineRippleBox self, double length, double width, double height) -> CosineRippleBox
        __init__(CosineRippleBox self, vdouble1d_T P) -> CosineRippleBox
        """
        _libBornAgainSample.CosineRippleBox_swiginit(self, _libBornAgainSample.new_CosineRippleBox(*args))

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

    def parDefs(self):
        r"""parDefs(CosineRippleBox self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.CosineRippleBox_parDefs(self)

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

# Register CosineRippleBox in _libBornAgainSample:
_libBornAgainSample.CosineRippleBox_swigregister(CosineRippleBox)
class CosineRippleGauss(ICosineRipple):
    r"""Proxy of C++ CosineRippleGauss 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__(CosineRippleGauss self, double length, double width, double height) -> CosineRippleGauss
        __init__(CosineRippleGauss self, vdouble1d_T P) -> CosineRippleGauss
        """
        _libBornAgainSample.CosineRippleGauss_swiginit(self, _libBornAgainSample.new_CosineRippleGauss(*args))

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

    def parDefs(self):
        r"""parDefs(CosineRippleGauss self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.CosineRippleGauss_parDefs(self)

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

# Register CosineRippleGauss in _libBornAgainSample:
_libBornAgainSample.CosineRippleGauss_swigregister(CosineRippleGauss)
class CosineRippleLorentz(ICosineRipple):
    r"""Proxy of C++ CosineRippleLorentz 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__(CosineRippleLorentz self, double length, double width, double height) -> CosineRippleLorentz
        __init__(CosineRippleLorentz self, vdouble1d_T P) -> CosineRippleLorentz
        """
        _libBornAgainSample.CosineRippleLorentz_swiginit(self, _libBornAgainSample.new_CosineRippleLorentz(*args))

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

    def parDefs(self):
        r"""parDefs(CosineRippleLorentz self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.CosineRippleLorentz_parDefs(self)

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

# Register CosineRippleLorentz in _libBornAgainSample:
_libBornAgainSample.CosineRippleLorentz_swigregister(CosineRippleLorentz)
class SawtoothRippleBox(ISawtoothRipple):
    r"""Proxy of C++ SawtoothRippleBox 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__(SawtoothRippleBox self, double length, double width, double height, double asymmetry) -> SawtoothRippleBox
        __init__(SawtoothRippleBox self, vdouble1d_T P) -> SawtoothRippleBox
        """
        _libBornAgainSample.SawtoothRippleBox_swiginit(self, _libBornAgainSample.new_SawtoothRippleBox(*args))

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

    def parDefs(self):
        r"""parDefs(SawtoothRippleBox self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SawtoothRippleBox_parDefs(self)

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

# Register SawtoothRippleBox in _libBornAgainSample:
_libBornAgainSample.SawtoothRippleBox_swigregister(SawtoothRippleBox)
class SawtoothRippleGauss(ISawtoothRipple):
    r"""Proxy of C++ SawtoothRippleGauss 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__(SawtoothRippleGauss self, double length, double width, double height, double asymmetry) -> SawtoothRippleGauss
        __init__(SawtoothRippleGauss self, vdouble1d_T P) -> SawtoothRippleGauss
        """
        _libBornAgainSample.SawtoothRippleGauss_swiginit(self, _libBornAgainSample.new_SawtoothRippleGauss(*args))

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

    def parDefs(self):
        r"""parDefs(SawtoothRippleGauss self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SawtoothRippleGauss_parDefs(self)

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

# Register SawtoothRippleGauss in _libBornAgainSample:
_libBornAgainSample.SawtoothRippleGauss_swigregister(SawtoothRippleGauss)
class SawtoothRippleLorentz(ISawtoothRipple):
    r"""Proxy of C++ SawtoothRippleLorentz 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__(SawtoothRippleLorentz self, double length, double width, double height, double asymmetry) -> SawtoothRippleLorentz
        __init__(SawtoothRippleLorentz self, vdouble1d_T P) -> SawtoothRippleLorentz
        """
        _libBornAgainSample.SawtoothRippleLorentz_swiginit(self, _libBornAgainSample.new_SawtoothRippleLorentz(*args))

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

    def parDefs(self):
        r"""parDefs(SawtoothRippleLorentz self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SawtoothRippleLorentz_parDefs(self)

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

# Register SawtoothRippleLorentz in _libBornAgainSample:
_libBornAgainSample.SawtoothRippleLorentz_swigregister(SawtoothRippleLorentz)
class LongBoxGauss(IFormfactor):
    r"""Proxy of C++ LongBoxGauss 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__(LongBoxGauss self, double length, double width, double height) -> LongBoxGauss
        __init__(LongBoxGauss self, vdouble1d_T P) -> LongBoxGauss
        """
        _libBornAgainSample.LongBoxGauss_swiginit(self, _libBornAgainSample.new_LongBoxGauss(*args))

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

    def parDefs(self):
        r"""parDefs(LongBoxGauss self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.LongBoxGauss_parDefs(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 formfactor(self, q):
        r"""formfactor(LongBoxGauss self, C3 q) -> complex_t"""
        return _libBornAgainSample.LongBoxGauss_formfactor(self, q)

    def validate(self):
        r"""validate(LongBoxGauss self) -> std::string"""
        return _libBornAgainSample.LongBoxGauss_validate(self)

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

# Register LongBoxGauss in _libBornAgainSample:
_libBornAgainSample.LongBoxGauss_swigregister(LongBoxGauss)
class LongBoxLorentz(IFormfactor):
    r"""Proxy of C++ LongBoxLorentz 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__(LongBoxLorentz self, double length, double width, double height) -> LongBoxLorentz
        __init__(LongBoxLorentz self, vdouble1d_T P) -> LongBoxLorentz
        """
        _libBornAgainSample.LongBoxLorentz_swiginit(self, _libBornAgainSample.new_LongBoxLorentz(*args))

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

    def parDefs(self):
        r"""parDefs(LongBoxLorentz self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.LongBoxLorentz_parDefs(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 formfactor(self, q):
        r"""formfactor(LongBoxLorentz self, C3 q) -> complex_t"""
        return _libBornAgainSample.LongBoxLorentz_formfactor(self, q)

    def validate(self):
        r"""validate(LongBoxLorentz self) -> std::string"""
        return _libBornAgainSample.LongBoxLorentz_validate(self)

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

# Register LongBoxLorentz in _libBornAgainSample:
_libBornAgainSample.LongBoxLorentz_swigregister(LongBoxLorentz)
class GaussSphere(IFormfactor):
    r"""Proxy of C++ GaussSphere 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__(GaussSphere self, vdouble1d_T P) -> GaussSphere
        __init__(GaussSphere self, double mean_radius) -> GaussSphere
        """
        _libBornAgainSample.GaussSphere_swiginit(self, _libBornAgainSample.new_GaussSphere(*args))

    def className(self):
        r"""className(GaussSphere self) -> std::string"""
        return _libBornAgainSample.GaussSphere_className(self)

    def parDefs(self):
        r"""parDefs(GaussSphere self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.GaussSphere_parDefs(self)

    def meanRadius(self):
        r"""meanRadius(GaussSphere self) -> double"""
        return _libBornAgainSample.GaussSphere_meanRadius(self)

    def radialExtension(self):
        r"""radialExtension(GaussSphere self) -> double"""
        return _libBornAgainSample.GaussSphere_radialExtension(self)

    def formfactor(self, q):
        r"""formfactor(GaussSphere self, C3 q) -> complex_t"""
        return _libBornAgainSample.GaussSphere_formfactor(self, q)

    def validate(self):
        r"""validate(GaussSphere self) -> std::string"""
        return _libBornAgainSample.GaussSphere_validate(self)

    def contains(self, position):
        r"""contains(GaussSphere self, R3 position) -> bool"""
        return _libBornAgainSample.GaussSphere_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_GaussSphere

# Register GaussSphere in _libBornAgainSample:
_libBornAgainSample.GaussSphere_swigregister(GaussSphere)
class FuzzySphere(IFormfactor):
    r"""Proxy of C++ FuzzySphere 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__(FuzzySphere self, vdouble1d_T P) -> FuzzySphere
        __init__(FuzzySphere self, double mean, double sigma) -> FuzzySphere
        """
        _libBornAgainSample.FuzzySphere_swiginit(self, _libBornAgainSample.new_FuzzySphere(*args))

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

    def parDefs(self):
        r"""parDefs(FuzzySphere self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.FuzzySphere_parDefs(self)

    def radialExtension(self):
        r"""radialExtension(FuzzySphere self) -> double"""
        return _libBornAgainSample.FuzzySphere_radialExtension(self)

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

    def validate(self):
        r"""validate(FuzzySphere self) -> std::string"""
        return _libBornAgainSample.FuzzySphere_validate(self)

    def contains(self, position):
        r"""contains(FuzzySphere self, R3 position) -> bool"""
        return _libBornAgainSample.FuzzySphere_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_FuzzySphere

# Register FuzzySphere in _libBornAgainSample:
_libBornAgainSample.FuzzySphere_swigregister(FuzzySphere)
class ISelectionRule(object):
    r"""Proxy of C++ ISelectionRule 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_ISelectionRule

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

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

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

# Register ISelectionRule in _libBornAgainSample:
_libBornAgainSample.ISelectionRule_swigregister(ISelectionRule)
class SimpleSelectionRule(ISelectionRule):
    r"""Proxy of C++ SimpleSelectionRule 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, 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, ISelectionRule 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(libBornAgainParam.INode):
    r"""Proxy of C++ Lattice3D 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__(Lattice3D self, R3 a, R3 b, R3 c) -> Lattice3D
        __init__(Lattice3D self, Lattice3D lattice) -> Lattice3D
        """
        _libBornAgainSample.Lattice3D_swiginit(self, _libBornAgainSample.new_Lattice3D(*args))
    __swig_destroy__ = _libBornAgainSample.delete_Lattice3D

    def className(self):
        r"""className(Lattice3D self) -> std::string"""
        return _libBornAgainSample.Lattice3D_className(self)

    def rotated(self, rotMatrix):
        r"""rotated(Lattice3D self, RotMatrix const & rotMatrix) -> Lattice3D"""
        return _libBornAgainSample.Lattice3D_rotated(self, rotMatrix)

    def basisVectorA(self):
        r"""basisVectorA(Lattice3D self) -> R3"""
        return _libBornAgainSample.Lattice3D_basisVectorA(self)

    def basisVectorB(self):
        r"""basisVectorB(Lattice3D self) -> R3"""
        return _libBornAgainSample.Lattice3D_basisVectorB(self)

    def basisVectorC(self):
        r"""basisVectorC(Lattice3D self) -> R3"""
        return _libBornAgainSample.Lattice3D_basisVectorC(self)

    def getMillerDirection(self, h, k, l):
        r"""getMillerDirection(Lattice3D self, double h, double k, double l) -> R3"""
        return _libBornAgainSample.Lattice3D_getMillerDirection(self, h, k, l)

    def unitCellVolume(self):
        r"""unitCellVolume(Lattice3D self) -> double"""
        return _libBornAgainSample.Lattice3D_unitCellVolume(self)

    def reciprocalLatticeBasis(self, ra, rb, rc):
        r"""reciprocalLatticeBasis(Lattice3D self, R3 ra, R3 rb, R3 rc)"""
        return _libBornAgainSample.Lattice3D_reciprocalLatticeBasis(self, ra, rb, rc)

    def setSelectionRule(self, selection_rule):
        r"""setSelectionRule(Lattice3D self, ISelectionRule selection_rule)"""
        return _libBornAgainSample.Lattice3D_setSelectionRule(self, selection_rule)

# Register Lattice3D in _libBornAgainSample:
_libBornAgainSample.Lattice3D_swigregister(Lattice3D)
class ReciprocalBases(object):
    r"""Proxy of C++ ReciprocalBases class."""

    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"""m_asx : double""")
    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"""m_bsx : double""")
    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(libBornAgainParam.INode):
    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 - class is abstract")
    __repr__ = _swig_repr

    def length1(self):
        r"""length1(Lattice2D self) -> double"""
        return _libBornAgainSample.Lattice2D_length1(self)

    def length2(self):
        r"""length2(Lattice2D self) -> double"""
        return _libBornAgainSample.Lattice2D_length2(self)

    def latticeAngle(self):
        r"""latticeAngle(Lattice2D self) -> double"""
        return _libBornAgainSample.Lattice2D_latticeAngle(self)

    def unitCellArea(self):
        r"""unitCellArea(Lattice2D self) -> double"""
        return _libBornAgainSample.Lattice2D_unitCellArea(self)

    def rotationAngle(self):
        r"""rotationAngle(Lattice2D self) -> double"""
        return _libBornAgainSample.Lattice2D_rotationAngle(self)

    def reciprocalBases(self):
        r"""reciprocalBases(Lattice2D self) -> ReciprocalBases"""
        return _libBornAgainSample.Lattice2D_reciprocalBases(self)

    def setRotationEnabled(self, enabled):
        r"""setRotationEnabled(Lattice2D self, bool enabled)"""
        return _libBornAgainSample.Lattice2D_setRotationEnabled(self, enabled)
    __swig_destroy__ = _libBornAgainSample.delete_Lattice2D

# Register Lattice2D in _libBornAgainSample:
_libBornAgainSample.Lattice2D_swigregister(Lattice2D)
class BasicLattice2D(Lattice2D):
    r"""Proxy of C++ BasicLattice2D 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, 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))

    def className(self):
        r"""className(BasicLattice2D self) -> std::string"""
        return _libBornAgainSample.BasicLattice2D_className(self)

    def parDefs(self):
        r"""parDefs(BasicLattice2D self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.BasicLattice2D_parDefs(self)

    def length1(self):
        r"""length1(BasicLattice2D self) -> double"""
        return _libBornAgainSample.BasicLattice2D_length1(self)

    def length2(self):
        r"""length2(BasicLattice2D self) -> double"""
        return _libBornAgainSample.BasicLattice2D_length2(self)

    def latticeAngle(self):
        r"""latticeAngle(BasicLattice2D self) -> double"""
        return _libBornAgainSample.BasicLattice2D_latticeAngle(self)

    def unitCellArea(self):
        r"""unitCellArea(BasicLattice2D self) -> double"""
        return _libBornAgainSample.BasicLattice2D_unitCellArea(self)

    def validate(self):
        r"""validate(BasicLattice2D self) -> std::string"""
        return _libBornAgainSample.BasicLattice2D_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_BasicLattice2D

# Register BasicLattice2D in _libBornAgainSample:
_libBornAgainSample.BasicLattice2D_swigregister(BasicLattice2D)
class SquareLattice2D(Lattice2D):
    r"""Proxy of C++ SquareLattice2D 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, length, xi=0.0):
        r"""__init__(SquareLattice2D self, double length, double xi=0.0) -> SquareLattice2D"""
        _libBornAgainSample.SquareLattice2D_swiginit(self, _libBornAgainSample.new_SquareLattice2D(length, xi))

    def className(self):
        r"""className(SquareLattice2D self) -> std::string"""
        return _libBornAgainSample.SquareLattice2D_className(self)

    def parDefs(self):
        r"""parDefs(SquareLattice2D self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.SquareLattice2D_parDefs(self)

    def length1(self):
        r"""length1(SquareLattice2D self) -> double"""
        return _libBornAgainSample.SquareLattice2D_length1(self)

    def length2(self):
        r"""length2(SquareLattice2D self) -> double"""
        return _libBornAgainSample.SquareLattice2D_length2(self)

    def latticeAngle(self):
        r"""latticeAngle(SquareLattice2D self) -> double"""
        return _libBornAgainSample.SquareLattice2D_latticeAngle(self)

    def unitCellArea(self):
        r"""unitCellArea(SquareLattice2D self) -> double"""
        return _libBornAgainSample.SquareLattice2D_unitCellArea(self)

    def validate(self):
        r"""validate(SquareLattice2D self) -> std::string"""
        return _libBornAgainSample.SquareLattice2D_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_SquareLattice2D

# Register SquareLattice2D in _libBornAgainSample:
_libBornAgainSample.SquareLattice2D_swigregister(SquareLattice2D)
class HexagonalLattice2D(Lattice2D):
    r"""Proxy of C++ HexagonalLattice2D 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, length, xi):
        r"""__init__(HexagonalLattice2D self, double length, double xi) -> HexagonalLattice2D"""
        _libBornAgainSample.HexagonalLattice2D_swiginit(self, _libBornAgainSample.new_HexagonalLattice2D(length, xi))

    def className(self):
        r"""className(HexagonalLattice2D self) -> std::string"""
        return _libBornAgainSample.HexagonalLattice2D_className(self)

    def parDefs(self):
        r"""parDefs(HexagonalLattice2D self) -> std::vector< ParaMeta,std::allocator< ParaMeta > >"""
        return _libBornAgainSample.HexagonalLattice2D_parDefs(self)

    def length1(self):
        r"""length1(HexagonalLattice2D self) -> double"""
        return _libBornAgainSample.HexagonalLattice2D_length1(self)

    def length2(self):
        r"""length2(HexagonalLattice2D self) -> double"""
        return _libBornAgainSample.HexagonalLattice2D_length2(self)

    def latticeAngle(self):
        r"""latticeAngle(HexagonalLattice2D self) -> double"""
        return _libBornAgainSample.HexagonalLattice2D_latticeAngle(self)

    def unitCellArea(self):
        r"""unitCellArea(HexagonalLattice2D self) -> double"""
        return _libBornAgainSample.HexagonalLattice2D_unitCellArea(self)

    def validate(self):
        r"""validate(HexagonalLattice2D self) -> std::string"""
        return _libBornAgainSample.HexagonalLattice2D_validate(self)
    __swig_destroy__ = _libBornAgainSample.delete_HexagonalLattice2D

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

def CubicLattice(a):
    r"""CubicLattice(double a) -> Lattice3D"""
    return _libBornAgainSample.CubicLattice(a)

def FCCLattice(a):
    r"""FCCLattice(double a) -> Lattice3D"""
    return _libBornAgainSample.FCCLattice(a)

def HexagonalLattice(a, c):
    r"""HexagonalLattice(double a, double c) -> Lattice3D"""
    return _libBornAgainSample.HexagonalLattice(a, c)

def HCPLattice(a, c):
    r"""HCPLattice(double a, double c) -> Lattice3D"""
    return _libBornAgainSample.HCPLattice(a, c)

def TetragonalLattice(a, c):
    r"""TetragonalLattice(double a, double c) -> Lattice3D"""
    return _libBornAgainSample.TetragonalLattice(a, c)

def BCTLattice(a, c):
    r"""BCTLattice(double a, double c) -> Lattice3D"""
    return _libBornAgainSample.BCTLattice(a, c)
class Particle(IParticle):
    r"""Proxy of C++ Particle class."""

    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 className(self):
        r"""className(Particle self) -> std::string"""
        return _libBornAgainSample.Particle_className(self)

    def __init__(self, *args):
        r"""
        __init__(Particle self, Material material, IFormfactor formfactor) -> Particle
        __init__(Particle self, Material material, PyObject * pyFormfactor, int const arg4) -> 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_, IFormfactor):
            super().__init__(material_, ff_)
        elif hasattr(ff_, 'formfactor'):
            super().__init__(material_, ff_, 0)
        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.")