def selMuonPParts(name, trackingSeq):
"""
Make ProtoParticles out of VeloMuon tracks
"""
veloprotos = ChargedProtoParticleMaker(name + "ProtoPMaker")
veloprotos.Inputs = ["Rec/VeloMuon/Tracks"]
veloprotos.Output = "Rec/ProtoP/" + name + "ProtoPMaker/ProtoParticles"
veloprotos.addTool(DelegatingTrackSelector, name="TrackSelector")
tracktypes = ["Long"]
veloprotos.TrackSelector.TrackTypes = tracktypes
selector = veloprotos.TrackSelector
for tsname in tracktypes:
selector.addTool(TrackSelector, name=tsname)
ts = getattr(selector, tsname)
# Set Cuts
ts.TrackTypes = [tsname]
veloprotoseq = GaudiSequencer(name + "ProtoPSeq")
veloprotoseq.Members += [veloprotos]
return GSWrapper(name="WrappedVeloMuonProtoPSeqFor" + name,
sequencer=veloprotoseq,
output='Rec/ProtoP/' + name +
'ProtoPMaker/ProtoParticles',
requiredSelections=[trackingSeq])
def MakeVeloTracks(self,prefilter):
if self.__confdict__["DoVeloDecoding"]:
from DAQSys.Decoders import DecoderDB
from DAQSys.DecoderClass import decodersForBank
decs=[]
vdec=DecoderDB["DecodeVeloRawBuffer/createBothVeloClusters"]
vdec.Active=True
DecoderDB["DecodeVeloRawBuffer/createVeloClusters"].Active=False
DecoderDB["DecodeVeloRawBuffer/createVeloLiteClusters"].Active=False
decs=decs+[vdec]
VeloDecoding = GaudiSequencer("RecoDecodingSeq")
VeloDecoding.Members += [d.setup() for d in decs ]
MyFastVeloTracking = FastVeloTracking("For%sFastVelo"%self.name,OutputTracksName=self.VeloTrackOutputLocation)
MyFastVeloTracking.OnlyForward = True
MyFastVeloTracking.ResetUsedFlags = True
### prepare for fitting
preve = TrackStateInitAlg("For%sInitSeedFit"%self.name,TrackLocation = self.VeloTrackOutputLocation)
preve.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
copyVelo = TrackContainerCopy( "For%sCopyVelo"%self.name )
copyVelo.inputLocations = [self.VeloTrackOutputLocation]
copyVelo.outputLocation = self.FittedVeloTrackOutputLocation
### fitting
if self.__confdict__["VeloFitter"] == "ForwardStraightLine":
MyVeloFit = ConfiguredForwardStraightLineEventFitter(Name="For%sVeloRefitterAlg"%self.name,
TracksInContainer=self.FittedVeloTrackOutputLocation)
elif self.__confdict__["VeloFitter"] == "SimplifiedGeometry":
MyVeloFit = ConfiguredEventFitter(Name="For%sVeloRefitterAlg"%self.name,
TracksInContainer=self.FittedVeloTrackOutputLocation,
SimplifiedGeometry = True)
else:
MyVeloFit = ConfiguredEventFitter(Name="For%sVeloRefitterAlg"%self.name,
TracksInContainer=self.FittedVeloTrackOutputLocation)
#### making the proto particles
MakeVeloProtos = ChargedProtoParticleMaker('For%sVeloProtoMaker'%self.name)
MakeVeloProtos.Inputs=[self.FittedVeloTrackOutputLocation]
MakeVeloProtos.Output = self.VeloProtoOutputLocation
MakeVeloProtos.addTool( DelegatingTrackSelector, name="TrackSelector" )
MakeVeloProtos.TrackSelector.TrackTypes = [ "Velo" ]
#### the full sequence
makeparts = GaudiSequencer('For%sMakeVeloTracksGS'%self.name)
if self.__confdict__["DoVeloDecoding"]:
makeparts.Members += [ VeloDecoding ]
makeparts.Members += [ MyFastVeloTracking ]
makeparts.Members += [ preve ]
makeparts.Members += [ copyVelo ]
makeparts.Members += [ MyVeloFit ]
makeparts.Members += [ MakeVeloProtos ]
#### some python magic to maek this appear like a "Selection"
return GSWrapper(name="For%sWrappedVeloTrackingFor"%self.name,
sequencer=makeparts,
output=self.VeloProtoOutputLocation,
requiredSelections = prefilter)
def selMuonPParts(name, DataType, downstreamSeq):
"""
Make ProtoParticles out of Downstream tracks
"""
unpacker = UnpackTrack(name+"UnpackTrack") # do we need this or is it here for historical reason ?
unpacker.InputName="pRec/Downstream/FittedTracks"
unpacker.OutputName="Rec/Downstream/FittedTracks"
idalg = MuonIDAlg(name+"IDalg")
cm=ConfiguredMuonIDs.ConfiguredMuonIDs( DataType ) #data=DaVinci().getProp("DataType"))
cm.configureMuonIDAlg(idalg)
idalg.TrackLocation = "Rec/Downstream/FittedTracks"
idalg.MuonIDLocation = "Rec/Muon/MuonPID/Downstream"
idalg.MuonTrackLocation = "Rec/Track/MuonForDownstream" # I would call it FromDownstream …but just to be »Klugscheißer«
downprotoseq = GaudiSequencer(name+"ProtoPSeq")
downprotos = ChargedProtoParticleMaker(name+"ProtoPMaker")
downprotos.Inputs = ["Rec/Downstream/FittedTracks"]
downprotos.Output = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles"
downprotos.addTool( DelegatingTrackSelector, name="TrackSelector" )
#tracktypes = [ "Long","Upstream","Downstream","Ttrack","Velo","VeloR" ] # only downstream needed …
tracktypes = ["Downstream"]
#if (trackcont == "Best") :
# tracktypes = [ "Long" ]
downprotos.TrackSelector.TrackTypes = tracktypes
selector = downprotos.TrackSelector
for tsname in tracktypes:
selector.addTool(TrackSelector,name=tsname)
ts = getattr(selector,tsname)
# Set Cuts
ts.TrackTypes = [tsname]
# ts.MinNDoF = 1
ts.MaxChi2Cut = 10
addmuonpid = ChargedProtoParticleAddMuonInfo(name+"addmuoninfo")
addmuonpid.InputMuonPIDLocation = "Rec/Muon/MuonPID/Downstream"
addmuonpid.ProtoParticleLocation = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles"
#addmuonpid.OutputLevel = 0
combinedll = ChargedProtoCombineDLLsAlg(name+"CombineDLL")
combinedll.ProtoParticleLocation = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles"
#combinedll.OutputLevel = 0
# DST post treatment
#TrackToDST(name+"TrackToDST").TracksInContainer = "Rec/Downstream/Tracks"
#downprotoseq.Members += [ TrackToDST(name+"TrackToDST"), downprotos, addmuonpid, combinedll ]
downprotoseq.Members += [ downprotos, addmuonpid, combinedll ]
#
DataOnDemandSvc().AlgMap.update( {
"/Event/Rec/Downstream/Tracks" : unpacker.getFullName(),
"/Event/Rec/Muon/MuonPID/Downstream" : idalg.getFullName(),
# "/Event/Rec/ProtoP/"+name+"ProtoPMaker" : downprotoseq.getFullName()
} )
return GSWrapper(name="WrappedDownMuonProtoPSeqFor"+name,
sequencer=downprotoseq,
output='Rec/ProtoP/' + name +'ProtoPMaker/ProtoParticles',
requiredSelections = [ downstreamSeq])
def configIso():
from Configurables import ChargedProtoParticleMaker, DaVinci
veloprotos = ChargedProtoParticleMaker("ProtoPMaker")
veloprotos.Inputs = ["Rec/Track/Best"]
veloprotos.Output = "Rec/ProtoP/myProtoPMaker/ProtoParticles"
DaVinci().appendToMainSequence( [ veloprotos ])
from Configurables import ProtoParticleCALOFilter, CombinedParticleMaker,NoPIDsParticleMaker
from CommonParticles.Utils import trackSelector, updateDoD
algorithm = NoPIDsParticleMaker('StdNoPIDsVeloPions', Particle =
'pion', )
algorithm.Input = "Rec/ProtoP/myProtoPMaker/ProtoParticles"
selector = trackSelector ( algorithm , trackTypes = ['Velo'] )
locations = updateDoD ( algorithm )
DaVinci().appendToMainSequence( [ algorithm ])
def MakeVeloProtos(self,prefilter):
#### making the proto particles
MakeVeloProtos = ChargedProtoParticleMaker('For%sVeloProtoMaker'%self.name())
MakeVeloProtos.Inputs = [self.VeloTrackInputLocaton]
MakeVeloProtos.Output = self.VeloProtoOutputLocation
MakeVeloProtos.addTool( DelegatingTrackSelector, name="TrackSelector" )
MakeVeloProtos.TrackSelector.TrackTypes = [ "Velo" ]
#### the full sequence
makeparts = GaudiSequencer('For%sMakeVeloProtosGS'%self.name())
makeparts.Members += [ MakeVeloProtos ]
#### some python magic to maek this appear like a "Selection"
return GSWrapper(name="For%sWrappedVeloTrackingFor"%self.name(),
sequencer=makeparts,
output=self.VeloProtoOutputLocation,
requiredSelections = prefilter)
def selMuonPParts(name, trackingSeq):
"""
Make ProtoParticles out of VeloMuon tracks
"""
unpacker = UnpackTrack(name+"UnpackTrack")
unpacker.InputName="pRec/VeloMuon/Tracks"
unpacker.OutputName="Rec/VeloMuon/Tracks"
veloprotos = ChargedProtoParticleMaker(name+"ProtoPMaker")
veloprotos.Inputs = ["Rec/VeloMuon/Tracks"]
veloprotos.Output = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles"
veloprotos.addTool( DelegatingTrackSelector, name="TrackSelector" )
tracktypes = [ "Long" ]
#veloprotos.OutputLevel =0
#if (trackcont == "Best") :
# tracktypes = [ "Long" ]
veloprotos.TrackSelector.TrackTypes = tracktypes
selector = veloprotos.TrackSelector
for tsname in tracktypes:
selector.addTool(TrackSelector,name=tsname)
ts = getattr(selector,tsname)
# Set Cuts
ts.TrackTypes = [tsname]
#
DataOnDemandSvc().AlgMap.update( {
"/Event/Rec/VeloMuon/Tracks" : unpacker.getFullName(),
} )
veloprotoseq = GaudiSequencer(name+"ProtoPSeq")
veloprotoseq.Members += [ veloprotos ]
return GSWrapper(name="WrappedVeloMuonProtoPSeqFor" + name,
sequencer=veloprotoseq,
output='Rec/ProtoP/' + name +'ProtoPMaker/ProtoParticles',
requiredSelections = [ trackingSeq])
hlt1_emu.Variables = []
hlt1_emu.nltValue = 16.
DaVinci().appendToMainSequence([relinfo_HLT1])
##############################################################################################
##### PRODUCTION OF THE VELO PARTICLE INPUT CONTAINER FOR THE CHARGED ISOLATION TUPLE TOOL
#############################################################################################
#To produce the Velo particles input container (the gain in performance from adding velo tracks is actually pretty negligible...)
from Configurables import ChargedProtoParticleMaker
name = "Lambdab2Lcmunu"
veloprotos = ChargedProtoParticleMaker(name + "ProtoPMaker")
veloprotos.Inputs = ["Rec/Track/Best"]
veloprotos.Output = "Rec/ProtoP/myProtoPMaker/ProtoParticles"
DaVinci().appendToMainSequence([veloprotos])
from Gaudi.Configuration import *
from Configurables import ProtoParticleCALOFilter, CombinedParticleMaker, NoPIDsParticleMaker
from CommonParticles.Utils import *
algorithm = NoPIDsParticleMaker(
'StdNoPIDsVeloPions',
Particle='pion',
)
algorithm.Input = "Rec/ProtoP/myProtoPMaker/ProtoParticles"
selector = trackSelector(algorithm, trackTypes=['Velo'])
# Debug options
DaVinci().EvtMax = -1
###################################
# Customize DaVinci main sequence #
###################################
from Configurables import ChargedProtoParticleMaker
from Configurables import NoPIDsParticleMaker
from CommonParticles.Utils import trackSelector, updateDoD
# Provide required information for VELO pions.
ms_all_protos = ChargedProtoParticleMaker(name='MyProtoPMaker')
ms_all_protos.Inputs = ['Rec/Track/Best']
ms_all_protos.Output = 'Rec/ProtoP/MyProtoPMaker/ProtoParticles'
# NOTE: The name 'StdNoPIDsVeloPions' is hard-coded in the tuple tool, so the
# name should not be changed.
ms_velo_pions = NoPIDsParticleMaker('StdNoPIDsVeloPions', Particle='pion')
ms_velo_pions.Input = ms_all_protos.Output
trackSelector(ms_velo_pions, trackTypes=['Velo'])
updateDoD(ms_velo_pions)
DaVinci().appendToMainSequence([ms_all_protos, ms_velo_pions])
#######################
# Particle references #
def __hlt2ProbeMuonProtos(self):
"""
Charged muon protoparticles
Requires chargedProtos and muon ID
"""
from Configurables import (ChargedProtoParticleAddMuonInfo,
ChargedProtoCombineDLLsAlg, MuonIDAlg,
ChargedProtoParticleMaker,
DelegatingTrackSelector)
from MuonID import ConfiguredMuonIDs
ProbeMuonProtosOutputLocation = _baseProtoPLocation(
"Hlt2",
HltDefaultFitSuffix + "/" + TrackEffNames[self.trackType()])
Hlt2ProbeMuonProtoMaker = ChargedProtoParticleMaker(
self.__pidAlgosAndToolsPrefix() + 'ProbeProtoPAlg')
if (self.trackType() == "MuonTT"):
# create the protos
bm_members = [self.__hlt2MuonTTTracking()]
Hlt2ProbeMuonProtoMaker.Inputs = [
self.__hlt2MuonTTTracking().outputSelection()
]
Hlt2ProbeMuonProtoMaker.addTool(DelegatingTrackSelector)
Hlt2ProbeMuonProtoMaker.Output = ProbeMuonProtosOutputLocation
Hlt2ProbeMuonProtoMaker.DelegatingTrackSelector.TrackTypes = [
"Long"
]
bm_members += [Hlt2ProbeMuonProtoMaker]
elif (self.trackType() == "VeloMuon"):
#build protos out of tracks
bm_members = [self.__hlt2VeloMuonTracking()]
Hlt2ProbeMuonProtoMaker.Inputs = [
self.__hlt2VeloMuonTracking().outputSelection()
]
Hlt2ProbeMuonProtoMaker.Output = ProbeMuonProtosOutputLocation
Hlt2ProbeMuonProtoMaker.addTool(DelegatingTrackSelector,
name='delTrackSel')
Hlt2ProbeMuonProtoMaker.delTrackSel.TrackTypes = ['Long']
bm_members += [Hlt2ProbeMuonProtoMaker]
elif (self.trackType() == "FullDownstream"):
# add muon ID
bm_members = [self.__hlt2FullDownstreamTracking()]
idalgname = self.__pidAlgosAndToolsPrefix() + "IDalg"
cm = ConfiguredMuonIDs.ConfiguredMuonIDs(
data=self.getProp("DataType"))
idalg = cm.configureMuonIDAlgLite(idalgname)
idalg.TracksLocations = [
self.__hlt2FullDownstreamTracking().outputSelection()
]
idalg.MuonIDLocation = Hlt2TrackRoot + HltDefaultFitSuffix + "/" + HltSharedPIDPrefix + "/" + HltMuonIDSuffix
idalg.MuonTrackLocation = Hlt2TrackRoot + HltDefaultFitSuffix + "/" + HltSharedPIDPrefix + "/" + HltMuonTracksName
# Configure moun ID tools explicitly, would be better if the ConfiguredMuonIDs class
# provided a comprehensive method. All tools are public, but should configure
# everywhere, where they are used to be safe.
import Configurables
for tool, fun in (("CommonMuonTool",
"IsMuonTool"), ("DLLMuonTool", "DLLMuonTool"),
("MakeMuonTool", "MakeMuonTool")):
tool = getattr(Configurables, tool)()
getattr(cm, "configure" + fun)(tool)
# make protos
Hlt2ProbeMuonProtoMaker.Inputs = [
self.__hlt2FullDownstreamTracking().outputSelection()
]
Hlt2ProbeMuonProtoMaker.Output = ProbeMuonProtosOutputLocation
Hlt2ProbeMuonProtoMaker.addTool(DelegatingTrackSelector,
name="TrackSelector")
tracktypes = ["Downstream"]
Hlt2ProbeMuonProtoMaker.TrackSelector.TrackTypes = tracktypes
addmuonpid = ChargedProtoParticleAddMuonInfo("addmuonpid")
addmuonpid.InputMuonPIDLocation = idalg.MuonIDLocation
addmuonpid.ProtoParticleLocation = Hlt2ProbeMuonProtoMaker.Output
combinedll = ChargedProtoCombineDLLsAlg("combineDLL")
combinedll.ProtoParticleLocation = Hlt2ProbeMuonProtoMaker.Output
bm_members += [
idalg, Hlt2ProbeMuonProtoMaker, addmuonpid, combinedll
]
from HltLine.HltLine import bindMembers
# Build the bindMembers
bm_name = self.__pidAlgosAndToolsPrefix() + "ProbeMuonProtosSeq"
bm_output = ProbeMuonProtosOutputLocation
return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
def setupPF(self):
## set the algorithm
alg = ParticleFlow(self.name)
if "Velo" in self.paramDef['TrackSelector'].keys(
) and not self.paramDef['UseVelo']:
self.paramDef['UseVelo'] = True
# set all params
for prop, value in self.paramDef.items():
if prop != 'TrackSelector' and prop != 'TrackVelo' and prop != "scalingANDsmearing":
setattr(alg, prop, value)
else:
self.__dict__[prop] = value
if (self.name != "PF"):
alg.PFOutputLocation = "Phys/" + self.name + "/Particles"
## List of algorithms to put in the sequencer
if self.scalingANDsmearing:
from Configurables import TrackScaleState as SCALER
scaler = SCALER('PFStateScale')
self.PFSeq.Members += [scaler]
if self.MCCor:
from Configurables import TrackSmearState as SMEAR
smear = SMEAR('PFStateSmear')
self.PFSeq.Members += [smear]
## Definition of cuts to apply to input tracks for inputselection
TrackCuts = {}
if self.paramDef['UseVelo'] and not "Velo" in self.TrackSelector.keys(
):
self.TrackSelector["Velo"] = self.TrackVelo
for trtype in self.TrackSelector.keys():
if trtype == "Long":
TrackCuts[trtype] = {
"Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']],
"MinPtCut": self.TrackSelector[trtype]['PtMin'],
"MaxGhostProbCut":
self.TrackSelector[trtype]['MaxGhostProb']
}
if trtype == "Downstream":
TrackCuts[trtype] = {
"Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']],
"MinPtCut": self.TrackSelector[trtype]['PtMin'],
"MaxGhostProbCut":
self.TrackSelector[trtype]['MaxGhostProb']
}
if trtype == "Upstream":
TrackCuts[trtype] = {
"Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']],
"MinPtCut": self.TrackSelector[trtype]['PtMin']
}
if trtype == "Velo":
TrackCuts[trtype] = {
"Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']]
}
protos = ChargedProtoParticleMaker("VeloProtoPMaker")
protos.Inputs = ["Rec/Track/Best"]
protos.Output = "Rec/ProtoP/VeloProtoPMaker"
protos.addTool(DelegatingTrackSelector, name="TrackSelector")
protos.TrackSelector.TrackTypes = ["Velo"]
self.setupTypeTrackSelector("Velo", protos.TrackSelector,
TrackCuts["Velo"])
self.PFSeq.Members += [protos]
pLocations = []
pCompLocations = []
alg.MC_recovery = self.MCCor
#re set default to false
alg.UseHCAL = False
alg.NeutralRecovery = False
for t in self.InputParticles:
if t == 'Photons':
pLocations.append('Phys/StdLooseAllPhotons/Particles')
elif t == 'NeutralHadrons':
## Set the HCAL uses
alg.UseHCAL = True
self.setupHCAL()
elif t == 'Charged':
## Track selector
alg.TrackSelectorType = "DelegatingTrackSelector"
alg.addTool(DelegatingTrackSelector, name="TrackSelector")
tracktypes = TrackCuts.keys()
alg.TrackSelector.TrackTypes = self.TrackSelector.keys()
for type in tracktypes:
self.setupTypeTrackSelector(type, alg.TrackSelector,
TrackCuts)
elif t == 'Pi0s':
pLocations.append('Phys/StdLooseResolvedPi0/Particles')
pLocations.append('Phys/StdLooseMergedPi0/Particles')
elif t == 'V0s':
pCompLocations.append("Phys/StdKs2PiPiLL/Particles")
pCompLocations.append("Phys/StdKs2PiPiDD/Particles")
pCompLocations.append("Phys/StdLambda2PPiLL/Particles")
pCompLocations.append("Phys/StdLambda2PPiDD/Particles")
elif t == 'PFNeutrals':
alg.NeutralRecovery = True
else:
print t, "are not supported!"
exit(1)
if len(self.paramDef['CompositeParticleLocations']) > 0.5:
for t in self.paramDef['CompositeParticleLocations']:
pCompLocations.append(t)
alg.ParticleLocations = pLocations
alg.CompositeParticleLocations = pCompLocations
self.PFSeq.Members += [alg]
self.algorithms.append(self.PFSeq)
def setupPF(self):
## List of algorithms to put in the sequencer
## set the algorithm
alg = ParticleFlow4Jets(self.name)
## Definition of cuts to apply to input tracks for inputselection
TrackCuts = {}
print '###################################### ', self.TrackType
if self.UseVelo and not "Velo" in self.TrackType:
self.TrackType.append("Velo")
for trtype in self.TrackType:
if trtype == "Long":
TrackCuts["Long"] = {
"Chi2Cut": [0, self.Chi2MaxLong],
"MinPtCut": self.PtMinLong,
"CloneDistCut": [5000, 9e+99],
"AcceptClones": self.AcceptClone
}
if trtype == "Downstream":
TrackCuts["Downstream"] = {
"Chi2Cut": [0, self.Chi2MaxDown],
"MinPtCut": self.PtMinDown
}
if trtype == "Upstream":
TrackCuts["Upstream"] = {
"Chi2Cut": [0, self.Chi2MaxUp],
"MinPtCut": self.PtMinUp
}
if trtype == "Velo":
TrackCuts["Velo"] = {"Chi2Cut": [0, self.Chi2MaxVelo]}
protos = ChargedProtoParticleMaker("VeloProtoPMaker")
protos.Inputs = ["Rec/Track/Best"]
protos.Output = "Rec/ProtoP/VeloProtoPMaker"
protos.addTool(DelegatingTrackSelector, name="TrackSelector")
protos.TrackSelector.TrackTypes = ["Velo"]
self.setupTypeTrackSelector("Velo", protos.TrackSelector,
TrackCuts["Velo"])
self.algorithms.append(protos)
## Neutral related cuts
pLocations = []
alg.UseTTrackBanning = True
alg.CandidateToBanLocation = self.CandidateToBanLocation
alg.VerticesLocation = self.VerticesLocation
alg.PFOutputLocation = self.PFOutputLocation
alg.PFBannedOutputLocation = self.PFBannedOutputLocation
alg.PFHiddenNeutralOutputLocation = self.PFHiddenNeutralOutputLocation
alg.PFProtoParticlesOutputLocation = self.PFProtoParticlesOutputLocation
alg.PFCaloHypoOutputLocation = self.PFCaloHypoOutputLocation
for t in self.InputParticles:
if t == 'Photons':
pLocations.append('Phys/StdLooseAllPhotons/Particles')
alg.MinPhotonID4Photon = self.MinPhotonID4Photon
alg.MinPhotonID4PhotonTtrack = self.MinPhotonID4PhotonTtrack
if t == 'NeutralHadrons':
## Set the HCAL uses
alg.UseHCAL = self.UseHCAL
self.setupHCAL()
alg.MinHCALE = self.MinHCALE
## Match track and clusters
alg.MaxMatchHCALLowEValue = self.MaxMatchHCALLowEValue
alg.MaxMatchHCALHighEValue = self.MaxMatchHCALHighEValue
alg.MaxMatchHCALTrSmallE = self.MaxMatchHCALTrSmallE
alg.MaxMatchHCALTrMediumE = self.MaxMatchHCALTrMediumE
alg.MaxMatchHCALTrLargeE = self.MaxMatchHCALTrLargeE
alg.MaxMatchHCALTr_T = self.MaxMatchHCALTr_T
if t == 'Charged':
## Track selector
alg.TrackSelectorType = "DelegatingTrackSelector"
alg.addTool(DelegatingTrackSelector, name="TrackSelector")
tracktypes = TrackCuts.keys()
alg.TrackSelector.TrackTypes = self.TrackType
for type in tracktypes:
self.setupTypeTrackSelector(type, alg.TrackSelector,
TrackCuts)
## Track related cuts
alg.MinInfMomentumCut = self.MinInfMomentumCut
alg.MaxChi2NoTT = self.MaxChi2NoTT
alg.UseTTHits = self.UseTTHits
alg.MaxMatchECALTr = self.MaxMatchECALTr
alg.MaxMatchECALTr_T = self.MaxMatchECALTr_T
alg.UsePIDInfo = self.UsePIDInfo
if t == 'Pi0s':
pLocations.append('Phys/StdLooseResolvedPi0/Particles')
pLocations.append('Phys/StdLooseMergedPi0/Particles')
alg.MinPhotonIDMax4ResolvedPi0 = self.MinPhotonIDMax4ResolvedPi0
alg.MinPhotonIDMin4ResolvedPi0 = self.MinPhotonIDMin4ResolvedPi0
if t == 'V0s':
pLocations.append('Phys/StdLooseKsDD/Particles')
pLocations.append('Phys/StdLooseKsLL/Particles')
pLocations.append('Phys/StdLooseLambdaDD/Particles')
pLocations.append('Phys/StdLooseLambdaLL/Particles')
if t == 'PFNeutrals':
alg.NeutralRecovery = True
alg.UsePIDInfo = True
alg.CalibECAL_EovP = self.CalibECAL_EovP
alg.CalibHCAL_EovP = self.CalibHCAL_EovP
alg.NSigmaForCaloRecovery = self.NSigmaForCaloRecovery
alg.ParticleLocations = pLocations
#alg.OutputLevel = 0
self.algorithms.append(alg)
Hlt2FullDownParts.Output = "Hlt2/Hlt2DownstreamMuons/Particles"
##########################################################################
#
# Velo particles
#
##########################################################################
from HltTracking.HltTrackNames import HltSharedTrackLoc, HltDefaultFitSuffix, _baseProtoPLocation, TrackName, Hlt2TrackEffRoot
from HltLine.HltLine import bindMembers
from Configurables import CombinedParticleMaker, ChargedProtoParticleMaker, BestPIDParticleMaker, NoPIDsParticleMaker
from Configurables import DelegatingTrackSelector
from HltTracking.HltSharedTracking import RevivedVelo, FittedVelo
Hlt2VeloProtos = ChargedProtoParticleMaker('Hlt2VeloProtosForTrackEff')
Hlt2VeloProtos.Inputs = [FittedVelo.outputSelection()]
Hlt2VeloProtos.Output = _baseProtoPLocation(
"Hlt2", Hlt2TrackEffRoot + "/" + TrackName["Velo"])
Hlt2VeloProtos.addTool(DelegatingTrackSelector, name='delTrackSelVelo')
Hlt2VeloProtos.delTrackSelVelo.TrackTypes = ['Velo']
Hlt2VeloPionParts = NoPIDsParticleMaker("Hlt2VeloPionParts")
Hlt2VeloPionParts.Particle = 'pion'
Hlt2VeloPionParts.Input = Hlt2VeloProtos.Output
Hlt2VeloPionParts.Output = Hlt2TrackEffRoot + "/Hlt2VeloPions/Particles"
Hlt2VeloKaonParts = NoPIDsParticleMaker("Hlt2VeloKaonParts")
Hlt2VeloKaonParts.Particle = 'kaon'
Hlt2VeloKaonParts.Input = Hlt2VeloProtos.Output
Hlt2VeloKaonParts.Output = Hlt2TrackEffRoot + "/Hlt2VeloKaons/Particles"
