libBornAgainBase.py

        retrieve a 1d bin for the given index 

        """
        return _libBornAgainBase.IAxis_getBin(self, index)

    def getMin(self):
        r"""
        getMin(IAxis self) -> double
        virtual double IAxis::getMin() const =0

        Returns value of first point of axis. 

        """
        return _libBornAgainBase.IAxis_getMin(self)

    def getMax(self):
        r"""
        getMax(IAxis self) -> double
        virtual double IAxis::getMax() const =0

        Returns value of last point of axis. 

        """
        return _libBornAgainBase.IAxis_getMax(self)

    def getBinCenter(self, index):
        r"""
        getBinCenter(IAxis self, size_t index) -> double
        virtual double IAxis::getBinCenter(size_t index) const =0

        """
        return _libBornAgainBase.IAxis_getBinCenter(self, index)

    def findClosestIndex(self, value):
        r"""
        findClosestIndex(IAxis self, double value) -> size_t
        virtual size_t IAxis::findClosestIndex(double value) const =0

        find bin index which is best match for given value 

        """
        return _libBornAgainBase.IAxis_findClosestIndex(self, value)

    def __eq__(self, right):
        r"""__eq__(IAxis self, IAxis right) -> bool"""
        return _libBornAgainBase.IAxis___eq__(self, right)

    def __ne__(self, right):
        r"""__ne__(IAxis self, IAxis right) -> bool"""
        return _libBornAgainBase.IAxis___ne__(self, right)

    def getBinCenters(self):
        r"""
        getBinCenters(IAxis self) -> vdouble1d_t
        std::vector< double > IAxis::getBinCenters() const

        """
        return _libBornAgainBase.IAxis_getBinCenters(self)

    def getBinBoundaries(self):
        r"""
        getBinBoundaries(IAxis self) -> vdouble1d_t
        std::vector< double > IAxis::getBinBoundaries() const

        """
        return _libBornAgainBase.IAxis_getBinBoundaries(self)

    def createClippedAxis(self, left, right):
        r"""
        createClippedAxis(IAxis self, double left, double right) -> IAxis
        IAxis * IAxis::createClippedAxis(double left, double right) const

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.IAxis_createClippedAxis(self, left, right)

    def contains(self, value):
        r"""
        contains(IAxis self, double value) -> bool
        bool IAxis::contains(double value) const

        Returns true if axis contains given point. 

        """
        return _libBornAgainBase.IAxis_contains(self, value)

# Register IAxis in _libBornAgainBase:
_libBornAgainBase.IAxis_swigregister(IAxis)


def HaveSameNameAndShape(left, right):
    r"""
    HaveSameNameAndShape(IAxis left, IAxis right) -> bool
    bool HaveSameNameAndShape(const IAxis &left, const IAxis &right)

    global helper function for comparison of axes 

    """
    return _libBornAgainBase.HaveSameNameAndShape(left, right)
