libBornAgainBase.py

        """
        return _libBornAgainBase.Transform3D_isYRotation(self)

    def isZRotation(self):
        r"""
        isZRotation(Transform3D self) -> bool
        bool Transform3D::isZRotation() const

        """
        return _libBornAgainBase.Transform3D_isZRotation(self)

# Register Transform3D in _libBornAgainBase:
_libBornAgainBase.Transform3D_swigregister(Transform3D)

def Transform3D_createRotateX(phi):
    r"""Transform3D_createRotateX(double phi) -> Transform3D"""
    return _libBornAgainBase.Transform3D_createRotateX(phi)

def Transform3D_createRotateY(phi):
    r"""Transform3D_createRotateY(double phi) -> Transform3D"""
    return _libBornAgainBase.Transform3D_createRotateY(phi)

def Transform3D_createRotateZ(phi):
    r"""Transform3D_createRotateZ(double phi) -> Transform3D"""
    return _libBornAgainBase.Transform3D_createRotateZ(phi)

def Transform3D_createRotateEuler(alpha, beta, gamma):
    r"""Transform3D_createRotateEuler(double alpha, double beta, double gamma) -> Transform3D"""
    return _libBornAgainBase.Transform3D_createRotateEuler(alpha, beta, gamma)

class Bin1D(object):
    r"""Proxy of C++ Bin1D 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__(Bin1D self) -> Bin1D
        __init__(Bin1D self, double lower, double upper) -> Bin1D
        Bin1D::Bin1D(double lower, double upper)

        """
        _libBornAgainBase.Bin1D_swiginit(self, _libBornAgainBase.new_Bin1D(*args))
    m_lower = property(_libBornAgainBase.Bin1D_m_lower_get, _libBornAgainBase.Bin1D_m_lower_set, doc=r"""m_lower : double""")
    m_upper = property(_libBornAgainBase.Bin1D_m_upper_get, _libBornAgainBase.Bin1D_m_upper_set, doc=r"""m_upper : double""")

    def center(self):
        r"""
        center(Bin1D self) -> double
        double Bin1D::center() const

        """
        return _libBornAgainBase.Bin1D_center(self)

    def binSize(self):
        r"""
        binSize(Bin1D self) -> double
        double Bin1D::binSize() const

        """
        return _libBornAgainBase.Bin1D_binSize(self)
    __swig_destroy__ = _libBornAgainBase.delete_Bin1D

# Register Bin1D in _libBornAgainBase:
_libBornAgainBase.Bin1D_swigregister(Bin1D)


def BinContains(bin, value):
    r"""
    BinContains(Bin1D bin, double value) -> bool
    bool BinContains(const Bin1D &bin, double value)

    Checks if value is contained in bin: value in [m_lower, m_upper) 

    """
    return _libBornAgainBase.BinContains(bin, value)
class Bin1DKVector(object):
    r"""


    An one-dimensional range of kvector_t's.

    C++ includes: Bin.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__(Bin1DKVector self) -> Bin1DKVector
        __init__(Bin1DKVector self, kvector_t lower, kvector_t upper) -> Bin1DKVector
        __init__(Bin1DKVector self, double wavelength, Bin1D alpha_bin, Bin1D phi_bin) -> Bin1DKVector
        Bin1DKVector::Bin1DKVector(double wavelength, const Bin1D &alpha_bin, const Bin1D &phi_bin)

        creation on  Bin1DKVector from alpha and phi bins 

        """
        _libBornAgainBase.Bin1DKVector_swiginit(self, _libBornAgainBase.new_Bin1DKVector(*args))

    def center(self):
        r"""
        center(Bin1DKVector self) -> kvector_t
        kvector_t Bin1DKVector::center() const

        """
        return _libBornAgainBase.Bin1DKVector_center(self)

    def span(self):
        r"""
        span(Bin1DKVector self) -> kvector_t
        kvector_t Bin1DKVector::span() const

        """
        return _libBornAgainBase.Bin1DKVector_span(self)
    m_q_lower = property(_libBornAgainBase.Bin1DKVector_m_q_lower_get, _libBornAgainBase.Bin1DKVector_m_q_lower_set, doc=r"""m_q_lower : kvector_t""")
    m_q_upper = property(_libBornAgainBase.Bin1DKVector_m_q_upper_get, _libBornAgainBase.Bin1DKVector_m_q_upper_set, doc=r"""m_q_upper : kvector_t""")
    __swig_destroy__ = _libBornAgainBase.delete_Bin1DKVector

# Register Bin1DKVector in _libBornAgainBase:
_libBornAgainBase.Bin1DKVector_swigregister(Bin1DKVector)

class Bin1DCVector(object):
    r"""


    An one-dimensional range of cvector_t's.

    C++ includes: Bin.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__(Bin1DCVector self) -> Bin1DCVector
        __init__(Bin1DCVector self, cvector_t lower, cvector_t upper) -> Bin1DCVector
        __init__(Bin1DCVector self, double wavelength, Bin1D alpha_bin, Bin1D phi_bin) -> Bin1DCVector
        Bin1DCVector::Bin1DCVector(double wavelength, const Bin1D &alpha_bin, const Bin1D &phi_bin)

        creation on  Bin1DCVector from alpha and phi bins 

        """
        _libBornAgainBase.Bin1DCVector_swiginit(self, _libBornAgainBase.new_Bin1DCVector(*args))

    def center(self):
        r"""
        center(Bin1DCVector self) -> cvector_t
        cvector_t Bin1DCVector::center() const

        """
        return _libBornAgainBase.Bin1DCVector_center(self)

    def span(self):
        r"""
        span(Bin1DCVector self) -> cvector_t
        cvector_t Bin1DCVector::span() const

        """
        return _libBornAgainBase.Bin1DCVector_span(self)
    m_q_lower = property(_libBornAgainBase.Bin1DCVector_m_q_lower_get, _libBornAgainBase.Bin1DCVector_m_q_lower_set, doc=r"""m_q_lower : cvector_t""")
    m_q_upper = property(_libBornAgainBase.Bin1DCVector_m_q_upper_get, _libBornAgainBase.Bin1DCVector_m_q_upper_set, doc=r"""m_q_upper : cvector_t""")
    __swig_destroy__ = _libBornAgainBase.delete_Bin1DCVector

# Register Bin1DCVector in _libBornAgainBase:
_libBornAgainBase.Bin1DCVector_swigregister(Bin1DCVector)

class IAxis(object):
    r"""


    Abstract base class for one-dimensional axes.

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

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

        """
        return _libBornAgainBase.IAxis_clone(self)

    def setName(self, name):
        r"""
        setName(IAxis self, std::string name)
        void IAxis::setName(std::string name)

        Sets the axis label. 

        """
        return _libBornAgainBase.IAxis_setName(self, name)

    def size(self):
        r"""
        size(IAxis self) -> size_t
        virtual size_t IAxis::size() const =0

        Returns the number of bins. 

        """
        return _libBornAgainBase.IAxis_size(self)

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

        Returns value of first point of axis. 

        """
        return _libBornAgainBase.IAxis_lowerBound(self)

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

        Returns value of last point of axis. 

        """
        return _libBornAgainBase.IAxis_upperBound(self)

    def bounds(self):
        r"""
        bounds(IAxis self) -> pvacuum_double_t
        std::pair< double, double > IAxis::bounds() const

        Returns lower and upper bound in a pair. first is lower, second is upper. 

        """
        return _libBornAgainBase.IAxis_bounds(self)

    def span(self):
        r"""
        span(IAxis self) -> double
        double IAxis::span() const

        Returns distance from first to last point. 

        """
        return _libBornAgainBase.IAxis_span(self)

    def center(self):
        r"""
        center(IAxis self) -> double
        double IAxis::center() const

        Returns midpoint of axis. 

        """
        return _libBornAgainBase.IAxis_center(self)

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

        Returns the label of the axis. 

        """
        return _libBornAgainBase.IAxis_getName(self)

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

        """
        return _libBornAgainBase.IAxis_binCenters(self)

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

        """
        return _libBornAgainBase.IAxis_binBoundaries(self)

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

        retrieve a 1d bin for the given index 

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

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

        """
        return _libBornAgainBase.IAxis_binCenter(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 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)

    def createClippedAxis(self, lower, upper):
        r"""
        createClippedAxis(IAxis self, double lower, double upper) -> IAxis
        IAxis * IAxis::createClippedAxis(double lower, double upper) const

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.IAxis_createClippedAxis(self, lower, upper)

    def clip(self, *args):
        r"""
        clip(IAxis self, double lower, double upper)
        clip(IAxis self, pvacuum_double_t bounds)
        void IAxis::clip(const std::pair< double, double > bounds)

        Convenience overload to clip this axis to the given values. bounds.first is lower, bounds.second is upper value. 

        """
        return _libBornAgainBase.IAxis_clip(self, *args)

    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)

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

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 override

        """
        return _libBornAgainBase.VariableBinAxis_clone(self)

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

        Returns the number of bins. 

        """
        return _libBornAgainBase.VariableBinAxis_size(self)

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

        retrieve a 1d bin for the given index 

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

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

        Returns value of first point of axis. 

        """
        return _libBornAgainBase.VariableBinAxis_lowerBound(self)

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

        Returns value of last point of axis. 

        """
        return _libBornAgainBase.VariableBinAxis_upperBound(self)

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

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

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

        find bin index which is best match for given value 

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

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

        """
        return _libBornAgainBase.VariableBinAxis_binCenters(self)

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

        """
        return _libBornAgainBase.VariableBinAxis_binBoundaries(self)

    def createClippedAxis(self, lower, upper):
        r"""
        createClippedAxis(VariableBinAxis self, double lower, double upper) -> VariableBinAxis
        VariableBinAxis * VariableBinAxis::createClippedAxis(double lower, double upper) const override

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.VariableBinAxis_createClippedAxis(self, lower, upper)

    def clip(self, lower, upper):
        r"""
        clip(VariableBinAxis self, double lower, double upper)
        void VariableBinAxis::clip(double lower, double upper) override

        Clips this axis to the given values. 

        """
        return _libBornAgainBase.VariableBinAxis_clip(self, lower, upper)

    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 override

        """
        return _libBornAgainBase.ConstKBinAxis_clone(self)

    def createClippedAxis(self, lower, upper):
        r"""
        createClippedAxis(ConstKBinAxis self, double lower, double upper) -> ConstKBinAxis
        ConstKBinAxis * ConstKBinAxis::createClippedAxis(double lower, double upper) const override

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.ConstKBinAxis_createClippedAxis(self, lower, upper)

    def clip(self, lower, upper):
        r"""
        clip(ConstKBinAxis self, double lower, double upper)
        void ConstKBinAxis::clip(double lower, double upper) override

        Clips this axis to the given values. 

        """
        return _libBornAgainBase.ConstKBinAxis_clip(self, lower, upper)

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

        """
        return _libBornAgainBase.CustomBinAxis_clone(self)

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

        retrieve a 1d bin for the given index 

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

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

        """
        return _libBornAgainBase.CustomBinAxis_binCenters(self)

    def createClippedAxis(self, lower, upper):
        r"""
        createClippedAxis(CustomBinAxis self, double lower, double upper) -> CustomBinAxis
        CustomBinAxis * CustomBinAxis::createClippedAxis(double lower, double upper) const override

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.CustomBinAxis_createClippedAxis(self, lower, upper)

    def clip(self, lower, upper):
        r"""
        clip(CustomBinAxis self, double lower, double upper)
        void CustomBinAxis::clip(double lower, double upper) override

        Clips this axis to the given values. 

        """
        return _libBornAgainBase.CustomBinAxis_clip(self, lower, upper)

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

        """
        return _libBornAgainBase.FixedBinAxis_clone(self)

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

        Returns the number of bins. 

        """
        return _libBornAgainBase.FixedBinAxis_size(self)

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

        retrieve a 1d bin for the given index 

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

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

        Returns value of first point of axis. 

        """
        return _libBornAgainBase.FixedBinAxis_lowerBound(self)

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

        Returns value of last point of axis. 

        """
        return _libBornAgainBase.FixedBinAxis_upperBound(self)

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

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

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

        find bin index which is best match for given value 

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

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

        """
        return _libBornAgainBase.FixedBinAxis_binCenters(self)

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

        """
        return _libBornAgainBase.FixedBinAxis_binBoundaries(self)

    def createClippedAxis(self, lower, upper):
        r"""
        createClippedAxis(FixedBinAxis self, double lower, double upper) -> FixedBinAxis
        FixedBinAxis * FixedBinAxis::createClippedAxis(double lower, double upper) const override

        Creates a new clipped axis. 

        """
        return _libBornAgainBase.FixedBinAxis_createClippedAxis(self, lower, upper)

    def clip(self, lower, upper):
        r"""
        clip(FixedBinAxis self, double lower, double upper)
        void FixedBinAxis::clip(double lower, double upper) override

        Clips this axis to the given values. 

        """
        return _libBornAgainBase.FixedBinAxis_clip(self, lower, upper)

    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 kvector_t(object):
    r"""


    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)

        Constructs a vector 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<T> BasicVector3D< T >::conj() const

        Returns complex conjugate vector. 

        """
        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<T> BasicVector3D< T >::unit() const