rundec.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.2.0
#
# 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 the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _rundec
else:
    import _rundec

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


class SwigPyIterator(object):
    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__ = _rundec.delete_SwigPyIterator

    def value(self):
        return _rundec.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _rundec.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _rundec.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _rundec.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _rundec.SwigPyIterator_equal(self, x)

    def copy(self):
        return _rundec.SwigPyIterator_copy(self)

    def next(self):
        return _rundec.SwigPyIterator_next(self)

    def __next__(self):
        return _rundec.SwigPyIterator___next__(self)

    def previous(self):
        return _rundec.SwigPyIterator_previous(self)

    def advance(self, n):
        return _rundec.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _rundec.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _rundec.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _rundec.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _rundec.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _rundec.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _rundec.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _rundec:
_rundec.SwigPyIterator_swigregister(SwigPyIterator)
class PairDouble(object):
    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):
        _rundec.PairDouble_swiginit(self, _rundec.new_PairDouble(*args))
    first = property(_rundec.PairDouble_first_get, _rundec.PairDouble_first_set)
    second = property(_rundec.PairDouble_second_get, _rundec.PairDouble_second_set)
    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__ = _rundec.delete_PairDouble

# Register PairDouble in _rundec:
_rundec.PairDouble_swigregister(PairDouble)
class PairDoubleVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _rundec.PairDoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _rundec.PairDoubleVector___nonzero__(self)

    def __bool__(self):
        return _rundec.PairDoubleVector___bool__(self)

    def __len__(self):
        return _rundec.PairDoubleVector___len__(self)

    def __getslice__(self, i, j):
        return _rundec.PairDoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _rundec.PairDoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _rundec.PairDoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _rundec.PairDoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _rundec.PairDoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _rundec.PairDoubleVector___setitem__(self, *args)

    def pop(self):
        return _rundec.PairDoubleVector_pop(self)

    def append(self, x):
        return _rundec.PairDoubleVector_append(self, x)

    def empty(self):
        return _rundec.PairDoubleVector_empty(self)

    def size(self):
        return _rundec.PairDoubleVector_size(self)

    def swap(self, v):
        return _rundec.PairDoubleVector_swap(self, v)

    def begin(self):
        return _rundec.PairDoubleVector_begin(self)

    def end(self):
        return _rundec.PairDoubleVector_end(self)

    def rbegin(self):
        return _rundec.PairDoubleVector_rbegin(self)

    def rend(self):
        return _rundec.PairDoubleVector_rend(self)

    def clear(self):
        return _rundec.PairDoubleVector_clear(self)

    def get_allocator(self):
        return _rundec.PairDoubleVector_get_allocator(self)

    def pop_back(self):
        return _rundec.PairDoubleVector_pop_back(self)

    def erase(self, *args):
        return _rundec.PairDoubleVector_erase(self, *args)

    def __init__(self, *args):
        _rundec.PairDoubleVector_swiginit(self, _rundec.new_PairDoubleVector(*args))

    def push_back(self, x):
        return _rundec.PairDoubleVector_push_back(self, x)

    def front(self):
        return _rundec.PairDoubleVector_front(self)

    def back(self):
        return _rundec.PairDoubleVector_back(self)

    def assign(self, n, x):
        return _rundec.PairDoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _rundec.PairDoubleVector_resize(self, *args)

    def insert(self, *args):
        return _rundec.PairDoubleVector_insert(self, *args)

    def reserve(self, n):
        return _rundec.PairDoubleVector_reserve(self, n)

    def capacity(self):
        return _rundec.PairDoubleVector_capacity(self)
    __swig_destroy__ = _rundec.delete_PairDoubleVector

# Register PairDoubleVector in _rundec:
_rundec.PairDoubleVector_swigregister(PairDoubleVector)
class TriplenfMmuArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _rundec.TriplenfMmuArray_swiginit(self, _rundec.new_TriplenfMmuArray(nelements))
    __swig_destroy__ = _rundec.delete_TriplenfMmuArray

    def __getitem__(self, index):
        return _rundec.TriplenfMmuArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _rundec.TriplenfMmuArray___setitem__(self, index, value)

    def cast(self):
        return _rundec.TriplenfMmuArray_cast(self)

    @staticmethod
    def frompointer(t):
        return _rundec.TriplenfMmuArray_frompointer(t)