class VariableBinAxis(IAxis):
    r"""


    Axis with variable bin size.

    C++ includes: VariableBinAxis.h

    """

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

    def __init__(self, name, nbins, bin_boundaries):
        r"""
        __init__(VariableBinAxis self, std::string const & name, size_t nbins, vdouble1d_t bin_boundaries) -> VariableBinAxis
        VariableBinAxis::VariableBinAxis(const std::string &name, size_t nbins, const std::vector< double > &bin_boundaries)

        VariableBinAxis constructor.

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

        name: 
        Axis name

        nbins: 
        number of bins

        bin_boundaries: 
        Array of size nbins+1 containing low-edges for each bin and upper edge of last bin. 

        """
        _libBornAgainBase.VariableBinAxis_swiginit(self, _libBornAgainBase.new_VariableBinAxis(name, nbins, bin_boundaries))
    __swig_destroy__ = _libBornAgainBase.delete_VariableBinAxis

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

        clone function 

        """
        return _libBornAgainBase.VariableBinAxis_clone(self)

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

        retrieve the number of bins 

        """
        return _libBornAgainBase.VariableBinAxis_size(self)

    def getBin(self, index):
        r"""
        getBin(VariableBinAxis self, size_t index) -> Bin1D
        Bin1D VariableBinAxis::getBin(size_t index) const

        retrieve a 1d bin for the given index 

        """
        return _libBornAgainBase.VariableBinAxis_getBin(self, index)

    def getMin(self):
        r"""
        getMin(VariableBinAxis self) -> double
        double VariableBinAxis::getMin() const

        Returns value of first point of axis. 

        """
        return _libBornAgainBase.VariableBinAxis_getMin(self)

    def getMax(self):
        r"""
        getMax(VariableBinAxis self) -> double
        double VariableBinAxis::getMax() const

        Returns value of last point of axis. 

        """
        return _libBornAgainBase.VariableBinAxis_getMax(self)

    def getBinCenter(self, index):
        r"""
        getBinCenter(VariableBinAxis self, size_t index) -> double
        double VariableBinAxis::getBinCenter(size_t index) const

        """
        return _libBornAgainBase.VariableBinAxis_getBinCenter(self, index)

    def findClosestIndex(self, value):
        r"""
        findClosestIndex(VariableBinAxis self, double value) -> size_t
        size_t VariableBinAxis::findClosestIndex(double value) const

        find bin index which is best match for given value 

        """
        return _libBornAgainBase.VariableBinAxis_findClosestIndex(self, value)

    def getBinCenters(self):
        r"""
        getBinCenters(VariableBinAxis self) -> vdouble1d_t
        std::vector< double > VariableBinAxis::getBinCenters() const

        """
        return _libBornAgainBase.VariableBinAxis_getBinCenters(self)

    def getBinBoundaries(self):
        r"""
        getBinBoundaries(VariableBinAxis self) -> vdouble1d_t
        std::vector<double> VariableBinAxis::getBinBoundaries() const

        """
        return _libBornAgainBase.VariableBinAxis_getBinBoundaries(self)

    def createClippedAxis(self, left, right):
        r"""
        createClippedAxis(VariableBinAxis self, double left, double right) -> VariableBinAxis
        VariableBinAxis * VariableBinAxis::createClippedAxis(double left, double right) const

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.VariableBinAxis_createClippedAxis(self, left, right)

    def __getitem__(self, i):
        r"""__getitem__(VariableBinAxis self, unsigned int i) -> double"""
        return _libBornAgainBase.VariableBinAxis___getitem__(self, i)

# Register VariableBinAxis in _libBornAgainBase:
_libBornAgainBase.VariableBinAxis_swigregister(VariableBinAxis)

class ConstKBinAxis(VariableBinAxis):
    r"""


    Axis with fixed bin size in sin(angle) space.

    C++ includes: ConstKBinAxis.h

    """

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

    def __init__(self, name, nbins, start, end):
        r"""
        __init__(ConstKBinAxis self, std::string const & name, size_t nbins, double start, double end) -> ConstKBinAxis
        ConstKBinAxis::ConstKBinAxis(const std::string &name, size_t nbins, double start, double end)

        ConstKBinAxis constructor.

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

        name: 
        Axis name

        nbins: 
        number of bins

        start: 
        low edge of first bin

        end: 
        upper edge of last bin 

        """
        _libBornAgainBase.ConstKBinAxis_swiginit(self, _libBornAgainBase.new_ConstKBinAxis(name, nbins, start, end))
    __swig_destroy__ = _libBornAgainBase.delete_ConstKBinAxis

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

        clone function 

        """
        return _libBornAgainBase.ConstKBinAxis_clone(self)

    def createClippedAxis(self, left, right):
        r"""
        createClippedAxis(ConstKBinAxis self, double left, double right) -> ConstKBinAxis
        ConstKBinAxis * ConstKBinAxis::createClippedAxis(double left, double right) const final

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.ConstKBinAxis_createClippedAxis(self, left, right)

# Register ConstKBinAxis in _libBornAgainBase:
_libBornAgainBase.ConstKBinAxis_swigregister(ConstKBinAxis)

class CustomBinAxis(VariableBinAxis):
    r"""


    Axis with fixed bin size in sin(angle) space used for numerical comparison with IsGisaxs. The main feature of the axis is that it produces zero bin sizes.

    C++ includes: CustomBinAxis.h

    """

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

    def __init__(self, name, nbins, start, end):
        r"""
        __init__(CustomBinAxis self, std::string const & name, size_t nbins, double start, double end) -> CustomBinAxis
        CustomBinAxis::CustomBinAxis(const std::string &name, size_t nbins, double start, double end)

        CustomBinAxis constructor.

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

        name: 
        Axis name

        nbins: 
        number of bins

        start: 
        center of first bin (IsGisaxs convention)

        end: 
        center of last bin (IsGisaxs convention) 

        """
        _libBornAgainBase.CustomBinAxis_swiginit(self, _libBornAgainBase.new_CustomBinAxis(name, nbins, start, end))
    __swig_destroy__ = _libBornAgainBase.delete_CustomBinAxis

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

        clone function 

        """
        return _libBornAgainBase.CustomBinAxis_clone(self)

    def getBin(self, index):
        r"""
        getBin(CustomBinAxis self, size_t index) -> Bin1D
        Bin1D CustomBinAxis::getBin(size_t index) const

        retrieve a 1d bin for the given index 

        """
        return _libBornAgainBase.CustomBinAxis_getBin(self, index)

    def getBinCenters(self):
        r"""
        getBinCenters(CustomBinAxis self) -> vdouble1d_t
        std::vector< double > CustomBinAxis::getBinCenters() const

        """
        return _libBornAgainBase.CustomBinAxis_getBinCenters(self)

    def createClippedAxis(self, left, right):
        r"""
        createClippedAxis(CustomBinAxis self, double left, double right) -> CustomBinAxis
        CustomBinAxis * CustomBinAxis::createClippedAxis(double left, double right) const

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.CustomBinAxis_createClippedAxis(self, left, right)

# Register CustomBinAxis in _libBornAgainBase:
_libBornAgainBase.CustomBinAxis_swigregister(CustomBinAxis)

class FixedBinAxis(IAxis):
    r"""


    Axis with fixed bin size.

    C++ includes: FixedBinAxis.h

    """

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

    def __init__(self, name, nbins, start, end):
        r"""
        __init__(FixedBinAxis self, std::string const & name, size_t nbins, double start, double end) -> FixedBinAxis
        FixedBinAxis::FixedBinAxis(const std::string &name, size_t nbins, double start, double end)

        FixedBinAxis constructor.

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

        name: 
        Axis name

        nbins: 
        number of bins

        start: 
        low edge of first bin

        end: 
        upper edge of last bin 

        """
        _libBornAgainBase.FixedBinAxis_swiginit(self, _libBornAgainBase.new_FixedBinAxis(name, nbins, start, end))
    __swig_destroy__ = _libBornAgainBase.delete_FixedBinAxis

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

        clone function 

        """
        return _libBornAgainBase.FixedBinAxis_clone(self)

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

        retrieve the number of bins 

        """
        return _libBornAgainBase.FixedBinAxis_size(self)

    def getBin(self, index):
        r"""
        getBin(FixedBinAxis self, size_t index) -> Bin1D
        Bin1D FixedBinAxis::getBin(size_t index) const

        retrieve a 1d bin for the given index 

        """
        return _libBornAgainBase.FixedBinAxis_getBin(self, index)

    def getMin(self):
        r"""
        getMin(FixedBinAxis self) -> double
        double FixedBinAxis::getMin() const

        Returns value of first point of axis. 

        """
        return _libBornAgainBase.FixedBinAxis_getMin(self)

    def getMax(self):
        r"""
        getMax(FixedBinAxis self) -> double
        double FixedBinAxis::getMax() const

        Returns value of last point of axis. 

        """
        return _libBornAgainBase.FixedBinAxis_getMax(self)

    def getBinCenter(self, index):
        r"""
        getBinCenter(FixedBinAxis self, size_t index) -> double
        double FixedBinAxis::getBinCenter(size_t index) const

        """
        return _libBornAgainBase.FixedBinAxis_getBinCenter(self, index)

    def findClosestIndex(self, value):
        r"""
        findClosestIndex(FixedBinAxis self, double value) -> size_t
        size_t FixedBinAxis::findClosestIndex(double value) const

        find bin index which is best match for given value 

        """
        return _libBornAgainBase.FixedBinAxis_findClosestIndex(self, value)

    def getBinCenters(self):
        r"""
        getBinCenters(FixedBinAxis self) -> vdouble1d_t
        std::vector< double > FixedBinAxis::getBinCenters() const

        """
        return _libBornAgainBase.FixedBinAxis_getBinCenters(self)

    def getBinBoundaries(self):
        r"""
        getBinBoundaries(FixedBinAxis self) -> vdouble1d_t
        std::vector< double > FixedBinAxis::getBinBoundaries() const

        """
        return _libBornAgainBase.FixedBinAxis_getBinBoundaries(self)

    def createClippedAxis(self, left, right):
        r"""
        createClippedAxis(FixedBinAxis self, double left, double right) -> FixedBinAxis
        FixedBinAxis * FixedBinAxis::createClippedAxis(double left, double right) const

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.FixedBinAxis_createClippedAxis(self, left, right)

    def __getitem__(self, i):
        r"""__getitem__(FixedBinAxis self, unsigned int i) -> double"""
        return _libBornAgainBase.FixedBinAxis___getitem__(self, i)

