Exemple #1
0
VSource = LoKi.FunctorFromFunctor('void', _vv)

EMPTY = LoKi.Functors.Empty(_RCP)()
VEMPTY = LoKi.Functors.Empty(_RCV)()
SIZE = LoKi.Functors.Size(_RCP)()
VSIZE = LoKi.Functors.Size(_RCV)()

# =============================================================================
## All concrete types
# =============================================================================

## @see LoKi::Cuts::ARMENTEROS
ARMENTEROS = LoKi.Particles.ArmenterosPodolanski()

## @see LoKi::Cuts::ALL
ALL = LoKi.Constant(_RCP, bool)(True)
## @see LoKi::Cuts::NONE
NONE = LoKi.Constant(_RCP, bool)(False)
## @see LoKi::Cuts::PALL
PALL = LoKi.Constant(_RCP, bool)(True)
## @see LoKi::Cuts::PNONE
PNONE = LoKi.Constant(_RCP, bool)(False)
## @see LoKi::Cuts::ONE
ONE = LoKi.Constant(_RCP, 'double')(1.0)
## @see LoKi::Cuts::ZERO
ZERO = LoKi.Constant(_RCP, 'double')(0.0)
## @see LoKi::Cuts::VALID
VALID = LoKi.Valid(_RCP)()
## @see LoKi::Cuts::SAME
SAME = LoKi.TheSame(_RCP)
## @see LoKi::Cuts::HASKEY
# =============================================================================

## @see LoKi::Types::TrFunc
TrFunc = LoKi.Functor(_T, 'double')
## @see LoKi::Types::TrCuts
TrCuts = LoKi.Functor(_T, bool)
## @see LoKi::Types::TrFun
TrFun = LoKi.FunctorFromFunctor(_T, 'double')
## @see LoKi::Types::TrCut
TrCut = LoKi.FunctorFromFunctor(_T, bool)

## @see LoKi::Cuts::TrTYPE
TrTYPE = LoKi.Tracks.Type()

## @see @see LoKi::Cuts::TrALL
TrALL = LoKi.Constant(_T, bool)(True)
## @see LoKi::Cuts::TrBACKWARD
TrBACKWARD = LoKi.Tracks.CheckFlag(LHCb.Track.Backward)
## @see LoKi::Cuts::TrCHI2
TrCHI2 = LoKi.Tracks.Chi2()
## @see LoKi::Cuts::TrCHI2PDOF
TrCHI2PDOF = LoKi.Tracks.Chi2PerDoF()
## @see LoKi::Cuts::TrGHOSTPROB
TrGHOSTPROB = LoKi.Tracks.GhostProb()
## @see LoKi::Cuts::TrCLONE
TrCLONE = LoKi.Tracks.CheckFlag(LHCb.Track.Clone)
## ## @see LoKi::Cuts::TrDE
## TrDE          = LoKi.Tracks.DeltaE     ()
## @see LoKi::Cuts::TrFALSE
TrFALSE = LoKi.Constant(_T, bool)(False)
## @see LoKi::Cuts::TrFILTER
XMaps = LoKi.Functor(_v, _v)
XMap = LoKi.FunctorFromFunctor(_v, _v)
XPipes = XMaps
XPipe = XMap

XFunVals = LoKi.Functor(_v, _d)
XFunVal = LoKi.FunctorFromFunctor(_v, _d)
XSources = LoKi.Functor('void', _v)
XSource = LoKi.FunctorFromFunctor('void', _v)

XVCuts = LoKi.Functor(_v, bool)
XVCut = LoKi.FunctorFromFunctor(_v, bool)
XCutVals = XVCuts
XCutVal = XVCut

XTRUE = LoKi.Constant(_d, bool)(True)
XALL = LoKi.Constant(_d, bool)(True)
XFALSE = LoKi.Constant(_d, bool)(False)
XNONE = LoKi.Constant(_d, bool)(False)

XONE = LoKi.Constant(_d, _d)(1.0)
XZERO = LoKi.Constant(_d, _d)(0.0)
XNULL = LoKi.Constant(_d, _d)(0.0)

XVONE = LoKi.Constant(_v, _d)(1.0)
XVZERO = LoKi.Constant(_v, _d)(0.0)

XVTRUE = LoKi.Constant(_v, bool)(True)
XVALL = LoKi.Constant(_v, bool)(True)
XVFALSE = LoKi.Constant(_v, bool)(False)
XVNONE = LoKi.Constant(_v, bool)(False)
Exemple #4
0
      This file is a part of LoKi project - 
'C++ ToolKit  for Smart and Friendly Physics Analysis'

The package has been designed with the kind help from
Galina PAKHLOVA and Sergey BARSUK.  Many bright ideas, 
contributions and advices from G.Raven, J.van Tilburg, 
A.Golutvin, P.Koppenburg have been used in the design.
"""
# =============================================================================
__author__ = "Pieter David [email protected]"
__date__ = "2007-05-29"
__version__ = "$Revision$ "
# =============================================================================

from LoKiCore.basic import LoKi, std, cpp
FALL = LoKi.Constant("void", bool)(True)
_c1 = std.vector('const LHCb::MCParticle*')
MCRange = cpp.Gaudi.NamedRange_(_c1)

# =============================================================================
if '__main__' == __name__:

    print 80 * '*'
    print __doc__
    print ' Author  : ', __author__
    print ' Version : ', __version__
    print ' Date    : ', __date__
    print 80 * '*'
    for i in dir():
        print i
Exemple #5
0
## @see LoKi::Types::TC_Pipe
TC_Pipe      = LoKi.FunctorFromFunctor      ( _vC    , _vC      )
## @see LoKi::Types::TC_FunVals
TC_FunVals   = LoKi.Functor                 ( _vC    , 'double' )
## @see LoKi::Types::TC_FunVal
TC_FunVal    = LoKi.FunctorFromFunctor      ( _vC    , 'double' )
## @see LoKi::Types::TC_CutVals
TC_CutVals   = LoKi.Functor                 ( _vC    , bool     )
## @see LoKi::Types::TC_CutVal
TC_CutVal    = LoKi.FunctorFromFunctor      ( _vC    , bool     )
## @see LoKi::Types::TC_Sources
TC_Sources   = LoKi.Functor                 ( 'void' , _vC      )
## @see LoKi::Types::TC_Source
TC_Source    = LoKi.FunctorFromFunctor      ( 'void' , _vC      )

TC_ALL       = LoKi.Constant ( _TC , bool ) ( True  )
TC_NONE      = LoKi.Constant ( _TC , bool ) ( False )

TS_ALL       = LoKi.Constant ( _TS , bool ) ( True  )
TS_NONE      = LoKi.Constant ( _TS , bool ) ( False )


## @see LoKi::Cuts::TC_TOTSTAGES
TC_TOTSTAGES = LoKi.Candidates.TotalStages ()
## @see LoKi::Cuts::TC_NSTAGES
TC_NSTAGES   = LoKi.Candidates.NStages
## @see LoKi::Cuts::TC_StFUN
TC_StFUN     = LoKi.Candidates.StageFun
## @see LoKi::Cuts::TC_StCUT
TC_StCUT     = LoKi.Candidates.StageCut
## @see LoKi::Cuts::TC_BRANCH