def _decorate(name=_name):
"""
Make the decoration of all objects from this module
"""
import LoKiCore.decorators as _LoKiCore
## regular functors which accept the track
_t = LHCb.Track
_pt = 'const LHCb::Track*'
# "function" : Track -> double
_decorated = _LoKiCore.getAndDecorateFunctions(
name, ## module name
TrFunc, ## the base
LoKi.Dicts.FunCalls(_t), ## call-traits
LoKi.Dicts.FuncOps(_pt, _pt)) ## operators&operations
# "predicate/cut" : Track -> bool
_decorated |= _LoKiCore.getAndDecoratePredicates(
name, ## module name
TrCuts, ## the base
LoKi.Dicts.CutCalls(_t), ## call-traits
LoKi.Dicts.CutsOps(_pt, _pt)) ## operators&operations
## functional stuff
_vt = 'std::vector<const LHCb::Track*>' ## std.vector ( )
_vd = 'std::vector<double>' ## std.vector ( 'double' )
# "map" : vector<T> -> vector<double>
_decorated |= _LoKiCore.getAndDecorateMaps(
name, ## module name
LoKi.Functor(_vt, _vd), ## the base
LoKi.Dicts.MapsOps(_pt)) ## call-traits
# "pipe" : vector<T> -> vector<T>
_decorated |= _LoKiCore.getAndDecoratePipes(
name, ## module name
LoKi.Functor(_vt, _vt), ## the base
LoKi.Dicts.PipeOps(_pt, _pt)) ## call-traits
# "funval" : vector<T> -> double
_decorated |= _LoKiCore.getAndDecorateFunVals(
name, ## module name
LoKi.Functor(_vt, 'double'), ## the base
LoKi.Dicts.FunValOps(_pt)) ## call-traits
# "cutval" : vector<T> -> bool
_decorated |= _LoKiCore.getAndDecorateCutVals(
name, ## module name
LoKi.Functor(_vt, bool), ## the base
LoKi.Dicts.CutValOps(_pt)) ## call-traits
# "source" : void -> vector<T>
_decorated |= _LoKiCore.getAndDecorateSources(
name, ## module name
LoKi.Functor('void', _vt), ## the base
LoKi.Dicts.SourceOps(_pt, _pt)) ## call-traits
## smart info:
_decorated |= _LoKiCore.getAndDecorateInfos(
name, ## module name
TrFunc, ## the base
LoKi.Dicts.InfoOps(_pt)) ## methods
##
## primitive voids:
_decorated |= _LoKiCore.getAndDecoratePrimitiveVoids(name)
return _decorated ## RETURN
def _decorate(name=_name):
"""
Make the decoration of all objects from this module
"""
import LoKiCore.decorators as _LoKiCore
_pp = 'const LHCb::ProtoParticle*'
_ppv = 'std::vector<const LHCb::ProtoParticle*>' ## std.vector( _mcp )
_vd = 'std::vector<double>' ## std.vector( 'double' )
#
# ProtoParticle -> double
_decorated = _LoKiCore.getAndDecorateFunctions(
name, ## module name
LoKi.Functor(_pp, 'double'), ## the base
LoKi.Dicts.FunCalls(LHCb.ProtoParticle), ## call-traits
LoKi.Dicts.FuncOps(_pp, _pp)) ## operators&operations
# ProtoParticle -> bool
_decorated |= _LoKiCore.getAndDecoratePredicates(
name, ## module name
LoKi.Functor(_pp, bool), ## the base
LoKi.Dicts.CutCalls(LHCb.ProtoParticle), ## call-traits
LoKi.Dicts.CutsOps(_pp, _pp)) ## operators&operations
## functional part:
# vector<T> -> vector<double>
_decorated |= _LoKiCore.getAndDecorateMaps(
name, ## module name
LoKi.Functor(_ppv, _vd), ## the base
LoKi.Dicts.MapsOps(_pp)) ## call-traits
# vector<T> -> vector<T>
_decorated |= _LoKiCore.getAndDecoratePipes(
name, ## module name
LoKi.Functor(_ppv, _ppv), ## the base
LoKi.Dicts.PipeOps(_pp, _pp)) ## call-traits
# vector<T> -> double
_decorated |= _LoKiCore.getAndDecorateFunVals(
name, ## module name
LoKi.Functor(_ppv, 'double'), ## the base
LoKi.Dicts.FunValOps(_pp)) ## call-traits
# vector<T> -> bool
_decorated |= _LoKiCore.getAndDecorateCutVals(
name, ## module name
LoKi.Functor(_ppv, bool), ## the base
LoKi.Dicts.CutValOps(_pp)) ## call-traits
#sources : void -> vector<T>
_decorated |= _LoKiCore.getAndDecorateSources(
name, ## module name
LoKi.Functor('void', _ppv), ## the base
LoKi.Dicts.SourceOps(_pp, _pp)) ## call-traits
# 'infos'
_decorated |= _LoKiCore.getAndDecorateInfos(
name, ## module name
LoKi.Functor(_pp, 'double'), ## the base
LoKi.Dicts.InfoOps(_pp)) ## methods
# primitive voids :
_decorated |= _LoKiCore.getAndDecoratePrimitiveVoids(name)
return _decorated
def _decorate ( name = _name ) :
"""
Make the decoration of all objects from this module
"""
import LoKiCore.decorators as _LoKiCore
_mcp = 'const LHCb::MCParticle*'
_mcv = 'const LHCb::MCVertex*'
#_vp = std.vector( _mcp )
#_vv = std.vector( _mcv )
#_vd = std.vector( 'double' )
_vp = 'std::vector<const LHCb::MCParticle*>' ## std.vector( _mcp )
_vv = 'std::vector<const LHCb::MCVertex*>' ## std.vector( _mcv )
_vd = 'std::vector<double>' ## std.vector( 'double' )
#
# MCParticle -> double
_decorated = _LoKiCore.getAndDecorateFunctions (
name , ## modulr name
LoKi.Functor (_mcp,'double') , ## the base
LoKi.Dicts.FunCalls (LHCb.MCParticle) , ## call-traits
LoKi.Dicts.FuncOps (_mcp,_mcp) ) ## operators&operations
# MCVertex -> double
_decorated != _LoKiCore.getAndDecorateFunctions (
name , ## moduel name
LoKi.Functor (_mcv,'double') , ## the base
LoKi.Dicts.FunCalls (LHCb.MCVertex) , ## call-traits
LoKi.Dicts.FuncOps (_mcv,_mcv) ) ## operators&operations
# MCParticle -> bool
_decorated != _LoKiCore.getAndDecoratePredicates (
name , ## module name
LoKi.Functor (_mcp,bool) , ## the base
LoKi.Dicts.CutCalls (LHCb.MCParticle) , ## call-traits
LoKi.Dicts.CutsOps (_mcp,_mcp) ) ## operators&operations
# MCVertex -> bool
_decorated != _LoKiCore.getAndDecoratePredicates (
name , ## module name
LoKi.Functor (_mcv,bool) , ## the base
LoKi.Dicts.CutCalls (LHCb.MCVertex) , ## call-traits
LoKi.Dicts.CutsOps (_mcv,_mcv) ) ## operators&operations
## functional part:
# vector<T> -> vector<double>
_decorated |= _LoKiCore.getAndDecorateMaps (
name , ## moduel name
LoKi.Functor (_vp,_vd) , ## the base
LoKi.Dicts.MapsOps(_mcp) ) ## call-traits
_decorated |= _LoKiCore.getAndDecorateMaps (
name , ## moduel name
LoKi.Functor (_vv,_vd) , ## the base
LoKi.Dicts.MapsOps(_mcv) ) ## call-traits
# vector<T> -> vector<T>
_decorated |= _LoKiCore.getAndDecoratePipes (
name , ## module name
LoKi.Functor (_vp,_vp) , ## the base
LoKi.Dicts.PipeOps(_mcp,_mcp) ) ## call-traits
_decorated |= _LoKiCore.getAndDecoratePipes (
name , ## module name
LoKi.Functor (_vv,_vv) , ## the base
LoKi.Dicts.PipeOps(_mcv,_mcv) ) ## call-traits
# vector<T> -> double
_decorated |= _LoKiCore.getAndDecorateFunVals (
name , ## module name
LoKi.Functor (_vp,'double') , ## the base
LoKi.Dicts.FunValOps(_mcp) ) ## call-traits
_decorated |= _LoKiCore.getAndDecorateFunVals (
name , ## module name
LoKi.Functor (_vv,'double') , ## the base
LoKi.Dicts.FunValOps(_mcv) ) ## call-traits
# vector<T> -> bool
_decorated |= _LoKiCore.getAndDecorateCutVals (
name , ## module name
LoKi.Functor (_vp,bool) , ## the base
LoKi.Dicts.CutValOps(_mcp) ) ## call-traits
_decorated |= _LoKiCore.getAndDecorateCutVals (
name , ## module name
LoKi.Functor (_vv,bool) , ## the base
LoKi.Dicts.CutValOps(_mcv) ) ## call-traits
#sources : void -> vector<T>
_decorated |= _LoKiCore.getAndDecorateSources (
name , ## module name
LoKi.Functor ('void',_vp) , ## the base
LoKi.Dicts.SourceOps(_mcp,_mcp) ) ## call-traits
_decorated |= _LoKiCore.getAndDecorateSources (
name , ## module name
LoKi.Functor ('void',_vv) , ## the base
LoKi.Dicts.SourceOps(_mcv,_mcv) ) ## call-traits
## primitive voids:
_decorated |= _LoKiCore.getAndDecoratePrimitiveVoids ( name )
## decorate pids (Comparison with strings, integers and ParticleID objects:
for t in ( MCID , MCABSID ) :
t = type ( t )
_LoKiCore.decoratePID ( t , LoKi.Dicts.PIDOps ( t ) )
_decorated.add ( t )
return _decorated
def _decorate(name=_name):
"""
Make the decoration of all objects from this module
"""
import LoKiCore.decorators as _LoKiCore
tC = 'const Hlt::Candidate*'
tS = 'const Hlt::Stage*'
vC = 'std::vector<const Hlt::Candidate*>'
vD = 'std::vector<double>'
#
## "function" : Hlt::Candidate -> double
_decorated = _LoKiCore.getAndDecorateFunctions(
name, ## module name
LoKi.Functor(tC, 'double'), ## the base
LoKi.Dicts.FunCalls(Hlt.Candidate), ## call-traits
LoKi.Dicts.FuncOps(tC, tC)) ## operators&operations
## "predicate/cut" : Hlt::Candidate -> bool
_decorated |= _LoKiCore.getAndDecoratePredicates(
name, ## module name
LoKi.Functor(tC, bool), ## the base
LoKi.Dicts.CutCalls(Hlt.Candidate), ## call-traits
LoKi.Dicts.CutsOps(tC, tC)) ## operators&operations
## "function" : Hlt::Stage -> double
_decorated = _LoKiCore.getAndDecorateFunctions(
name, ## module name
LoKi.Functor(tS, 'double'), ## the base
LoKi.Dicts.FunCalls(Hlt.Stage), ## call-traits
LoKi.Dicts.FuncOps(tS, tS)) ## operators&operations
## "predicate/cut" : Hlt::Stage -> bool
_decorated |= _LoKiCore.getAndDecoratePredicates(
name, ## module name
LoKi.Functor(tS, bool), ## the base
LoKi.Dicts.CutCalls(Hlt.Stage), ## call-traits
LoKi.Dicts.CutsOps(tS, tS)) ## operators&operations
## functional part:
# "map" : vector<T> -> vector<double>
_decorated |= _LoKiCore.getAndDecorateMaps(
name, ## module name
LoKi.Functor(vC, vD), ## the base
LoKi.Dicts.MapsOps(tC)) ## call-traits
# "pipe" : vector<T> -> vector<T>
_decorated |= _LoKiCore.getAndDecoratePipes(
name, ## module name
LoKi.Functor(vC, vC), ## the base
LoKi.Dicts.PipeOps(tC, tC)) ## call-traits
# "funval" : vector<T> -> double
_decorated |= _LoKiCore.getAndDecorateFunVals(
name, ## module name
LoKi.Functor(vC, 'double'), ## the base
LoKi.Dicts.FunValOps(tC)) ## call-traits
# "cutval" : vector<T> -> bool
_decorated |= _LoKiCore.getAndDecorateCutVals(
name, ## module name
LoKi.Functor(vC, bool), ## the base
LoKi.Dicts.CutValOps(tC)) ## call-traits
# 'source' : void -> vector<T>
_decorated |= _LoKiCore.getAndDecorateSources(
name, ## module name
LoKi.Functor('void', vC), ## the base
LoKi.Dicts.SourceOps(tC, tC)) ## call-traits
## primitive voids
_decorated |= _LoKiCore.getAndDecoratePrimitiveVoids(name)
# =========================================================================
## LHCb::Track remnants ATTENTION !!!
# =========================================================================
tT = 'const LHCb::Track*'
vT = 'std::vector<const LHCb::Track*>'
# function
_decorated |= _LoKiCore.getAndDecorateFunctions(
name, ## module name
LoKi.Functor(tT, 'double'), ## the base
LoKi.Dicts.FunCalls(LHCb.Track), ## call-traits
LoKi.Dicts.FuncOps(tT, tT)) ## operators&operations
# "pipe" : vector<T> -> vector<T>
_decorated |= _LoKiCore.getAndDecoratePipes(
name, ## module name
LoKi.Functor(vT, vT), ## the base
LoKi.Dicts.PipeOps(tT, tT)) ## call-traits
# 'source' : void -> vector<T>
_decorated |= _LoKiCore.getAndDecorateSources(
name, ## module name
LoKi.Functor('void', vT), ## the base
LoKi.Dicts.SourceOps(tT, tT)) ## call-traits
# =========================================================================
## LHCb::VertexBase specifics
# =========================================================================
tV = 'const LHCb::VertexBase*'
vV = 'std::vector<const LHCb::VertexBase*>'
# function
_decorated |= _LoKiCore.getAndDecorateFunctions(
name, ## module name
LoKi.Functor(tV, 'double'), ## the base
LoKi.Dicts.FunCalls(LHCb.VertexBase), ## call-traits
LoKi.Dicts.FuncOps(tV, tV)) ## operators&operations
# predicates
_decorated |= _LoKiCore.getAndDecoratePredicates(
name, ## module name
LoKi.Functor(tV, bool), ## the base
LoKi.Dicts.CutCalls(LHCb.VertexBase), ## call-traits
LoKi.Dicts.CutsOps(tV, tV)) ## operators&operations
# "pipe" : vector<T> -> vector<T>
_decorated |= _LoKiCore.getAndDecoratePipes(
name, ## module name
LoKi.Functor(vV, vV), ## the base
LoKi.Dicts.PipeOps(tV, tV)) ## call-traits
# 'source' : void -> vector<T>
_decorated |= _LoKiCore.getAndDecorateSources(
name, ## module name
LoKi.Functor('void', vV), ## the base
LoKi.Dicts.SourceOps(tV, tV)) ## call-traits
# =========================================================================
## various "info" operations
# =========================================================================
## decorate HltCandidates:
_decorated |= _LoKiCore.getAndDecorateInfos(
name,
LoKi.Functor(tC, 'double'), ## the base
LoKi.Dicts.InfoOps(tC) ## info-opeartion
)
## decorate HltCandidates:
_decorated |= _LoKiCore.getAndDecorateInfos(
name,
LoKi.Functor(tC, bool), ## the base
LoKi.Dicts.InfoOps(tC) ## info-opeartion
)
## decorate HltStages:
_decorated |= _LoKiCore.getAndDecorateInfos(
name,
LoKi.Functor(tS, 'double'), ## the base
LoKi.Dicts.InfoOps(tS) ## info-opeartion
)
## decorate HltStages:
_decorated |= _LoKiCore.getAndDecorateInfos(
name,
LoKi.Functor(tS, bool), ## the base
LoKi.Dicts.InfoOps(tS) ## info-opeartion
)
##
return _decorated ## RETURN
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