# Register TriplenfMmuArray in _rundec:
_rundec.TriplenfMmuArray_swigregister(TriplenfMmuArray)
class RunDecPairArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _rundec.RunDecPairArray_swiginit(self, _rundec.new_RunDecPairArray(nelements))
    __swig_destroy__ = _rundec.delete_RunDecPairArray

    def __getitem__(self, index):
        return _rundec.RunDecPairArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _rundec.RunDecPairArray___setitem__(self, index, value)

    def cast(self):
        return _rundec.RunDecPairArray_cast(self)

    @staticmethod
    def frompointer(t):
        return _rundec.RunDecPairArray_frompointer(t)

# Register RunDecPairArray in _rundec:
_rundec.RunDecPairArray_swigregister(RunDecPairArray)
class RunDec_values(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    asMz = property(_rundec.RunDec_values_asMz_get, _rundec.RunDec_values_asMz_set)
    asMtau = property(_rundec.RunDec_values_asMtau_get, _rundec.RunDec_values_asMtau_set)
    Mz = property(_rundec.RunDec_values_Mz_get, _rundec.RunDec_values_Mz_set)
    Mh = property(_rundec.RunDec_values_Mh_get, _rundec.RunDec_values_Mh_set)
    muc = property(_rundec.RunDec_values_muc_get, _rundec.RunDec_values_muc_set)
    mc3 = property(_rundec.RunDec_values_mc3_get, _rundec.RunDec_values_mc3_set)
    mub = property(_rundec.RunDec_values_mub_get, _rundec.RunDec_values_mub_set)
    Mtau = property(_rundec.RunDec_values_Mtau_get, _rundec.RunDec_values_Mtau_set)
    Mc = property(_rundec.RunDec_values_Mc_get, _rundec.RunDec_values_Mc_set)
    Mb = property(_rundec.RunDec_values_Mb_get, _rundec.RunDec_values_Mb_set)
    Mt = property(_rundec.RunDec_values_Mt_get, _rundec.RunDec_values_Mt_set)

    def __init__(self):
        _rundec.RunDec_values_swiginit(self, _rundec.new_RunDec_values())
    __swig_destroy__ = _rundec.delete_RunDec_values

# Register RunDec_values in _rundec:
_rundec.RunDec_values_swigregister(RunDec_values)
class TriplenfMmu(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    nf = property(_rundec.TriplenfMmu_nf_get, _rundec.TriplenfMmu_nf_set)
    Mth = property(_rundec.TriplenfMmu_Mth_get, _rundec.TriplenfMmu_Mth_set)
    muth = property(_rundec.TriplenfMmu_muth_get, _rundec.TriplenfMmu_muth_set)

    def __init__(self):
        _rundec.TriplenfMmu_swiginit(self, _rundec.new_TriplenfMmu())
    __swig_destroy__ = _rundec.delete_TriplenfMmu

# Register TriplenfMmu in _rundec:
_rundec.TriplenfMmu_swigregister(TriplenfMmu)
cvar = _rundec.cvar

class RunDecPair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    first = property(_rundec.RunDecPair_first_get, _rundec.RunDecPair_first_set)
    second = property(_rundec.RunDecPair_second_get, _rundec.RunDecPair_second_set)

    def __init__(self):
        _rundec.RunDecPair_swiginit(self, _rundec.new_RunDecPair())
    __swig_destroy__ = _rundec.delete_RunDecPair

# Register RunDecPair in _rundec:
_rundec.RunDecPair_swigregister(RunDecPair)
class AsmMS(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Asexact = property(_rundec.AsmMS_Asexact_get, _rundec.AsmMS_Asexact_set)
    mMSexact = property(_rundec.AsmMS_mMSexact_get, _rundec.AsmMS_mMSexact_set)

    def __init__(self):
        _rundec.AsmMS_swiginit(self, _rundec.new_AsmMS())
    __swig_destroy__ = _rundec.delete_AsmMS

# Register AsmMS in _rundec:
_rundec.AsmMS_swigregister(AsmMS)
class CRunDec(object):
    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):
        _rundec.CRunDec_swiginit(self, _rundec.new_CRunDec(*args))
    mq = property(_rundec.CRunDec_mq_get, _rundec.CRunDec_mq_set)
    nfMmu = property(_rundec.CRunDec_nfMmu_get, _rundec.CRunDec_nfMmu_set)
    AM = property(_rundec.CRunDec_AM_get, _rundec.CRunDec_AM_set)

    def GetNf(self):
        return _rundec.CRunDec_GetNf(self)

    def SetNf(self, nf):
        return _rundec.CRunDec_SetNf(self, nf)

    def DecLambdaUp(self, lam, massth, nl, nloops):
        return _rundec.CRunDec_DecLambdaUp(self, lam, massth, nl, nloops)

    def DecLambdaDown(self, lam, massth, nl, nloops):
        return _rundec.CRunDec_DecLambdaDown(self, lam, massth, nl, nloops)

    def AlL2AlH(self, asl, mu1, decpar, mu2, nloops):
        return _rundec.CRunDec_AlL2AlH(self, asl, mu1, decpar, mu2, nloops)

    def AlH2AlL(self, ash, mu1, decpar, mu2, nloops):
        return _rundec.CRunDec_AlH2AlL(self, ash, mu1, decpar, mu2, nloops)

    def mL2mH(self, mql, asl, mu1, decpar, mu2, nloops):
        return _rundec.CRunDec_mL2mH(self, mql, asl, mu1, decpar, mu2, nloops)

    def mH2mL(self, mqh, ash, mu1, decpar, mu2, nloops):
        return _rundec.CRunDec_mH2mL(self, mqh, ash, mu1, decpar, mu2, nloops)

    def mOS2mPS(self, mOS, mq, asmu, mu, muf, nl, nloops):
        return _rundec.CRunDec_mOS2mPS(self, mOS, mq, asmu, mu, muf, nl, nloops)

    def mMS2mPS(self, mMS, mq, asmu, mu, muf, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_mMS2mPS(self, mMS, mq, asmu, mu, muf, nl, nloops, fdelm)

    def mPS2mMS(self, mPS, mq, asmu, mu, muf, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_mPS2mMS(self, mPS, mq, asmu, mu, muf, nl, nloops, fdelm)

    def mPS2mSI(self, mPS, mq, _as, muf, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_mPS2mSI(self, mPS, mq, _as, muf, nl, nloops, fdelm)

    def mOS2m1S(self, mOS, mq, asmu, mu, nl, nloops):
        return _rundec.CRunDec_mOS2m1S(self, mOS, mq, asmu, mu, nl, nloops)

    def mMS2m1S(self, mMS, mq, asmu, mu, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_mMS2m1S(self, mMS, mq, asmu, mu, nl, nloops, fdelm)

    def m1S2mMS(self, m1S, mq, asmu, mu, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_m1S2mMS(self, m1S, mq, asmu, mu, nl, nloops, fdelm)

    def m1S2mSI(self, m1S, mq, _as, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_m1S2mSI(self, m1S, mq, _as, nl, nloops, fdelm)

    def mOS2mRS(self, *args):
        return _rundec.CRunDec_mOS2mRS(self, *args)

    def mMS2mRS(self, *args):
        return _rundec.CRunDec_mMS2mRS(self, *args)

    def mRS2mMS(self, *args):
        return _rundec.CRunDec_mRS2mMS(self, *args)

    def mRS2mSI(self, *args):
        return _rundec.CRunDec_mRS2mSI(self, *args)

    def mOS2mRSp(self, mOS, mq, asmu, mu, nuf, nl, nloops):
        return _rundec.CRunDec_mOS2mRSp(self, mOS, mq, asmu, mu, nuf, nl, nloops)

    def mMS2mRSp(self, mMS, mq, asmu, mu, nuf, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_mMS2mRSp(self, mMS, mq, asmu, mu, nuf, nl, nloops, fdelm)

    def mRSp2mMS(self, mRS, mq, asmu, mu, nuf, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_mRSp2mMS(self, mRS, mq, asmu, mu, nuf, nl, nloops, fdelm)

    def mRSp2mSI(self, mRS, mq, _as, nuf, nl, nloops, fdelm=1.0):
        return _rundec.CRunDec_mRSp2mSI(self, mRS, mq, _as, nuf, nl, nloops, fdelm)

    def LamExpl(self, *args):
        return _rundec.CRunDec_LamExpl(self, *args)

    def LamImpl(self, *args):
        return _rundec.CRunDec_LamImpl(self, *args)

    def AlphasLam(self, *args):
        return _rundec.CRunDec_AlphasLam(self, *args)

    def AlphasExact(self, *args):
        return _rundec.CRunDec_AlphasExact(self, *args)

    def mMS2mMS(self, *args):
        return _rundec.CRunDec_mMS2mMS(self, *args)

    def AsmMSrunexact(self, *args):
        return _rundec.CRunDec_AsmMSrunexact(self, *args)

    def DecAsDownOS(self, *args):
        return _rundec.CRunDec_DecAsDownOS(self, *args)

    def DecAsUpOS(self, *args):
        return _rundec.CRunDec_DecAsUpOS(self, *args)

    def DecAsDownMS(self, *args):
        return _rundec.CRunDec_DecAsDownMS(self, *args)

    def DecAsUpMS(self, *args):
        return _rundec.CRunDec_DecAsUpMS(self, *args)

    def DecAsDownSI(self, *args):
        return _rundec.CRunDec_DecAsDownSI(self, *args)

    def DecAsUpSI(self, *args):
        return _rundec.CRunDec_DecAsUpSI(self, *args)

    def DecMqUpOS(self, *args):
        return _rundec.CRunDec_DecMqUpOS(self, *args)

    def DecMqDownOS(self, *args):
        return _rundec.CRunDec_DecMqDownOS(self, *args)

    def DecMqUpMS(self, *args):
        return _rundec.CRunDec_DecMqUpMS(self, *args)

    def DecMqDownMS(self, *args):
        return _rundec.CRunDec_DecMqDownMS(self, *args)

    def DecMqUpSI(self, *args):
        return _rundec.CRunDec_DecMqUpSI(self, *args)

    def DecMqDownSI(self, *args):
        return _rundec.CRunDec_DecMqDownSI(self, *args)

    def mMS2mOS(self, *args):
        return _rundec.CRunDec_mMS2mOS(self, *args)

    def mOS2mMS(self, *args):
        return _rundec.CRunDec_mOS2mMS(self, *args)

    def mMS2mSI(self, *args):
        return _rundec.CRunDec_mMS2mSI(self, *args)

    def mRI2mMS(self, *args):
        return _rundec.CRunDec_mRI2mMS(self, *args)

    def mMS2mRGI(self, *args):
        return _rundec.CRunDec_mMS2mRGI(self, *args)

    def mRGI2mMS(self, *args):
        return _rundec.CRunDec_mRGI2mMS(self, *args)

    def mOS2mSI(self, *args):
        return _rundec.CRunDec_mOS2mSI(self, *args)

    def mOS2mMSrun(self, *args):
        return _rundec.CRunDec_mOS2mMSrun(self, *args)

    def mMS2mOSrun(self, *args):
        return _rundec.CRunDec_mMS2mOSrun(self, *args)

    def mMS2mRI(self, *args):
        return _rundec.CRunDec_mMS2mRI(self, *args)

    def mOS2mMSit(self, *args):
        return _rundec.CRunDec_mOS2mMSit(self, *args)

    def mMS2mRGImod(self, *args):
        return _rundec.CRunDec_mMS2mRGImod(self, *args)

    def mMS2mKIN(self, *args):
        return _rundec.CRunDec_mMS2mKIN(self, *args)

    def mKIN2mMS(self, *args):
        return _rundec.CRunDec_mKIN2mMS(self, *args)
    __swig_destroy__ = _rundec.delete_CRunDec

# Register CRunDec in _rundec:
_rundec.CRunDec_swigregister(CRunDec)

def fSetdydx(S, A, nl):
    return _rundec.fSetdydx(S, A, nl)

def fSetdydxa1(S, x, A):
    return _rundec.fSetdydxa1(S, x, A)

def fSetdydxM1(S, A, M):
    return _rundec.fSetdydxM1(S, A, M)

def fSetdydxa2(S, x, A):
    return _rundec.fSetdydxa2(S, x, A)

def fSetdydxM2(S, A, M):
    return _rundec.fSetdydxM2(S, A, M)

def fSetdydxa3(S, x, A):
    return _rundec.fSetdydxa3(S, x, A)

def fSetdydxM3(S, A, M):
    return _rundec.fSetdydxM3(S, A, M)

def fSetdydxa4(S, x, A):
    return _rundec.fSetdydxa4(S, x, A)

def fSetdydxM4(S, A, M):
    return _rundec.fSetdydxM4(S, A, M)

def fSetdydxa5(S, x, A):
    return _rundec.fSetdydxa5(S, x, A)

def fSetdydxM5(S, A, M):
    return _rundec.fSetdydxM5(S, A, M)