python-rivet 1.8.3-1.3 / usr / lib / python2.7 / dist-packages / rivet / rivetwrap.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# 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
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_rivetwrap', [dirname(__file__)])
        except ImportError:
            import _rivetwrap
            return _rivetwrap
        if fp is not None:
            try:
                _mod = imp.load_module('_rivetwrap', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _rivetwrap = swig_import_helper()
    del swig_import_helper
else:
    import _rivetwrap
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _rivetwrap.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _rivetwrap.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _rivetwrap.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class StrList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StrList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _rivetwrap.StrList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _rivetwrap.StrList___nonzero__(self)

    def __bool__(self):
        return _rivetwrap.StrList___bool__(self)

    def __len__(self):
        return _rivetwrap.StrList___len__(self)

    def pop(self):
        return _rivetwrap.StrList_pop(self)

    def __getslice__(self, i, j):
        return _rivetwrap.StrList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _rivetwrap.StrList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _rivetwrap.StrList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _rivetwrap.StrList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _rivetwrap.StrList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _rivetwrap.StrList___setitem__(self, *args)

    def append(self, x):
        return _rivetwrap.StrList_append(self, x)

    def empty(self):
        return _rivetwrap.StrList_empty(self)

    def size(self):
        return _rivetwrap.StrList_size(self)

    def clear(self):
        return _rivetwrap.StrList_clear(self)

    def swap(self, v):
        return _rivetwrap.StrList_swap(self, v)

    def get_allocator(self):
        return _rivetwrap.StrList_get_allocator(self)

    def begin(self):
        return _rivetwrap.StrList_begin(self)

    def end(self):
        return _rivetwrap.StrList_end(self)

    def rbegin(self):
        return _rivetwrap.StrList_rbegin(self)

    def rend(self):
        return _rivetwrap.StrList_rend(self)

    def pop_back(self):
        return _rivetwrap.StrList_pop_back(self)

    def erase(self, *args):
        return _rivetwrap.StrList_erase(self, *args)

    def __init__(self, *args):
        this = _rivetwrap.new_StrList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _rivetwrap.StrList_push_back(self, x)

    def front(self):
        return _rivetwrap.StrList_front(self)

    def back(self):
        return _rivetwrap.StrList_back(self)

    def assign(self, n, x):
        return _rivetwrap.StrList_assign(self, n, x)

    def resize(self, *args):
        return _rivetwrap.StrList_resize(self, *args)

    def insert(self, *args):
        return _rivetwrap.StrList_insert(self, *args)

    def reserve(self, n):
        return _rivetwrap.StrList_reserve(self, n)

    def capacity(self):
        return _rivetwrap.StrList_capacity(self)
    __swig_destroy__ = _rivetwrap.delete_StrList
    __del__ = lambda self: None
StrList_swigregister = _rivetwrap.StrList_swigregister
StrList_swigregister(StrList)

class DblPair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DblPair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DblPair, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _rivetwrap.new_DblPair(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["first"] = _rivetwrap.DblPair_first_set
    __swig_getmethods__["first"] = _rivetwrap.DblPair_first_get
    if _newclass:
        first = _swig_property(_rivetwrap.DblPair_first_get, _rivetwrap.DblPair_first_set)
    __swig_setmethods__["second"] = _rivetwrap.DblPair_second_set
    __swig_getmethods__["second"] = _rivetwrap.DblPair_second_get
    if _newclass:
        second = _swig_property(_rivetwrap.DblPair_second_get, _rivetwrap.DblPair_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__ = _rivetwrap.delete_DblPair
    __del__ = lambda self: None
DblPair_swigregister = _rivetwrap.DblPair_swigregister
DblPair_swigregister(DblPair)

class DblPairList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DblPairList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DblPairList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _rivetwrap.DblPairList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _rivetwrap.DblPairList___nonzero__(self)

    def __bool__(self):
        return _rivetwrap.DblPairList___bool__(self)

    def __len__(self):
        return _rivetwrap.DblPairList___len__(self)

    def pop(self):
        return _rivetwrap.DblPairList_pop(self)

    def __getslice__(self, i, j):
        return _rivetwrap.DblPairList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _rivetwrap.DblPairList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _rivetwrap.DblPairList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _rivetwrap.DblPairList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _rivetwrap.DblPairList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _rivetwrap.DblPairList___setitem__(self, *args)

    def append(self, x):
        return _rivetwrap.DblPairList_append(self, x)

    def empty(self):
        return _rivetwrap.DblPairList_empty(self)

    def size(self):
        return _rivetwrap.DblPairList_size(self)

    def clear(self):
        return _rivetwrap.DblPairList_clear(self)

    def swap(self, v):
        return _rivetwrap.DblPairList_swap(self, v)

    def get_allocator(self):
        return _rivetwrap.DblPairList_get_allocator(self)

    def begin(self):
        return _rivetwrap.DblPairList_begin(self)

    def end(self):
        return _rivetwrap.DblPairList_end(self)

    def rbegin(self):
        return _rivetwrap.DblPairList_rbegin(self)

    def rend(self):
        return _rivetwrap.DblPairList_rend(self)

    def pop_back(self):
        return _rivetwrap.DblPairList_pop_back(self)

    def erase(self, *args):
        return _rivetwrap.DblPairList_erase(self, *args)

    def __init__(self, *args):
        this = _rivetwrap.new_DblPairList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _rivetwrap.DblPairList_push_back(self, x)

    def front(self):
        return _rivetwrap.DblPairList_front(self)

    def back(self):
        return _rivetwrap.DblPairList_back(self)

    def assign(self, n, x):
        return _rivetwrap.DblPairList_assign(self, n, x)

    def resize(self, *args):
        return _rivetwrap.DblPairList_resize(self, *args)

    def insert(self, *args):
        return _rivetwrap.DblPairList_insert(self, *args)

    def reserve(self, n):
        return _rivetwrap.DblPairList_reserve(self, n)

    def capacity(self):
        return _rivetwrap.DblPairList_capacity(self)
    __swig_destroy__ = _rivetwrap.delete_DblPairList
    __del__ = lambda self: None
DblPairList_swigregister = _rivetwrap.DblPairList_swigregister
DblPairList_swigregister(DblPairList)


_rivetwrap.AIDAML_swigconstant(_rivetwrap)
AIDAML = _rivetwrap.AIDAML

_rivetwrap.FLAT_swigconstant(_rivetwrap)
FLAT = _rivetwrap.FLAT

_rivetwrap.ROOT_swigconstant(_rivetwrap)
ROOT = _rivetwrap.ROOT

def getKnownHistoFormats():
    return _rivetwrap.getKnownHistoFormats()
getKnownHistoFormats = _rivetwrap.getKnownHistoFormats

def getKnownHistoFormatsR():
    return _rivetwrap.getKnownHistoFormatsR()
getKnownHistoFormatsR = _rivetwrap.getKnownHistoFormatsR

def getKnownHistoFormatEnums():
    return _rivetwrap.getKnownHistoFormatEnums()
getKnownHistoFormatEnums = _rivetwrap.getKnownHistoFormatEnums

def getKnownHistoFormatNames():
    return _rivetwrap.getKnownHistoFormatNames()
getKnownHistoFormatNames = _rivetwrap.getKnownHistoFormatNames
class ParticleNames(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleNames, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ParticleNames, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["particleName"] = lambda x: _rivetwrap.ParticleNames_particleName
    if _newclass:
        particleName = staticmethod(_rivetwrap.ParticleNames_particleName)
    __swig_getmethods__["particleId"] = lambda x: _rivetwrap.ParticleNames_particleId
    if _newclass:
        particleId = staticmethod(_rivetwrap.ParticleNames_particleId)

    def _particleName(self, pid):
        return _rivetwrap.ParticleNames__particleName(self, pid)

    def _particleId(self, pname):
        return _rivetwrap.ParticleNames__particleId(self, pname)
    __swig_destroy__ = _rivetwrap.delete_ParticleNames
    __del__ = lambda self: None
ParticleNames_swigregister = _rivetwrap.ParticleNames_swigregister
ParticleNames_swigregister(ParticleNames)
cvar = _rivetwrap.cvar
ELECTRON = cvar.ELECTRON
POSITRON = cvar.POSITRON
PROTON = cvar.PROTON
ANTIPROTON = cvar.ANTIPROTON
PHOTON = cvar.PHOTON
NEUTRON = cvar.NEUTRON
ANTINEUTRON = cvar.ANTINEUTRON
MUON = cvar.MUON
ANTIMUON = cvar.ANTIMUON
NU_E = cvar.NU_E
NU_EBAR = cvar.NU_EBAR
NU_MU = cvar.NU_MU
NU_MUBAR = cvar.NU_MUBAR
NU_TAU = cvar.NU_TAU
NU_TAUBAR = cvar.NU_TAUBAR
PIPLUS = cvar.PIPLUS
PIMINUS = cvar.PIMINUS
PI0 = cvar.PI0
K0L = cvar.K0L
K0S = cvar.K0S
KPLUS = cvar.KPLUS
KMINUS = cvar.KMINUS
LAMBDA = cvar.LAMBDA
LAMBDABAR = cvar.LAMBDABAR
XIMINUS = cvar.XIMINUS
XIPLUS = cvar.XIPLUS
OMEGAMINUS = cvar.OMEGAMINUS
OMEGAPLUS = cvar.OMEGAPLUS
TAU = cvar.TAU
ANTITAU = cvar.ANTITAU
EMINUS = cvar.EMINUS
EPLUS = cvar.EPLUS
P = cvar.P
PBAR = cvar.PBAR
GLUON = cvar.GLUON
GAMMA = cvar.GAMMA
WPLUSBOSON = cvar.WPLUSBOSON
WMINUSBOSON = cvar.WMINUSBOSON
ZBOSON = cvar.ZBOSON
HIGGS = cvar.HIGGS
DQUARK = cvar.DQUARK
UQUARK = cvar.UQUARK
SQUARK = cvar.SQUARK
CQUARK = cvar.CQUARK
BQUARK = cvar.BQUARK
TQUARK = cvar.TQUARK
ANY = cvar.ANY

def ParticleNames_particleName(pid):
    return _rivetwrap.ParticleNames_particleName(pid)
ParticleNames_particleName = _rivetwrap.ParticleNames_particleName

def ParticleNames_particleId(pname):
    return _rivetwrap.ParticleNames_particleId(pname)
ParticleNames_particleId = _rivetwrap.ParticleNames_particleId


def toParticleName(p):
    return _rivetwrap.toParticleName(p)
toParticleName = _rivetwrap.toParticleName

def toParticleId(pname):
    return _rivetwrap.toParticleId(pname)
toParticleId = _rivetwrap.toParticleId

def make_pdgid_pair(*args):
    return _rivetwrap.make_pdgid_pair(*args)
make_pdgid_pair = _rivetwrap.make_pdgid_pair

def toBeamsString(pair):
    return _rivetwrap.toBeamsString(pair)
toBeamsString = _rivetwrap.toBeamsString
class PdgIdPair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PdgIdPair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PdgIdPair, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _rivetwrap.new_PdgIdPair(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["first"] = _rivetwrap.PdgIdPair_first_set
    __swig_getmethods__["first"] = _rivetwrap.PdgIdPair_first_get
    if _newclass:
        first = _swig_property(_rivetwrap.PdgIdPair_first_get, _rivetwrap.PdgIdPair_first_set)
    __swig_setmethods__["second"] = _rivetwrap.PdgIdPair_second_set
    __swig_getmethods__["second"] = _rivetwrap.PdgIdPair_second_get
    if _newclass:
        second = _swig_property(_rivetwrap.PdgIdPair_second_get, _rivetwrap.PdgIdPair_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__ = _rivetwrap.delete_PdgIdPair
    __del__ = lambda self: None
PdgIdPair_swigregister = _rivetwrap.PdgIdPair_swigregister
PdgIdPair_swigregister(PdgIdPair)

class PdgIdPairList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PdgIdPairList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PdgIdPairList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _rivetwrap.PdgIdPairList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _rivetwrap.PdgIdPairList___nonzero__(self)

    def __bool__(self):
        return _rivetwrap.PdgIdPairList___bool__(self)

    def __len__(self):
        return _rivetwrap.PdgIdPairList___len__(self)

    def pop(self):
        return _rivetwrap.PdgIdPairList_pop(self)

    def __getslice__(self, i, j):
        return _rivetwrap.PdgIdPairList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _rivetwrap.PdgIdPairList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _rivetwrap.PdgIdPairList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _rivetwrap.PdgIdPairList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _rivetwrap.PdgIdPairList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _rivetwrap.PdgIdPairList___setitem__(self, *args)

    def append(self, x):
        return _rivetwrap.PdgIdPairList_append(self, x)

    def empty(self):
        return _rivetwrap.PdgIdPairList_empty(self)

    def size(self):
        return _rivetwrap.PdgIdPairList_size(self)

    def clear(self):
        return _rivetwrap.PdgIdPairList_clear(self)

    def swap(self, v):
        return _rivetwrap.PdgIdPairList_swap(self, v)

    def get_allocator(self):
        return _rivetwrap.PdgIdPairList_get_allocator(self)

    def begin(self):
        return _rivetwrap.PdgIdPairList_begin(self)

    def end(self):
        return _rivetwrap.PdgIdPairList_end(self)

    def rbegin(self):
        return _rivetwrap.PdgIdPairList_rbegin(self)

    def rend(self):
        return _rivetwrap.PdgIdPairList_rend(self)

    def pop_back(self):
        return _rivetwrap.PdgIdPairList_pop_back(self)

    def erase(self, *args):
        return _rivetwrap.PdgIdPairList_erase(self, *args)

    def __init__(self, *args):
        this = _rivetwrap.new_PdgIdPairList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _rivetwrap.PdgIdPairList_push_back(self, x)

    def front(self):
        return _rivetwrap.PdgIdPairList_front(self)

    def back(self):
        return _rivetwrap.PdgIdPairList_back(self)

    def assign(self, n, x):
        return _rivetwrap.PdgIdPairList_assign(self, n, x)

    def resize(self, *args):
        return _rivetwrap.PdgIdPairList_resize(self, *args)

    def insert(self, *args):
        return _rivetwrap.PdgIdPairList_insert(self, *args)

    def reserve(self, n):
        return _rivetwrap.PdgIdPairList_reserve(self, n)

    def capacity(self):
        return _rivetwrap.PdgIdPairList_capacity(self)
    __swig_destroy__ = _rivetwrap.delete_PdgIdPairList
    __del__ = lambda self: None
PdgIdPairList_swigregister = _rivetwrap.PdgIdPairList_swigregister
PdgIdPairList_swigregister(PdgIdPairList)

class Log(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Log, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Log, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    TRACE = _rivetwrap.Log_TRACE
    DEBUG = _rivetwrap.Log_DEBUG
    INFO = _rivetwrap.Log_INFO
    WARN = _rivetwrap.Log_WARN
    WARNING = _rivetwrap.Log_WARNING
    ERROR = _rivetwrap.Log_ERROR
    CRITICAL = _rivetwrap.Log_CRITICAL
    ALWAYS = _rivetwrap.Log_ALWAYS
    __swig_getmethods__["setLogLevel"] = lambda x: _rivetwrap.Log_setLogLevel
    if _newclass:
        setLogLevel = staticmethod(_rivetwrap.Log_setLogLevel)
    __swig_destroy__ = _rivetwrap.delete_Log
    __del__ = lambda self: None
Log_swigregister = _rivetwrap.Log_swigregister
Log_swigregister(Log)

def Log_setLogLevel(name, level):
    return _rivetwrap.Log_setLogLevel(name, level)
Log_setLogLevel = _rivetwrap.Log_setLogLevel


def getLibPath():
    return _rivetwrap.getLibPath()
getLibPath = _rivetwrap.getLibPath

def getDataPath():
    return _rivetwrap.getDataPath()
getDataPath = _rivetwrap.getDataPath

def getRivetDataPath():
    return _rivetwrap.getRivetDataPath()
getRivetDataPath = _rivetwrap.getRivetDataPath

def getAnalysisLibPaths():
    return _rivetwrap.getAnalysisLibPaths()
getAnalysisLibPaths = _rivetwrap.getAnalysisLibPaths

def setAnalysisLibPaths(paths):
    return _rivetwrap.setAnalysisLibPaths(paths)
setAnalysisLibPaths = _rivetwrap.setAnalysisLibPaths

def addAnalysisLibPath(extrapath):
    return _rivetwrap.addAnalysisLibPath(extrapath)
addAnalysisLibPath = _rivetwrap.addAnalysisLibPath

def findAnalysisLibFile(filename):
    return _rivetwrap.findAnalysisLibFile(filename)
findAnalysisLibFile = _rivetwrap.findAnalysisLibFile

def getAnalysisRefPaths():
    return _rivetwrap.getAnalysisRefPaths()
getAnalysisRefPaths = _rivetwrap.getAnalysisRefPaths

def findAnalysisRefFile(*args):
    return _rivetwrap.findAnalysisRefFile(*args)
findAnalysisRefFile = _rivetwrap.findAnalysisRefFile

def getAnalysisInfoPaths():
    return _rivetwrap.getAnalysisInfoPaths()
getAnalysisInfoPaths = _rivetwrap.getAnalysisInfoPaths

def findAnalysisInfoFile(*args):
    return _rivetwrap.findAnalysisInfoFile(*args)
findAnalysisInfoFile = _rivetwrap.findAnalysisInfoFile

def getAnalysisPlotPaths():
    return _rivetwrap.getAnalysisPlotPaths()
getAnalysisPlotPaths = _rivetwrap.getAnalysisPlotPaths

def findAnalysisPlotFile(*args):
    return _rivetwrap.findAnalysisPlotFile(*args)
findAnalysisPlotFile = _rivetwrap.findAnalysisPlotFile

def version():
    return _rivetwrap.version()
version = _rivetwrap.version
class Event(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Event, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _rivetwrap.delete_Event
    __del__ = lambda self: None
Event_swigregister = _rivetwrap.Event_swigregister
Event_swigregister(Event)

class Particle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Particle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Particle, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _rivetwrap.delete_Particle
    __del__ = lambda self: None
Particle_swigregister = _rivetwrap.Particle_swigregister
Particle_swigregister(Particle)


def beams(e):
    return _rivetwrap.beams(e)
beams = _rivetwrap.beams

def beamIds(e):
    return _rivetwrap.beamIds(e)
beamIds = _rivetwrap.beamIds

def sqrtS(e):
    return _rivetwrap.sqrtS(e)
sqrtS = _rivetwrap.sqrtS
class Analysis(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Analysis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Analysis, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def name(self):
        return _rivetwrap.Analysis_name(self)

    def inspireId(self):
        return _rivetwrap.Analysis_inspireId(self)

    def spiresId(self):
        return _rivetwrap.Analysis_spiresId(self)

    def summary(self):
        return _rivetwrap.Analysis_summary(self)

    def description(self):
        return _rivetwrap.Analysis_description(self)

    def runInfo(self):
        return _rivetwrap.Analysis_runInfo(self)

    def experiment(self):
        return _rivetwrap.Analysis_experiment(self)

    def collider(self):
        return _rivetwrap.Analysis_collider(self)

    def year(self):
        return _rivetwrap.Analysis_year(self)

    def requiredBeams(self):
        return _rivetwrap.Analysis_requiredBeams(self)

    def requiredEnergies(self):
        return _rivetwrap.Analysis_requiredEnergies(self)

    def authors(self):
        return _rivetwrap.Analysis_authors(self)

    def references(self):
        return _rivetwrap.Analysis_references(self)

    def todos(self):
        return _rivetwrap.Analysis_todos(self)

    def status(self):
        return _rivetwrap.Analysis_status(self)

    def bibKey(self):
        return _rivetwrap.Analysis_bibKey(self)

    def bibTeX(self):
        return _rivetwrap.Analysis_bibTeX(self)

    def isCompatible(self, *args):
        return _rivetwrap.Analysis_isCompatible(self, *args)

    def needsCrossSection(self):
        return _rivetwrap.Analysis_needsCrossSection(self)
    __swig_destroy__ = _rivetwrap.delete_Analysis
    __del__ = lambda self: None
Analysis_swigregister = _rivetwrap.Analysis_swigregister
Analysis_swigregister(Analysis)

class AnalysisHandler(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnalysisHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AnalysisHandler, name)
    __repr__ = _swig_repr

    def __init__(self, runname):
        this = _rivetwrap.new_AnalysisHandler(runname)
        try:
            self.this.append(this)
        except:
            self.this = this

    def runName(self):
        return _rivetwrap.AnalysisHandler_runName(self)

    def numEvents(self):
        return _rivetwrap.AnalysisHandler_numEvents(self)

    def sumOfWeights(self):
        return _rivetwrap.AnalysisHandler_sumOfWeights(self)

    def sqrtS(self):
        return _rivetwrap.AnalysisHandler_sqrtS(self)

    def beams(self):
        return _rivetwrap.AnalysisHandler_beams(self)

    def beamIds(self):
        return _rivetwrap.AnalysisHandler_beamIds(self)

    def setIgnoreBeams(self, ignore):
        return _rivetwrap.AnalysisHandler_setIgnoreBeams(self, ignore)

    def analysisNames(self):
        return _rivetwrap.AnalysisHandler_analysisNames(self)

    def addAnalysis(self, analysisname):
        return _rivetwrap.AnalysisHandler_addAnalysis(self, analysisname)

    def addAnalyses(self, analysisnames):
        return _rivetwrap.AnalysisHandler_addAnalyses(self, analysisnames)

    def removeAnalysis(self, analysisname):
        return _rivetwrap.AnalysisHandler_removeAnalysis(self, analysisname)

    def removeAnalyses(self, analysisnames):
        return _rivetwrap.AnalysisHandler_removeAnalyses(self, analysisnames)

    def init(self, event):
        return _rivetwrap.AnalysisHandler_init(self, event)

    def analyze(self, event):
        return _rivetwrap.AnalysisHandler_analyze(self, event)

    def finalize(self):
        return _rivetwrap.AnalysisHandler_finalize(self)

    def needCrossSection(self):
        return _rivetwrap.AnalysisHandler_needCrossSection(self)

    def setCrossSection(self, xs):
        return _rivetwrap.AnalysisHandler_setCrossSection(self, xs)

    def crossSection(self):
        return _rivetwrap.AnalysisHandler_crossSection(self)

    def commitData(self):
        return _rivetwrap.AnalysisHandler_commitData(self)

    def writeData(self, filename):
        return _rivetwrap.AnalysisHandler_writeData(self, filename)
    __swig_destroy__ = _rivetwrap.delete_AnalysisHandler
    __del__ = lambda self: None
AnalysisHandler_swigregister = _rivetwrap.AnalysisHandler_swigregister
AnalysisHandler_swigregister(AnalysisHandler)

class AnalysisLoader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnalysisLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AnalysisLoader, name)
    __repr__ = _swig_repr
    __swig_getmethods__["analysisNames"] = lambda x: _rivetwrap.AnalysisLoader_analysisNames
    if _newclass:
        analysisNames = staticmethod(_rivetwrap.AnalysisLoader_analysisNames)
    __swig_getmethods__["getAnalysis"] = lambda x: _rivetwrap.AnalysisLoader_getAnalysis
    if _newclass:
        getAnalysis = staticmethod(_rivetwrap.AnalysisLoader_getAnalysis)

    def __init__(self):
        this = _rivetwrap.new_AnalysisLoader()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _rivetwrap.delete_AnalysisLoader
    __del__ = lambda self: None
AnalysisLoader_swigregister = _rivetwrap.AnalysisLoader_swigregister
AnalysisLoader_swigregister(AnalysisLoader)

def AnalysisLoader_analysisNames():
    return _rivetwrap.AnalysisLoader_analysisNames()
AnalysisLoader_analysisNames = _rivetwrap.AnalysisLoader_analysisNames

def AnalysisLoader_getAnalysis(analysisname):
    return _rivetwrap.AnalysisLoader_getAnalysis(analysisname)
AnalysisLoader_getAnalysis = _rivetwrap.AnalysisLoader_getAnalysis

class Run(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Run, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Run, name)
    __repr__ = _swig_repr

    def __init__(self, ah):
        this = _rivetwrap.new_Run(ah)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _rivetwrap.delete_Run
    __del__ = lambda self: None

    def setCrossSection(self, xs):
        return _rivetwrap.Run_setCrossSection(self, xs)

    def crossSection(self):
        return _rivetwrap.Run_crossSection(self)

    def setListAnalyses(self, dolist):
        return _rivetwrap.Run_setListAnalyses(self, dolist)

    def init(self, evtfile, weight=1.0):
        return _rivetwrap.Run_init(self, evtfile, weight)

    def openFile(self, evtfile, weight=1.0):
        return _rivetwrap.Run_openFile(self, evtfile, weight)

    def readEvent(self):
        return _rivetwrap.Run_readEvent(self)

    def processEvent(self):
        return _rivetwrap.Run_processEvent(self)

    def finalize(self):
        return _rivetwrap.Run_finalize(self)
Run_swigregister = _rivetwrap.Run_swigregister
Run_swigregister(Run)

# This file is compatible with both classic and new-style classes.