# Register FixedBinAxis in _libBornAgainBase:
_libBornAgainBase.FixedBinAxis_swigregister(FixedBinAxis)

class IPixel(object):
    r"""


    Interface for a function that maps [0,1]x[0,1] to the kvectors in a pixel.

    C++ includes: IPixel.h

    """

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

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

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

        """
        return _libBornAgainBase.IPixel_clone(self)

    def createZeroSizePixel(self, x, y):
        r"""
        createZeroSizePixel(IPixel self, double x, double y) -> IPixel
        virtual IPixel* IPixel::createZeroSizePixel(double x, double y) const =0

        """
        return _libBornAgainBase.IPixel_createZeroSizePixel(self, x, y)

    def getK(self, x, y, wavelength):
        r"""
        getK(IPixel self, double x, double y, double wavelength) -> kvector_t
        virtual kvector_t IPixel::getK(double x, double y, double wavelength) const =0

        """
        return _libBornAgainBase.IPixel_getK(self, x, y, wavelength)

    def getIntegrationFactor(self, x, y):
        r"""
        getIntegrationFactor(IPixel self, double x, double y) -> double
        virtual double IPixel::getIntegrationFactor(double x, double y) const =0

        """
        return _libBornAgainBase.IPixel_getIntegrationFactor(self, x, y)

    def getSolidAngle(self):
        r"""
        getSolidAngle(IPixel self) -> double
        virtual double IPixel::getSolidAngle() const =0

        """
        return _libBornAgainBase.IPixel_getSolidAngle(self)

# Register IPixel in _libBornAgainBase:
_libBornAgainBase.IPixel_swigregister(IPixel)

class kvector_t(object):
    r"""


    Forked from CLHEP/Geometry by E. Chernyaev Evgueni.Tcherniaev@cern.ch, then reworked beyond recognition. Removed split of point and vector semantics. Transforms are relegated to a separate class  Transform3D. Three-dimensional vector template, for use with integer, double, or complex components.

    C++ includes: BasicVector3D.h

    """

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

    def __init__(self, *args):
        r"""
        __init__(kvector_t self) -> kvector_t
        __init__(kvector_t self, double const x1, double const y1, double const z1) -> kvector_t
        BasicVector3D< T >::BasicVector3D(const T x1, const T y1, const T z1)

        Constructor from cartesian components. 

        """
        _libBornAgainBase.kvector_t_swiginit(self, _libBornAgainBase.new_kvector_t(*args))

    def x(self):
        r"""
        x(kvector_t self) -> double
        T BasicVector3D< T >::x() const

        Returns x-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.kvector_t_x(self)

    def y(self):
        r"""
        y(kvector_t self) -> double
        T BasicVector3D< T >::y() const

        Returns y-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.kvector_t_y(self)

    def z(self):
        r"""
        z(kvector_t self) -> double
        T BasicVector3D< T >::z() const

        Returns z-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.kvector_t_z(self)

    def setX(self, a):
        r"""
        setX(kvector_t self, double const & a)
        void BasicVector3D< T >::setX(const T &a)

        Sets x-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.kvector_t_setX(self, a)

    def setY(self, a):
        r"""
        setY(kvector_t self, double const & a)
        void BasicVector3D< T >::setY(const T &a)

        Sets y-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.kvector_t_setY(self, a)

    def setZ(self, a):
        r"""
        setZ(kvector_t self, double const & a)
        void BasicVector3D< T >::setZ(const T &a)

        Sets z-component in cartesian coordinate system. 

        """
        return _libBornAgainBase.kvector_t_setZ(self, a)

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

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

    def conj(self):
        r"""
        conj(kvector_t self) -> kvector_t
        BasicVector3D< complex_t > BasicVector3D< complex_t >::conj() const

        """
        return _libBornAgainBase.kvector_t_conj(self)

    def mag2(self):
        r"""
        mag2(kvector_t self) -> double
        double BasicVector3D< T >::mag2() const

        Returns magnitude squared of the vector. 

        """
        return _libBornAgainBase.kvector_t_mag2(self)

    def mag(self):
        r"""
        mag(kvector_t self) -> double
        double BasicVector3D< T >::mag() const

        Returns magnitude of the vector. 

        """
        return _libBornAgainBase.kvector_t_mag(self)

    def magxy2(self):
        r"""
        magxy2(kvector_t self) -> double
        double BasicVector3D< T >::magxy2() const

        Returns squared distance from z axis. 

        """
        return _libBornAgainBase.kvector_t_magxy2(self)

    def magxy(self):
        r"""
        magxy(kvector_t self) -> double
        double BasicVector3D< T >::magxy() const

        Returns distance from z axis. 

        """
        return _libBornAgainBase.kvector_t_magxy(self)

    def phi(self):
        r"""
        phi(kvector_t self) -> double
        double BasicVector3D< T >::phi() const

        Returns azimuth angle. 

        """
        return _libBornAgainBase.kvector_t_phi(self)

    def theta(self):
        r"""
        theta(kvector_t self) -> double
        double BasicVector3D< T >::theta() const

        Returns polar angle. 

        """
        return _libBornAgainBase.kvector_t_theta(self)

    def cosTheta(self):
        r"""
        cosTheta(kvector_t self) -> double
        double BasicVector3D< T >::cosTheta() const

        Returns cosine of polar angle. 

        """
        return _libBornAgainBase.kvector_t_cosTheta(self)

    def sin2Theta(self):
        r"""
        sin2Theta(kvector_t self) -> double
        double BasicVector3D< T >::sin2Theta() const

        Returns squared sine of polar angle. 

        """
        return _libBornAgainBase.kvector_t_sin2Theta(self)

    def unit(self):
        r"""
        unit(kvector_t self) -> kvector_t
        BasicVector3D< complex_t > BasicVector3D< complex_t >::unit() const

        """
        return _libBornAgainBase.kvector_t_unit(self)

    def complex(self):
        r"""
        complex(kvector_t self) -> cvector_t
        BasicVector3D<std::complex<double> > BasicVector3D< T >::complex() const

        Returns this, trivially converted to complex type. 

        """
        return _libBornAgainBase.kvector_t_complex(self)

    def real(self):
        r"""
        real(kvector_t self) -> kvector_t
        BasicVector3D< double > BasicVector3D< complex_t >::real() const

        """
        return _libBornAgainBase.kvector_t_real(self)

    def angle(self, v):
        r"""
        angle(kvector_t self, kvector_t v) -> double
        double BasicVector3D< T >::angle(const BasicVector3D< T > &v) const

        Returns angle with respect to another vector. 

        """
        return _libBornAgainBase.kvector_t_angle(self, v)

    def project(self, v):
        r"""
        project(kvector_t self, kvector_t v) -> kvector_t
        BasicVector3D<T> BasicVector3D< T >::project(const BasicVector3D< T > &v) const

        Returns projection of this onto other vector: (this*v)*v/|v|^2. 

        """
        return _libBornAgainBase.kvector_t_project(self, v)
    __swig_destroy__ = _libBornAgainBase.delete_kvector_t

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

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

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

    def iterator(self):
        r"""iterator(vector_kvector_t self) -> SwigPyIterator"""
        return _libBornAgainBase.vector_kvector_t_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class cvector_t(object):
    r"""


    Forked from CLHEP/Geometry by E. Chernyaev Evgueni.Tcherniaev@cern.ch, then reworked beyond recognition. Removed split of point and vector semantics. Transforms are relegated to a separate class  Transform3D. Three-dimensional vector template, for use with integer, double, or complex components.

    C++ includes: BasicVector3D.h

    """

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

    def __init__(self, *args):
        r"""
        __init__(cvector_t self) -> cvector_t
        __init__(cvector_t self, std::complex< double > const x1, std::complex< double > const y1, std::complex< double > const z1) -> cvector_t
        BasicVector3D< T >::BasicVector3D(const T x1, const T y1, const T z1)

        Constructor from cartesian components. 

        """
        _libBornAgainBase.cvector_t_swiginit(self, _libBornAgainBase.new_cvector_t(*args))