def timer(obj, *args):
""" Define the timers
>>> fun = ...
>>> fun_t = timer ( fun )
"""
##
if hasattr(obj, '__timer__'): return obj.__timer__(*args)
##
if isinstance(obj, str):
if not args: return LoKi.Timer(obj)
elif 1 == len(args):
arg0 = args[0]
if hasattr(arg0, '__timer__'): return timer(arg0, obj)
##
raise TypeErorr, "Invalid arguments "
from LoKiCore.functions import equal_to # Namespaces: from LoKiCore.basic import cpp, std, LoKi, LHCb, Gaudi _RCP = 'const LHCb::Particle*' _RCV = 'const LHCb::VertexBase*' _c1 = std.vector(_RCP) _c2 = std.vector(_RCV) ## ranges Range = Gaudi.NamedRange_(_c1) VRange = Gaudi.NamedRange_(_c2) ## range-lists: RangeL = LoKi.RangeList_(Range) VRangeL = LoKi.RangeList_(VRange) # ============================================================================= ## "The main" types # ============================================================================= ## @see LoKi::Types::Func Func = LoKi.Functor(_RCP, 'double') ## @see LoKi::Types::Cuts Cuts = LoKi.Functor(_RCP, bool) ## @see LoKi::Types::Fun Fun = LoKi.FunctorFromFunctor(_RCP, 'double') ## @see LoKi::Types::Cut Cut = LoKi.FunctorFromFunctor(_RCP, bool) ## @see LoKi::Types::Func
# ============================================================================= import LoKiCore.decorators as _LoKiCore # Namespaces: from LoKiCore.basic import cpp, std, LoKi LHCb = cpp.LHCb _T = 'const LHCb::Track*' # ============================================================================= ## "Ordinary" functions for Tracks: "Tr" # ============================================================================= ## @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
def first_n(N):
"""
helper object to select the first N-elements from the stream
"""
return LoKi.FirstN(N)
return doubles(lst, *args)
# =============================================================================
## @see LoKi::FirstN
def first_n(N):
"""
helper object to select the first N-elements from the stream
"""
return LoKi.FirstN(N)
# =============================================================================
## @see LoKi::Dump
Dump = LoKi.Dump
dump = LoKi.Dump()
## @see LoKi::Reverse
reverse = LoKi.Reverse()
## add the sequence to the vector
def _iadd_(v, o):
"""
add the sequence to the vector
"""
if hasattr(o, '__len__') and not issubclass(type(o), str):
for i in o:
v.push_back(i)
else:
v.push_back(o)
return v
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
try:
from GaudiKernel import ROOT6WorkAroundEnabled
except ImportError:
# dummy implementation
def ROOT6WorkAroundEnabled(id=None):
return False
if ROOT6WorkAroundEnabled('template-autoloading'):
cpp.gSystem.Load('libLoKiNumbersDict')
_d = 'double'
## _v = std.vector( _d )
_v = 'std::vector<double>'
XFunc = LoKi.Functor(_d, _d)
XFun = LoKi.FunctorFromFunctor(_d, _d)
XCuts = LoKi.Functor(_d, bool)
XCut = LoKi.FunctorFromFunctor(_d, bool)
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)
def _decorate(name=_name):
"""
Make the decoration of all objects from this module
"""
import LoKiCore.decorators as _LoKiCore
p = 'const LHCb::Particle*'
v = 'const LHCb::VertexBase*'
d = 'double'
_vp = 'std::vector<const LHCb::Particle*>' ## std.vector( p )
_vv = 'std::vector<const LHCb::VertexBase*>' ## std.vector( v )
_vd = 'std::vector<double>' ## std.vector( 'double' )
#_vp = std.vector( p )
#_vv = std.vector( v )
#_vd = std.vector( 'double' )
#
# "function" : Particle -> double
_decorated = _LoKiCore.getAndDecorateFunctions(
name, ## module name , ## the base
LoKi.Functor(p, 'double'), ## the base
LoKi.Dicts.FunCalls(LHCb.Particle), ## call-traits
LoKi.Dicts.FuncOps(p, p)) ## operators&operations
# "function" : Vertex -> double
_decorated |= _LoKiCore.getAndDecorateFunctions(
name, ## module name
LoKi.Functor(v, 'double'), ## the base
LoKi.Dicts.FunCalls(LHCb.VertexBase), ## call-traits
LoKi.Dicts.FuncOps(v, v)) ## operators&operations
# "predicate/cut" : Particle -> bool
_decorated |= _LoKiCore.getAndDecoratePredicates(
name, ## module name
LoKi.Functor(p, bool), ## the base
LoKi.Dicts.CutCalls(LHCb.Particle), ## call-traits
LoKi.Dicts.CutsOps(p, p)) ## operators&operations
# "predicate/cut" : Vertex -> bool
_decorated |= _LoKiCore.getAndDecoratePredicates(
name, ## moduel name
LoKi.Functor(v, bool), ## the base
LoKi.Dicts.CutCalls(LHCb.VertexBase), ## call-traits
LoKi.Dicts.CutsOps(v, v)) ## operators&operations
# =========================================================================
## functional part:
# =========================================================================
# "map" : vector<T> -> vector<double>
_decorated |= _LoKiCore.getAndDecorateMaps(
name, ## module name
LoKi.Functor(_vp, _vd), ## the base
LoKi.Dicts.MapsOps(p)) ## call-traits
_decorated |= _LoKiCore.getAndDecorateMaps(
name, ## module name
LoKi.Functor(_vv, _vd), ## the base
LoKi.Dicts.MapsOps(v)) ## call-traits
# "pipe" : vector<T> -> vector<T>
_decorated |= _LoKiCore.getAndDecoratePipes(
name, ## module name
LoKi.Functor(_vp, _vp), ## the base
LoKi.Dicts.PipeOps(p, p)) ## call-traits
_decorated |= _LoKiCore.getAndDecoratePipes(
name, ## module name
LoKi.Functor(_vv, _vv), ## the base
LoKi.Dicts.PipeOps(v, v)) ## call-traits
# "funval" : vector<T> -> double
_decorated |= _LoKiCore.getAndDecorateFunVals(
name, ## module name
LoKi.Functor(_vp, 'double'), ## the base
LoKi.Dicts.FunValOps(p)) ## call-traits
_decorated |= _LoKiCore.getAndDecorateFunVals(
name, ## module name
LoKi.Functor(_vv, 'double'), ## the base
LoKi.Dicts.FunValOps(v)) ## call-traits
# "cutval" : vector<T> -> bool
_decorated |= _LoKiCore.getAndDecorateCutVals(
name, ## module name
LoKi.Functor(_vp, bool), ## the base
LoKi.Dicts.CutValOps(p)) ## call-traits
_decorated |= _LoKiCore.getAndDecorateCutVals(
name, ## module name
LoKi.Functor(_vv, bool), ## the base
LoKi.Dicts.CutValOps(v)) ## call-traits
# 'source' : void -> vector<T>
_decorated |= _LoKiCore.getAndDecorateSources(
name, ## module name
LoKi.Functor('void', _vp), ## the base
LoKi.Dicts.SourceOps(p, p)) ## call-traits
_decorated |= _LoKiCore.getAndDecorateSources(
name, ## module name
LoKi.Functor('void', _vv), ## the base
LoKi.Dicts.SourceOps(v, v)) ## call-traits
# 'infos'
_decorated |= _LoKiCore.getAndDecorateInfos(
name, ## module name
LoKi.Functor(p, 'double'), ## the base
LoKi.Dicts.InfoOps(p)) ## methods
_decorated |= _LoKiCore.getAndDecorateInfos(
name, ## module name
LoKi.Functor(v, 'double'), ## the base
LoKi.Dicts.InfoOps(v)) ## methods
## void primitives
_decorated |= _LoKiCore.getAndDecoratePrimitiveVoids(name)
# decorate pids (Comparison with strings, integers and ParticleID objects:
for t in (ID, ABSID):
t = type(t)
_LoKiCore.decoratePID(t, LoKi.Dicts.PIDOps(t))
_decorated.add(t)
##
return _decorated
from LoKiCore.basic import cpp, std, LoKi LHCb = cpp.LHCb Hlt = cpp.Hlt # ============================================================================= ## new stuff ## # ============================================================================= _TC = 'const Hlt::Candidate*' _TS = 'const Hlt::Stage*' _vC = std.vector( _TC ) ## std::vector<const Hlt::Candidate*> _vD = std.vector( 'double' ) ## std::vector<double> ## @see LoKi::Types::TC_Func TC_Func = LoKi.Functor ( _TC , 'double' ) ## @see LoKi::Types::TC_Cuts TC_Cuts = LoKi.Functor ( _TC , bool ) ## @see LoKi::Types::TC_Fun TC_Fun = LoKi.FunctorFromFunctor ( _TC , 'double' ) ## @see LoKi::Types::TC_Cut TC_Cut = LoKi.FunctorFromFunctor ( _TC , bool ) ## @see LoKi::Types::TS_Func TS_Func = LoKi.Functor ( _TS , 'double' ) ## @see LoKi::Types::TC_Cuts TS_Cuts = LoKi.Functor ( _TS , bool ) ## @see LoKi::Types::TC_Fun TS_Fun = LoKi.FunctorFromFunctor ( _TS , 'double' ) ## @see LoKi::Types::TC_Cut TS_Cut = LoKi.FunctorFromFunctor ( _TS , bool )