# 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__)


import weakref

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

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _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)
SHARED_PTR_DISOWN = _libBornAgainSample.SHARED_PTR_DISOWN


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

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

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

    def iterator(self):
        r"""iterator(vdouble1d_t self) -> SwigPyIterator"""
        return _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 swig_dummy_type_const_inode_vector(object):
    r"""Proxy of C++ std::vector< INode const * > class."""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register swig_dummy_type_const_inode_vector in _libBornAgainSample:
_libBornAgainSample.swig_dummy_type_const_inode_vector_swigregister(swig_dummy_type_const_inode_vector)
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 clone(self):
        r"""clone(IMaterialImpl self) -> IMaterialImpl"""
        return _libBornAgainSample.IMaterialImpl_clone(self)

    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 clone(self):
        r"""clone(RefractiveMaterialImpl self) -> RefractiveMaterialImpl"""
        return _libBornAgainSample.RefractiveMaterialImpl_clone(self)

    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 clone(self):
        r"""clone(MaterialBySLDImpl self) -> MaterialBySLDImpl"""
        return _libBornAgainSample.MaterialBySLDImpl_clone(self)

    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(libBornAgainBase.ICloneable, 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")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ISampleNode self) -> ISampleNode
        __init__(ISampleNode self, vdouble1d_t PValues) -> ISampleNode
        """
        if self.__class__ == ISampleNode:
            _self = None
        else:
            _self = self
        _libBornAgainSample.ISampleNode_swiginit(self, _libBornAgainSample.new_ISampleNode(_self, *args))

    def clone(self):
        r"""clone(ISampleNode self) -> ISampleNode"""
        return _libBornAgainSample.ISampleNode_clone(self)
    __swig_destroy__ = _libBornAgainSample.delete_ISampleNode
    def __disown__(self):
        self.this.disown()
        _libBornAgainSample.disown_ISampleNode(self)
        return weakref.proxy(self)

# 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")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(IFormFactor self) -> IFormFactor
        __init__(IFormFactor self, vdouble1d_t PValues) -> IFormFactor
        """
        if self.__class__ == IFormFactor:
            _self = None
        else:
            _self = self
        _libBornAgainSample.IFormFactor_swiginit(self, _libBornAgainSample.new_IFormFactor(_self, *args))
    __swig_destroy__ = _libBornAgainSample.delete_IFormFactor

    def clone(self):
        r"""clone(IFormFactor self) -> IFormFactor"""
        return _libBornAgainSample.IFormFactor_clone(self)

    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 pythonConstructor(self):
        r"""pythonConstructor(IFormFactor self) -> std::string"""
        return _libBornAgainSample.IFormFactor_pythonConstructor(self)

    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)
    def __disown__(self):
        self.this.disown()
        _libBornAgainSample.disown_IFormFactor(self)
        return weakref.proxy(self)

# Register IFormFactor in _libBornAgainSample:
_libBornAgainSample.IFormFactor_swigregister(IFormFactor)
class IRotation(libBornAgainBase.ICloneable, 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 clone(self):
        r"""clone(IRotation self) -> IRotation"""
        return _libBornAgainSample.IRotation_clone(self)

    def createInverse(self):
        r"""createInverse(IRotation self) -> IRotation"""
        return _libBornAgainSample.IRotation_createInverse(self)

    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 clone(self):
        r"""clone(IdentityRotation self) -> IdentityRotation"""
        return _libBornAgainSample.IdentityRotation_clone(self)

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

    def createInverse(self):
        r"""createInverse(IdentityRotation self) -> IdentityRotation"""
        return _libBornAgainSample.IdentityRotation_createInverse(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 clone(self):
        r"""clone(RotationX self) -> RotationX"""
        return _libBornAgainSample.RotationX_clone(self)

    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 createInverse(self):
        r"""createInverse(RotationX self) -> RotationX"""
        return _libBornAgainSample.RotationX_createInverse(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 clone(self):
        r"""clone(RotationY self) -> RotationY"""
        return _libBornAgainSample.RotationY_clone(self)

    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 createInverse(self):
        r"""createInverse(RotationY self) -> RotationY"""
        return _libBornAgainSample.RotationY_createInverse(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 clone(self):
        r"""clone(RotationZ self) -> RotationZ"""
        return _libBornAgainSample.RotationZ_clone(self)

    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 createInverse(self):
        r"""createInverse(RotationZ self) -> RotationZ"""
        return _libBornAgainSample.RotationZ_createInverse(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 clone(self):
        r"""clone(RotationEuler self) -> RotationEuler"""
        return _libBornAgainSample.RotationEuler_clone(self)

    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 createInverse(self):
        r"""createInverse(RotationEuler self) -> IRotation"""
        return _libBornAgainSample.RotationEuler_createInverse(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 clone(self):
        r"""clone(Crystal self) -> Crystal"""
        return _libBornAgainSample.Crystal_clone(self)

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

    def nodeChildren(self):
        r"""nodeChildren(Crystal self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Crystal_nodeChildren(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 clone(self):
        r"""clone(IParticle self) -> IParticle"""
        return _libBornAgainSample.IParticle_clone(self)

    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 clone(self):
        r"""clone(Mesocrystal self) -> Mesocrystal"""
        return _libBornAgainSample.Mesocrystal_clone(self)

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

    def nodeChildren(self):
        r"""nodeChildren(Mesocrystal self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Mesocrystal_nodeChildren(self)

# Register Mesocrystal in _libBornAgainSample:
_libBornAgainSample.Mesocrystal_swigregister(Mesocrystal)
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

    def __init__(self, material, formfactor):
        r"""__init__(Particle self, Material material, IFormFactor formfactor) -> Particle"""
        _libBornAgainSample.Particle_swiginit(self, _libBornAgainSample.new_Particle(material, formfactor))
    __swig_destroy__ = _libBornAgainSample.delete_Particle

    def clone(self):
        r"""clone(Particle self) -> Particle"""
        return _libBornAgainSample.Particle_clone(self)

    def className(self):
        r"""className(Particle self) -> std::string"""
        return _libBornAgainSample.Particle_className(self)

# Register Particle in _libBornAgainSample:
_libBornAgainSample.Particle_swigregister(Particle)
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 clone(self):
        r"""clone(Compound self) -> Compound"""
        return _libBornAgainSample.Compound_clone(self)

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

    def nodeChildren(self):
        r"""nodeChildren(Compound self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Compound_nodeChildren(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, *args):
        r"""__init__(CoreAndShell self, Particle core, Particle shell, R3 relative_core_position=R3()) -> CoreAndShell"""
        _libBornAgainSample.CoreAndShell_swiginit(self, _libBornAgainSample.new_CoreAndShell(*args))
    __swig_destroy__ = _libBornAgainSample.delete_CoreAndShell

    def clone(self):
        r"""clone(CoreAndShell self) -> CoreAndShell"""
        return _libBornAgainSample.CoreAndShell_clone(self)

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

# Register CoreAndShell in _libBornAgainSample:
_libBornAgainSample.CoreAndShell_swigregister(CoreAndShell)
class IProfile1D(libBornAgainBase.ICloneable, 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 clone(self):
        r"""clone(IProfile1D self) -> IProfile1D"""
        return _libBornAgainSample.IProfile1D_clone(self)

    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 clone(self):
        r"""clone(Profile1DCauchy self) -> Profile1DCauchy"""
        return _libBornAgainSample.Profile1DCauchy_clone(self)

    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 clone(self):
        r"""clone(Profile1DGauss self) -> Profile1DGauss"""
        return _libBornAgainSample.Profile1DGauss_clone(self)

    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 clone(self):
        r"""clone(Profile1DGate self) -> Profile1DGate"""
        return _libBornAgainSample.Profile1DGate_clone(self)

    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 clone(self):
        r"""clone(Profile1DTriangle self) -> Profile1DTriangle"""
        return _libBornAgainSample.Profile1DTriangle_clone(self)

    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 clone(self):
        r"""clone(Profile1DCosine self) -> Profile1DCosine"""
        return _libBornAgainSample.Profile1DCosine_clone(self)

    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 clone(self):
        r"""clone(Profile1DVoigt self) -> Profile1DVoigt"""
        return _libBornAgainSample.Profile1DVoigt_clone(self)

    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(libBornAgainBase.ICloneable, 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 clone(self):
        r"""clone(IProfile2D self) -> IProfile2D"""
        return _libBornAgainSample.IProfile2D_clone(self)

    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 clone(self):
        r"""clone(Profile2DCauchy self) -> Profile2DCauchy"""
        return _libBornAgainSample.Profile2DCauchy_clone(self)

    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 clone(self):
        r"""clone(Profile2DGauss self) -> Profile2DGauss"""
        return _libBornAgainSample.Profile2DGauss_clone(self)

    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 clone(self):
        r"""clone(Profile2DGate self) -> Profile2DGate"""
        return _libBornAgainSample.Profile2DGate_clone(self)

    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 clone(self):
        r"""clone(Profile2DCone self) -> Profile2DCone"""
        return _libBornAgainSample.Profile2DCone_clone(self)

    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 clone(self):
        r"""clone(Profile2DVoigt self) -> Profile2DVoigt"""
        return _libBornAgainSample.Profile2DVoigt_clone(self)

    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(libBornAgainBase.ICloneable, 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 clone(self):
        r"""clone(IPeakShape self) -> IPeakShape"""
        return _libBornAgainSample.IPeakShape_clone(self)

    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 clone(self):
        r"""clone(IsotropicGaussPeakShape self) -> IsotropicGaussPeakShape"""
        return _libBornAgainSample.IsotropicGaussPeakShape_clone(self)

    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 clone(self):
        r"""clone(IsotropicLorentzPeakShape self) -> IsotropicLorentzPeakShape"""
        return _libBornAgainSample.IsotropicLorentzPeakShape_clone(self)

    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 clone(self):
        r"""clone(GaussFisherPeakShape self) -> GaussFisherPeakShape"""
        return _libBornAgainSample.GaussFisherPeakShape_clone(self)

    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 clone(self):
        r"""clone(LorentzFisherPeakShape self) -> LorentzFisherPeakShape"""
        return _libBornAgainSample.LorentzFisherPeakShape_clone(self)

    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 clone(self):
        r"""clone(MisesFisherGaussPeakShape self) -> MisesFisherGaussPeakShape"""
        return _libBornAgainSample.MisesFisherGaussPeakShape_clone(self)

    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 clone(self):
        r"""clone(MisesGaussPeakShape self) -> MisesGaussPeakShape"""
        return _libBornAgainSample.MisesGaussPeakShape_clone(self)

    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(libBornAgainBase.ICloneable, 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 clone(self):
        r"""clone(IInterference self) -> IInterference"""
        return _libBornAgainSample.IInterference_clone(self)

    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 clone(self):
        r"""clone(Interference1DLattice self) -> Interference1DLattice"""
        return _libBornAgainSample.Interference1DLattice_clone(self)

    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 nodeChildren(self):
        r"""nodeChildren(Interference1DLattice self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Interference1DLattice_nodeChildren(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 clone(self):
        r"""clone(Interference2DLattice self) -> Interference2DLattice"""
        return _libBornAgainSample.Interference2DLattice_clone(self)

    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)

    def nodeChildren(self):
        r"""nodeChildren(Interference2DLattice self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Interference2DLattice_nodeChildren(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 clone(self):
        r"""clone(Interference2DParacrystal self) -> Interference2DParacrystal"""
        return _libBornAgainSample.Interference2DParacrystal_clone(self)

    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 nodeChildren(self):
        r"""nodeChildren(Interference2DParacrystal self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Interference2DParacrystal_nodeChildren(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 clone(self):
        r"""clone(Interference2DSuperLattice self) -> Interference2DSuperLattice"""
        return _libBornAgainSample.Interference2DSuperLattice_clone(self)

    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)

    def nodeChildren(self):
        r"""nodeChildren(Interference2DSuperLattice self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Interference2DSuperLattice_nodeChildren(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 clone(self):
        r"""clone(InterferenceFinite2DLattice self) -> InterferenceFinite2DLattice"""
        return _libBornAgainSample.InterferenceFinite2DLattice_clone(self)

    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)

    def nodeChildren(self):
        r"""nodeChildren(InterferenceFinite2DLattice self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.InterferenceFinite2DLattice_nodeChildren(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 clone(self):
        r"""clone(InterferenceHardDisk self) -> InterferenceHardDisk"""
        return _libBornAgainSample.InterferenceHardDisk_clone(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 clone(self):
        r"""clone(InterferenceNone self) -> InterferenceNone"""
        return _libBornAgainSample.InterferenceNone_clone(self)

    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 clone(self):
        r"""clone(InterferenceRadialParacrystal self) -> InterferenceRadialParacrystal"""
        return _libBornAgainSample.InterferenceRadialParacrystal_clone(self)

    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 nodeChildren(self):
        r"""nodeChildren(InterferenceRadialParacrystal self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.InterferenceRadialParacrystal_nodeChildren(self)

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

    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 clone(self):
        r"""clone(ParticleLayout self) -> ParticleLayout"""
        return _libBornAgainSample.ParticleLayout_clone(self)

    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 LayerRoughness(ISampleNode):
    r"""Proxy of C++ LayerRoughness 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__(LayerRoughness self, double sigma, double hurstParameter=0, double lateralCorrLength=0, RoughnessModel roughnessModel=None) -> LayerRoughness
        __init__(LayerRoughness self, double sigma, RoughnessModel roughnessModel) -> LayerRoughness
        __init__(LayerRoughness self) -> LayerRoughness
        """
        _libBornAgainSample.LayerRoughness_swiginit(self, _libBornAgainSample.new_LayerRoughness(*args))

    def clone(self):
        r"""clone(LayerRoughness self) -> LayerRoughness"""
        return _libBornAgainSample.LayerRoughness_clone(self)

    def className(self):
        r"""className(LayerRoughness self) -> std::string"""
        return _libBornAgainSample.LayerRoughness_className(self)

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

    def spectralFunction(self, kvec):
        r"""spectralFunction(LayerRoughness self, R3 kvec) -> double"""
        return _libBornAgainSample.LayerRoughness_spectralFunction(self, kvec)

    def corrFunction(self, k):
        r"""corrFunction(LayerRoughness self, R3 k) -> double"""
        return _libBornAgainSample.LayerRoughness_corrFunction(self, k)

    def setSigma(self, sigma):
        r"""setSigma(LayerRoughness self, double sigma)"""
        return _libBornAgainSample.LayerRoughness_setSigma(self, sigma)

    def sigma(self):
        r"""sigma(LayerRoughness self) -> double"""
        return _libBornAgainSample.LayerRoughness_sigma(self)

    def setHurstParameter(self, hurstParameter):
        r"""setHurstParameter(LayerRoughness self, double hurstParameter)"""
        return _libBornAgainSample.LayerRoughness_setHurstParameter(self, hurstParameter)

    def hurst(self):
        r"""hurst(LayerRoughness self) -> double"""
        return _libBornAgainSample.LayerRoughness_hurst(self)

    def setLatteralCorrLength(self, lateralCorrLength):
        r"""setLatteralCorrLength(LayerRoughness self, double lateralCorrLength)"""
        return _libBornAgainSample.LayerRoughness_setLatteralCorrLength(self, lateralCorrLength)

    def lateralCorrLength(self):
        r"""lateralCorrLength(LayerRoughness self) -> double"""
        return _libBornAgainSample.LayerRoughness_lateralCorrLength(self)

    def validate(self):
        r"""validate(LayerRoughness self) -> std::string"""
        return _libBornAgainSample.LayerRoughness_validate(self)

    def setRoughnessModel(self, roughnessModel):
        r"""setRoughnessModel(LayerRoughness self, RoughnessModel roughnessModel)"""
        return _libBornAgainSample.LayerRoughness_setRoughnessModel(self, roughnessModel)

    def roughnessModel(self):
        r"""roughnessModel(LayerRoughness self) -> RoughnessModel"""
        return _libBornAgainSample.LayerRoughness_roughnessModel(self)
    __swig_destroy__ = _libBornAgainSample.delete_LayerRoughness

# Register LayerRoughness in _libBornAgainSample:
_libBornAgainSample.LayerRoughness_swigregister(LayerRoughness)
class Layer(ISampleNode):
    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, material, thickness=0):
        r"""__init__(Layer self, Material material, double thickness=0) -> Layer"""
        _libBornAgainSample.Layer_swiginit(self, _libBornAgainSample.new_Layer(material, thickness))
    __swig_destroy__ = _libBornAgainSample.delete_Layer

    def clone(self):
        r"""clone(Layer self) -> Layer"""
        return _libBornAgainSample.Layer_clone(self)

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

    def nodeChildren(self):
        r"""nodeChildren(Layer self) -> swig_dummy_type_const_inode_vector"""
        return _libBornAgainSample.Layer_nodeChildren(self)

    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 MultiLayer(ISampleNode):
    r"""Proxy of C++ MultiLayer 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__(MultiLayer self) -> MultiLayer"""
        _libBornAgainSample.MultiLayer_swiginit(self, _libBornAgainSample.new_MultiLayer())
    __swig_destroy__ = _libBornAgainSample.delete_MultiLayer

    def clone(self):
        r"""clone(MultiLayer self) -> MultiLayer"""
        return _libBornAgainSample.MultiLayer_clone(self)

    def className(self):
        r"""className(MultiLayer self) -> std::string"""
        return _libBornAgainSample.MultiLayer_className(self)

    def addLayer(self, layer):
        r"""addLayer(MultiLayer self, Layer layer)"""
        return _libBornAgainSample.MultiLayer_addLayer(self, layer)

    def addLayerWithTopRoughness(self, layer, roughness):
        r"""addLayerWithTopRoughness(MultiLayer self, Layer layer, LayerRoughness roughness)"""
        return _libBornAgainSample.MultiLayer_addLayerWithTopRoughness(self, layer, roughness)

    def setCrossCorrLength(self, crossCorrLength):
        r"""setCrossCorrLength(MultiLayer self, double crossCorrLength)"""
        return _libBornAgainSample.MultiLayer_setCrossCorrLength(self, crossCorrLength)

    def setExternalField(self, ext_field):
        r"""setExternalField(MultiLayer self, R3 ext_field)"""
        return _libBornAgainSample.MultiLayer_setExternalField(self, ext_field)

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

# Register MultiLayer in _libBornAgainSample:
_libBornAgainSample.MultiLayer_swigregister(MultiLayer)
class RoughnessModel(libBornAgainBase.ICloneable):
    r"""Proxy of C++ RoughnessModel 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 clone(self):
        r"""clone(RoughnessModel self) -> RoughnessModel"""
        return _libBornAgainSample.RoughnessModel_clone(self)

    def transient(self, x, sigma):
        r"""transient(RoughnessModel self, double x, double sigma) -> double"""
        return _libBornAgainSample.RoughnessModel_transient(self, x, sigma)
    __swig_destroy__ = _libBornAgainSample.delete_RoughnessModel

# Register RoughnessModel in _libBornAgainSample:
_libBornAgainSample.RoughnessModel_swigregister(RoughnessModel)
class ErfRoughness(RoughnessModel):
    r"""Proxy of C++ ErfRoughness 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__(ErfRoughness self) -> ErfRoughness"""
        _libBornAgainSample.ErfRoughness_swiginit(self, _libBornAgainSample.new_ErfRoughness())

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

    def clone(self):
        r"""clone(ErfRoughness self) -> ErfRoughness"""
        return _libBornAgainSample.ErfRoughness_clone(self)
    __swig_destroy__ = _libBornAgainSample.delete_ErfRoughness

# Register ErfRoughness in _libBornAgainSample:
_libBornAgainSample.ErfRoughness_swigregister(ErfRoughness)
class TanhRoughness(RoughnessModel):
    r"""Proxy of C++ TanhRoughness 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__(TanhRoughness self) -> TanhRoughness"""
        _libBornAgainSample.TanhRoughness_swiginit(self, _libBornAgainSample.new_TanhRoughness())

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

    def clone(self):
        r"""clone(TanhRoughness self) -> TanhRoughness"""
        return _libBornAgainSample.TanhRoughness_clone(self)
    __swig_destroy__ = _libBornAgainSample.delete_TanhRoughness

# Register TanhRoughness in _libBornAgainSample:
_libBornAgainSample.TanhRoughness_swigregister(TanhRoughness)
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 clone(self):
        r"""clone(Box self) -> Box"""
        return _libBornAgainSample.Box_clone(self)

    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 clone(self):
        r"""clone(Prism3 self) -> Prism3"""
        return _libBornAgainSample.Prism3_clone(self)

    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 clone(self):
        r"""clone(Prism6 self) -> Prism6"""
        return _libBornAgainSample.Prism6_clone(self)

    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 clone(self):
        r"""clone(PlatonicTetrahedron self) -> PlatonicTetrahedron"""
        return _libBornAgainSample.PlatonicTetrahedron_clone(self)

    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 clone(self):
        r"""clone(PlatonicOctahedron self) -> PlatonicOctahedron"""
        return _libBornAgainSample.PlatonicOctahedron_clone(self)

    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 clone(self):
        r"""clone(Dodecahedron self) -> Dodecahedron"""
        return _libBornAgainSample.Dodecahedron_clone(self)

    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 clone(self):
        r"""clone(Icosahedron self) -> Icosahedron"""
        return _libBornAgainSample.Icosahedron_clone(self)

    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 clone(self):
        r"""clone(Pyramid2 self) -> Pyramid2"""
        return _libBornAgainSample.Pyramid2_clone(self)

    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 clone(self):
        r"""clone(Pyramid3 self) -> Pyramid3"""
        return _libBornAgainSample.Pyramid3_clone(self)

    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 clone(self):
        r"""clone(Pyramid4 self) -> Pyramid4"""
        return _libBornAgainSample.Pyramid4_clone(self)

    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 clone(self):
        r"""clone(Pyramid6 self) -> Pyramid6"""
        return _libBornAgainSample.Pyramid6_clone(self)

    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 clone(self):
        r"""clone(Bipyramid4 self) -> Bipyramid4"""
        return _libBornAgainSample.Bipyramid4_clone(self)

    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 clone(self):
        r"""clone(CantellatedCube self) -> CantellatedCube"""
        return _libBornAgainSample.CantellatedCube_clone(self)

    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 clone(self):
        r"""clone(TruncatedCube self) -> TruncatedCube"""
        return _libBornAgainSample.TruncatedCube_clone(self)

    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 clone(self):
        r"""clone(Cone self) -> Cone"""
        return _libBornAgainSample.Cone_clone(self)

    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 clone(self):
        r"""clone(Cylinder self) -> Cylinder"""
        return _libBornAgainSample.Cylinder_clone(self)

    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 clone(self):
        r"""clone(EllipsoidalCylinder self) -> EllipsoidalCylinder"""
        return _libBornAgainSample.EllipsoidalCylinder_clone(self)

    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 height) -> HemiEllipsoid
        __init__(HemiEllipsoid self, vdouble1d_t P) -> HemiEllipsoid
        """
        _libBornAgainSample.HemiEllipsoid_swiginit(self, _libBornAgainSample.new_HemiEllipsoid(*args))
    __swig_destroy__ = _libBornAgainSample.delete_HemiEllipsoid

    def clone(self):
        r"""clone(HemiEllipsoid self) -> HemiEllipsoid"""
        return _libBornAgainSample.HemiEllipsoid_clone(self)

    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 height(self):
        r"""height(HemiEllipsoid self) -> double"""
        return _libBornAgainSample.HemiEllipsoid_height(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 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 clone(self):
        r"""clone(HorizontalCylinder self) -> HorizontalCylinder"""
        return _libBornAgainSample.HorizontalCylinder_clone(self)

    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 clone(self):
        r"""clone(Sphere self) -> Sphere"""
        return _libBornAgainSample.Sphere_clone(self)

    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 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, double height) -> Spheroid
        __init__(Spheroid self, vdouble1d_t P) -> Spheroid
        """
        _libBornAgainSample.Spheroid_swiginit(self, _libBornAgainSample.new_Spheroid(*args))

    def clone(self):
        r"""clone(Spheroid self) -> Spheroid"""
        return _libBornAgainSample.Spheroid_clone(self)

    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 height(self):
        r"""height(Spheroid self) -> double"""
        return _libBornAgainSample.Spheroid_height(self)

    def radius(self):
        r"""radius(Spheroid self) -> double"""
        return _libBornAgainSample.Spheroid_radius(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 TruncatedSphere(IFormFactor):
    r"""Proxy of C++ TruncatedSphere 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__(TruncatedSphere self, double radius, double untruncated_height, double dh) -> TruncatedSphere
        __init__(TruncatedSphere self, vdouble1d_t P) -> TruncatedSphere
        """
        _libBornAgainSample.TruncatedSphere_swiginit(self, _libBornAgainSample.new_TruncatedSphere(*args))

    def clone(self):
        r"""clone(TruncatedSphere self) -> TruncatedSphere"""
        return _libBornAgainSample.TruncatedSphere_clone(self)

    def className(self):
        r"""className(TruncatedSphere self) -> std::string"""
        return _libBornAgainSample.TruncatedSphere_className(self)

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

    def untruncated_height(self):
        r"""untruncated_height(TruncatedSphere self) -> double"""
        return _libBornAgainSample.TruncatedSphere_untruncated_height(self)

    def radius(self):
        r"""radius(TruncatedSphere self) -> double"""
        return _libBornAgainSample.TruncatedSphere_radius(self)

    def removedTop(self):
        r"""removedTop(TruncatedSphere self) -> double"""
        return _libBornAgainSample.TruncatedSphere_removedTop(self)

    def height(self):
        r"""height(TruncatedSphere self) -> double"""
        return _libBornAgainSample.TruncatedSphere_height(self)

    def radialExtension(self):
        r"""radialExtension(TruncatedSphere self) -> double"""
        return _libBornAgainSample.TruncatedSphere_radialExtension(self)

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

    def validate(self):
        r"""validate(TruncatedSphere self) -> std::string"""
        return _libBornAgainSample.TruncatedSphere_validate(self)

    def contains(self, position):
        r"""contains(TruncatedSphere self, R3 position) -> bool"""
        return _libBornAgainSample.TruncatedSphere_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_TruncatedSphere

# Register TruncatedSphere in _libBornAgainSample:
_libBornAgainSample.TruncatedSphere_swigregister(TruncatedSphere)
class TruncatedSpheroid(IFormFactor):
    r"""Proxy of C++ TruncatedSpheroid 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__(TruncatedSpheroid self, double radius, double untruncated_height, double untruncated_height_flattening, double dh) -> TruncatedSpheroid
        __init__(TruncatedSpheroid self, vdouble1d_t P) -> TruncatedSpheroid
        """
        _libBornAgainSample.TruncatedSpheroid_swiginit(self, _libBornAgainSample.new_TruncatedSpheroid(*args))

    def clone(self):
        r"""clone(TruncatedSpheroid self) -> TruncatedSpheroid"""
        return _libBornAgainSample.TruncatedSpheroid_clone(self)

    def className(self):
        r"""className(TruncatedSpheroid self) -> std::string"""
        return _libBornAgainSample.TruncatedSpheroid_className(self)

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

    def radius(self):
        r"""radius(TruncatedSpheroid self) -> double"""
        return _libBornAgainSample.TruncatedSpheroid_radius(self)

    def untruncated_height(self):
        r"""untruncated_height(TruncatedSpheroid self) -> double"""
        return _libBornAgainSample.TruncatedSpheroid_untruncated_height(self)

    def heightFlattening(self):
        r"""heightFlattening(TruncatedSpheroid self) -> double"""
        return _libBornAgainSample.TruncatedSpheroid_heightFlattening(self)

    def removedTop(self):
        r"""removedTop(TruncatedSpheroid self) -> double"""
        return _libBornAgainSample.TruncatedSpheroid_removedTop(self)

    def height(self):
        r"""height(TruncatedSpheroid self) -> double"""
        return _libBornAgainSample.TruncatedSpheroid_height(self)

    def radialExtension(self):
        r"""radialExtension(TruncatedSpheroid self) -> double"""
        return _libBornAgainSample.TruncatedSpheroid_radialExtension(self)

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

    def validate(self):
        r"""validate(TruncatedSpheroid self) -> std::string"""
        return _libBornAgainSample.TruncatedSpheroid_validate(self)

    def contains(self, position):
        r"""contains(TruncatedSpheroid self, R3 position) -> bool"""
        return _libBornAgainSample.TruncatedSpheroid_contains(self, position)
    __swig_destroy__ = _libBornAgainSample.delete_TruncatedSpheroid

# Register TruncatedSpheroid in _libBornAgainSample:
_libBornAgainSample.TruncatedSpheroid_swigregister(TruncatedSpheroid)
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 clone(self):
        r"""clone(BarGauss self) -> BarGauss"""
        return _libBornAgainSample.BarGauss_clone(self)

    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 clone(self):
        r"""clone(BarLorentz self) -> BarLorentz"""
        return _libBornAgainSample.BarLorentz_clone(self)

    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 clone(self):
        r"""clone(CosineRippleBox self) -> CosineRippleBox"""
        return _libBornAgainSample.CosineRippleBox_clone(self)

    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 clone(self):
        r"""clone(CosineRippleGauss self) -> CosineRippleGauss"""
        return _libBornAgainSample.CosineRippleGauss_clone(self)

    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 clone(self):
        r"""clone(CosineRippleLorentz self) -> CosineRippleLorentz"""
        return _libBornAgainSample.CosineRippleLorentz_clone(self)

    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 clone(self):
        r"""clone(SawtoothRippleBox self) -> SawtoothRippleBox"""
        return _libBornAgainSample.SawtoothRippleBox_clone(self)

    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 clone(self):
        r"""clone(SawtoothRippleGauss self) -> SawtoothRippleGauss"""
        return _libBornAgainSample.SawtoothRippleGauss_clone(self)

    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 clone(self):
        r"""clone(SawtoothRippleLorentz self) -> SawtoothRippleLorentz"""
        return _libBornAgainSample.SawtoothRippleLorentz_clone(self)

    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 clone(self):
        r"""clone(LongBoxGauss self) -> LongBoxGauss"""
        return _libBornAgainSample.LongBoxGauss_clone(self)

    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 clone(self):
        r"""clone(LongBoxLorentz self) -> LongBoxLorentz"""
        return _libBornAgainSample.LongBoxLorentz_clone(self)

    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 clone(self):
        r"""clone(GaussSphere self) -> GaussSphere"""
        return _libBornAgainSample.GaussSphere_clone(self)

    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 clone(self):
        r"""clone(FuzzySphere self) -> FuzzySphere"""
        return _libBornAgainSample.FuzzySphere_clone(self)

    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 clone(self):
        r"""clone(ISelectionRule self) -> ISelectionRule"""
        return _libBornAgainSample.ISelectionRule_clone(self)

    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 clone(self):
        r"""clone(SimpleSelectionRule self) -> SimpleSelectionRule"""
        return _libBornAgainSample.SimpleSelectionRule_clone(self)

    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, arg2):
        r"""__eq__(SimpleSelectionRule self, SimpleSelectionRule arg2) -> bool"""
        return _libBornAgainSample.SimpleSelectionRule___eq__(self, arg2)

# 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 Lattice2D(libBornAgainBase.ICloneable, 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 clone(self):
        r"""clone(Lattice2D self) -> Lattice2D"""
        return _libBornAgainSample.Lattice2D_clone(self)

    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) -> Lattice2D::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 clone(self):
        r"""clone(BasicLattice2D self) -> BasicLattice2D"""
        return _libBornAgainSample.BasicLattice2D_clone(self)

    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 clone(self):
        r"""clone(SquareLattice2D self) -> SquareLattice2D"""
        return _libBornAgainSample.SquareLattice2D_clone(self)

    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 clone(self):
        r"""clone(HexagonalLattice2D self) -> HexagonalLattice2D"""
        return _libBornAgainSample.HexagonalLattice2D_clone(self)

    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)
