def __configure(self):
recoSeq = GaudiSequencer("Hlt2JetRecoSequence", ModeOR = True, ShortCircuit = False)
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedForwardTracking
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedDownstreamTracking
# Long charged proto particles
longTracking = Hlt2BiKalmanFittedForwardTracking()
longChargedProtos = longTracking.hlt2ChargedNoPIDsProtos()
longSeq = GaudiSequencer("Hlt2JetLongRecoSequence", Members = longChargedProtos.members())
# Downstream charged proto particles
downTracking = Hlt2BiKalmanFittedDownstreamTracking()
downChargedProtos = downTracking.hlt2ChargedNoPIDsProtos()
downSeq = GaudiSequencer("Hlt2JetDownRecoSequence", Members = downChargedProtos.members())
from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedPhotons as Photons
from Hlt2SharedParticles.Pi0 import ResolvedPi0s
from Hlt2SharedParticles.Pi0 import MergedPi0s
from Hlt2SharedParticles.Ks import KsLLTF as KsLL
from Hlt2SharedParticles.Ks import KsLLTF as KsDD
from Hlt2SharedParticles.Lambda import LambdaLLTrackFitted as LambdaLL
from Hlt2SharedParticles.Lambda import LambdaDDTrackFitted as LambdaDD
self.__caloProcessor = longTracking.caloProcessor()
ecalSeq = self.__caloProcessor.clusters()
inputs = [
['Particle', 'particle', self.__sharedParticleInput(Photons, "Photons")],
['Particle', 'particle', self.__sharedParticleInput(ResolvedPi0s, "ResolvedPi0s")],
['Particle', 'particle', self.__sharedParticleInput(MergedPi0s, "MergedPi0s")],
['Particle', 'particle', self.__sharedParticleInput(KsLL, "KsLL")],
['Particle', 'particle', self.__sharedParticleInput(KsDD, "KsDD")],
['Particle', 'particle', self.__sharedParticleInput(LambdaLL, "LambdaLL")],
['Particle', 'particle', self.__sharedParticleInput(LambdaDD, "LambdaDD")],
['ProtoParticle', 'best', (longSeq, longChargedProtos.outputSelection())],
['ProtoParticle', 'best', (downSeq, downChargedProtos.outputSelection())],
['CaloCluster', 'gamma', (None, self.__findCaloLocation(Photons.members(), CellularAutomatonAlg, "OutputData"))],
['CaloCluster', 'gamma', self.__hcalClusters()],
['IClusTrTable2D', 'ecal', (None, self.__findCaloLocation(Photons.members(), PhotonMatchAlg, "Output"))],
['IClusTrTable2D', 'hcal', self.__hcal2Track(longTracking, Photons)]
]
pfInputs = []
for inputClass, inputType, (seq, loc) in inputs:
if seq and seq not in recoSeq.Members:
recoSeq.Members += [seq]
pfInputs.append([inputClass, inputType, loc])
from Configurables import HltParticleFlow
particleFlow = HltParticleFlow("HltParticleFlow", **self.getProp('ParticleFlowOptions'))
particleFlow.Inputs = pfInputs
particleFlow.Output = "Hlt2/ParticleFlow/Particles"
from HltLine.HltLine import bindMembers
self.__particleFlow = bindMembers("Hlt2Jet", [recoSeq, particleFlow])
def myActionHlt2():
from Gaudi.Configuration import GaudiSequencer
from Configurables import (PrTrackAssociator, TrackResChecker,
TrackOccupChecker, PrChecker2, TrackSelector,
MCReconstructible, MCParticleSelector,
PrLHCbID2MCParticle, UnpackMCParticle,
UnpackMCVertex, DebugTrackingLosses)
from HltTracking.HltTrackNames import HltSharedTrackLoc, HltSharedTrackRoot, Hlt2TrackRoot, Hlt2TrackLoc, HltDefaultFitSuffix
PatCheck = GaudiSequencer("CheckPatSeq")
PrChecker2("PrCheckerHlt2").TriggerNumbers = True
PrChecker2("PrCheckerHlt2").Eta25Cut = True
PrChecker2("PrCheckerHlt2").WriteForwardHistos = 1
PrChecker2("PrCheckerHlt2Forward").TriggerNumbers = True
PrChecker2("PrCheckerHlt2Forward").Eta25Cut = True
PrChecker2("PrCheckerHlt2Forward").WriteForwardHistos = 1
PrChecker2("PrCheckerHlt2Forward"
).ForwardTracks = Hlt2TrackLoc["ComplementForward"]
#(N.B.: container base for velo tracks was renamed to Hlt1)
# Figure out which HLT is run from HltConf
PrChecker2("PrCheckerHlt2").SeedTracks = Hlt2TrackLoc["Seeding"]
PrChecker2("PrCheckerHlt2").MatchTracks = Hlt2TrackLoc["Match"]
PrChecker2("PrCheckerHlt2").DownTracks = Hlt2TrackLoc["Downstream"]
PrChecker2("PrCheckerHlt2").ForwardTracks = Hlt2TrackLoc["Forward"]
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedForwardTracking
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedDownstreamTracking
tracks = Hlt2BiKalmanFittedForwardTracking().hlt2PrepareTracks()
tracksDown = Hlt2BiKalmanFittedDownstreamTracking().hlt2PrepareTracks()
PrChecker2("PrCheckerHlt2").BestTracks = tracks.outputSelection()
PrChecker2("PrCheckerHlt2Down").BestTracks = tracksDown.outputSelection()
#PrChecker2("PrCheckerHlt2").DownTracks = tracksDown.outputSelection()
PrTrackAssociator("AssocAllHlt2").RootOfContainers = Hlt2TrackRoot
PrTrackAssociator("AssocFittedHlt2"
).RootOfContainers = Hlt2TrackRoot + HltDefaultFitSuffix
print tracks.outputSelection()
print Hlt2TrackRoot + HltDefaultFitSuffix
print tracks.outputSelection()
print Hlt2TrackRoot + HltDefaultFitSuffix
print tracks.outputSelection()
print Hlt2TrackRoot + HltDefaultFitSuffix
PatCheck.Members += [
PrTrackAssociator("AssocAllHlt2"),
PrTrackAssociator("AssocFittedHlt2")
]
PatCheck.Members += [PrChecker2("PrCheckerHlt2Forward")]
PatCheck.Members += [PrChecker2("PrCheckerHlt2")]
PatCheck.Members += [PrChecker2("PrCheckerHlt2Down")]
def configureReconstruction(self):
definedTrackings = [
Hlt2BiKalmanFittedDownstreamTracking(),
Hlt2BiKalmanFittedForwardTracking(),
Hlt2MuonTTTracking(),
Hlt2VeloMuonTracking(),
Hlt2FullDownstreamTracking()
]
# And now we have to, for each of the configurables we just created,
# tell it the data type and tell it to use all the Hlt2 lines...
from HltLine.HltLinesConfigurableUser import HltLinesConfigurableUser
from Gaudi.Configuration import ConfigurableUser
from HltTracking.Hlt2TrackingConfigurations import setDataTypeForTracking
for thistracking in definedTrackings:
setDataTypeForTracking(thistracking, self.getProp("DataType"))
if self.getProp('Hlt2ForwardMaxVelo') and hasattr(
thistracking, 'Hlt2ForwardMaxVelo'):
thistracking.Hlt2ForwardMaxVelo = self.getProp(
"Hlt2ForwardMaxVelo")
def __apply_configuration__(self):
"""Apply the HLT persist reco configuration."""
from Configurables import GaudiSequencer
from Configurables import LoKi__HDRFilter
from Configurables import TrackToDST
persistRecoSeq = self.getProp("Sequence")
if not self.getProp("Sequence"):
return
persistRecoSeq.IgnoreFilterPassed = False
persistRecoSeq.Members = []
# This sequence expects the proper line filter to be applied already
# Cut down states in tracks first
tracks = Hlt2BiKalmanFittedForwardTracking().hlt2PrepareTracks()
tracksDown = Hlt2BiKalmanFittedDownstreamTracking().hlt2PrepareTracks()
longStateCutter = TrackToDST("TrackToDSTLong")
longStateCutter.TracksInContainer = tracks.outputSelection()
downStateCutter = TrackToDST("TrackToDSTDown")
downStateCutter.TracksInContainer = tracksDown.outputSelection()
persistRecoSeq.Members += [longStateCutter]
persistRecoSeq.Members += [downStateCutter]
# Setup packers and add them to the sequence
packerAlgs = self._packers()
persistRecoSeq.Members += packerAlgs
# Configure HltPackedDataWriter algorithm to add to the raw banks
pdwriter = HltPackedDataWriter("Hlt2PackedDataWriter")
pdwriter.Containers = [
out for inp, out in self.packedObjectLocations()
]
persistRecoSeq.Members += [pdwriter]
# Register the mapping of output locations and integers
self._registerToHltANNSvc()
from Gaudi.Configuration import * from HltLine.HltLine import bindMembers from Configurables import NoPIDsParticleMaker, CombinedParticleMaker, TrackSelector from Configurables import PhotonMaker, PhotonMakerAlg from Configurables import ProtoParticleCALOFilter, ProtoParticleMUONFilter from GaudiKernel.SystemOfUnits import MeV # # Forward fitted # from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedForwardTracking Hlt2BiKalmanFittedForwardTracking = Hlt2BiKalmanFittedForwardTracking() # # Now the downstream tracking # from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedDownstreamTracking Hlt2BiKalmanFittedDownstreamTracking = Hlt2BiKalmanFittedDownstreamTracking() ########################################################################## # # Now all PID # ########################################################################## # # Charged hadron protoparticles, no Rich # #BiKalmanFittedChargedProtoMaker = Hlt2BiKalmanFittedForwardTracking.hlt2ChargedNoPIDsProtos() BiKalmanFittedChargedProtoMaker = Hlt2BiKalmanFittedForwardTracking.hlt2ChargedAllPIDsProtos( ) # # Downstream hadron protoparticles, no Rich #
def __apply_configuration__(self):
"""
HLT Afterburner configuration
"""
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedForwardTracking
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedDownstreamTracking
Afterburner = self.getProp("Sequence") if self.isPropertySet(
"Sequence") else None
if not Afterburner:
return
AfterburnerFilterSeq = Sequence("HltAfterburnerFilterSequence")
Afterburner.Members += [AfterburnerFilterSeq]
if self.getProp("Hlt2Filter"):
from DAQSys.Decoders import DecoderDB
decoder = DecoderDB["HltDecReportsDecoder/Hlt2DecReportsDecoder"]
from Configurables import LoKi__HDRFilter as HDRFilter
hlt2Filter = HDRFilter('HltAfterburnerHlt2Filter',
Code=self.getProp("Hlt2Filter"),
Location=decoder.listOutputs()[0])
AfterburnerFilterSeq.Members += [hlt2Filter]
AfterburnerSeq = Sequence("HltAfterburnerSequence",
IgnoreFilterPassed=True)
AfterburnerFilterSeq.Members += [AfterburnerSeq]
if self.getProp("EnableHltRecSummary"):
from Configurables import RecSummaryAlg
seq = Sequence("RecSummarySequence")
tracks = Hlt2BiKalmanFittedForwardTracking().hlt2PrepareTracks()
tracksDown = Hlt2BiKalmanFittedDownstreamTracking(
).hlt2PrepareTracks()
muonID = Hlt2BiKalmanFittedForwardTracking().hlt2MuonID()
from HltLine.HltDecodeRaw import DecodeVELO, DecodeIT, DecodeTT, DecodeSPD, DecodeMUON
decoders = {
"Velo": (DecodeVELO, "VeloLiteClustersLocation"),
"TT": (DecodeTT, "clusterLocation"),
"IT": (DecodeIT, "clusterLocation"),
"SPD": (DecodeSPD, "DigitsContainer"),
'Muon': (DecodeMUON, "OutputLocation"),
'MuonTr': (muonID, "MuonTrackLocation")
}
decoders = {
k: (bm.members(), bm.members()[-1].getProp(loc))
for (k, (bm, loc)) in decoders.iteritems()
}
from HltTracking.HltPVs import PV3D
PVs = PV3D("Hlt2")
from HltTracking.HltTrackNames import Hlt2TrackLoc
recSeq = Sequence("RecSummaryRecoSequence",
IgnoreFilterPassed=True)
from itertools import chain
from Hlt2Lines.Utilities.Utilities import uniqueEverseen
recSeq.Members = list(
uniqueEverseen(
chain.from_iterable(
[dec[0] for dec in decoders.itervalues()] +
[tracks, tracksDown, muonID, PVs])))
summary = RecSummaryAlg(
'Hlt2RecSummary',
SummaryLocation=self.getProp("RecSummaryLocation"),
HltSplitTracks=True,
SplitLongTracksLocation=tracks.outputSelection(),
SplitDownTracksLocation=tracksDown.outputSelection(),
PVsLocation=PVs.output,
VeloClustersLocation=decoders['Velo'][1],
ITClustersLocation=decoders['IT'][1],
TTClustersLocation=decoders['TT'][1],
SpdDigitsLocation=decoders['SPD'][1],
MuonCoordsLocation=decoders['Muon'][1],
MuonTracksLocation=decoders['MuonTr'][1])
seq.Members = [recSeq, summary]
AfterburnerSeq.Members += [seq]
if self.getProp("AddAdditionalTrackInfos"):
from GaudiKernel.SystemOfUnits import mm
from Configurables import LoKi__VoidFilter as Filter
trackLocations = [
Hlt2BiKalmanFittedForwardTracking().hlt2PrepareTracks(
).outputSelection(),
Hlt2BiKalmanFittedDownstreamTracking().hlt2PrepareTracks().
outputSelection()
]
infoSeq = Sequence("TrackInfoSequence", IgnoreFilterPassed=True)
# I don't want to pull in reconstruction if not run before, then there should be also no candidates needing this information
# This is anyhow done by the RecSummary above
members = [
Hlt2BiKalmanFittedForwardTracking().hlt2PrepareTracks(
).members() + Hlt2BiKalmanFittedDownstreamTracking().
hlt2PrepareTracks().members()
]
infoSeq.Members += list(
uniqueEverseen(chain.from_iterable(members)))
prefix = "Hlt2"
trackClones = Sequence(prefix + "TrackClonesSeq")
#checkTracks = Filter(prefix+"CheckTrackLoc",Code = "EXISTS('%(trackLocLong)s') & EXISTS('%(trackLocDown)s')" % {"trackLocLong" : trackLocations[0], "trackLocDown" : trackLocations[1]})
#trackClones.Members += [checkTracks]
from Configurables import TrackBuildCloneTable, TrackCloneCleaner
cloneTable = TrackBuildCloneTable(prefix + "FindTrackClones")
cloneTable.maxDz = 500 * mm
cloneTable.zStates = [0 * mm, 990 * mm, 9450 * mm]
cloneTable.klCut = 5e3
cloneTable.inputLocations = trackLocations
cloneTable.outputLocation = trackLocations[
0] + "Downstream" + "Clones"
cloneCleaner = TrackCloneCleaner(prefix + "FlagTrackClones")
cloneCleaner.CloneCut = 5e3
cloneCleaner.inputLocations = trackLocations
cloneCleaner.linkerLocation = cloneTable.outputLocation
trackClones.Members += [cloneTable, cloneCleaner]
infoSeq.Members += [trackClones]
AfterburnerSeq.Members += [infoSeq]
# Add VeloCharge to protoparticles for dedx
veloChargeSeq = Sequence("VeloChargeSequence")
from Configurables import ChargedProtoParticleAddVeloInfo
protoLocation = Hlt2BiKalmanFittedForwardTracking(
).hlt2ChargedAllPIDsProtos().outputSelection()
checkProto = Filter("CheckProtoParticles",
Code="EXISTS('%(protoLoc)s')" %
{"protoLoc": protoLocation})
addVeloCharge = ChargedProtoParticleAddVeloInfo(
"Hlt2AddVeloCharge")
addVeloCharge.ProtoParticleLocation = protoLocation
decodeVeloFullClusters = DecoderDB[
"DecodeVeloRawBuffer/createVeloClusters"].setup()
veloChargeSeq.Members += [
checkProto, decodeVeloFullClusters, addVeloCharge
]
AfterburnerSeq.Members += [veloChargeSeq]
persistRecoLines = self._persistRecoLines()
if self.getProp("AddPIDToDownstream") and (
len(persistRecoLines) > 0
or len(self.getProp("Hlt2DownstreamFilter")) > 0):
from Configurables import LoKi__HDRFilter as HDRFilter
if (len(persistRecoLines) > 0
and len(self.getProp("Hlt2DownstreamFilter")) > 0):
code = self._persistRecoFilterCode(
persistRecoLines) + " | " + self._filterCode(
self.getProp("Hlt2DownstreamFilter"))
elif len(persistRecoLines) > 0:
code = self._persistRecoFilterCode(persistRecoLines)
elif len(self.getProp("Hlt2DownstreamFilter")) > 0:
code = self._filterCode(self.getProp("Hlt2DownstreamFilter"))
# Activate Downstream RICH for all PersistReco lines
from DAQSys.Decoders import DecoderDB
decoder = DecoderDB["HltDecReportsDecoder/Hlt2DecReportsDecoder"]
hlt2DownstreamFilter = HDRFilter('DownstreamHlt2Filter',
Code=code,
Location=decoder.listOutputs()[0])
downstreamPIDSequence = Sequence("Hlt2AfterburnerDownstreamPIDSeq")
downstreamPIDSequence.Members += [hlt2DownstreamFilter]
downstreamTracking = Hlt2BiKalmanFittedDownstreamTracking()
tracksDown = downstreamTracking.hlt2PrepareTracks()
protosDown = downstreamTracking.hlt2ChargedNoPIDsProtos()
chargedProtosOutputLocation = protosDown.outputSelection()
richPid = downstreamTracking.hlt2RICHID()
downstreamPIDSequence.Members += list(
uniqueEverseen(
chain.from_iterable([tracksDown, protosDown, richPid])))
from Configurables import ChargedProtoParticleAddRichInfo, ChargedProtoParticleAddMuonInfo
downstreamRichDLL_name = "Hlt2AfterburnerDownstreamProtoPAddRich"
downstreamRichDLL = ChargedProtoParticleAddRichInfo(
downstreamRichDLL_name)
downstreamRichDLL.InputRichPIDLocation = richPid.outputSelection()
downstreamRichDLL.ProtoParticleLocation = chargedProtosOutputLocation
# Add the muon info to the DLL
downstreamMuon_name = "Hlt2AfterburnerDownstreamProtoPAddMuon"
downstreamMuon = ChargedProtoParticleAddMuonInfo(
downstreamMuon_name)
downstreamMuon.ProtoParticleLocation = chargedProtosOutputLocation
downstreamMuon.InputMuonPIDLocation = downstreamTracking.hlt2MuonID(
).outputSelection()
# Add the Calo info to the DLL
#
from Configurables import (ChargedProtoParticleAddEcalInfo,
ChargedProtoParticleAddBremInfo,
ChargedProtoParticleAddHcalInfo,
ChargedProtoParticleAddPrsInfo,
ChargedProtoParticleAddSpdInfo)
caloPidLocation = downstreamTracking.hlt2CALOID().outputSelection()
downstreamEcal = ChargedProtoParticleAddEcalInfo(
"HltAfterburnerDownstreamProtoPAddEcal")
downstreamBrem = ChargedProtoParticleAddBremInfo(
"HltAfterburnerDownstreamProtoPAddBrem")
downstreamHcal = ChargedProtoParticleAddHcalInfo(
"HltAfterburnerDownstreamProtoPAddHcal")
downstreamPrs = ChargedProtoParticleAddPrsInfo(
"HltAfterburnerDownstreamProtoPAddPrs")
downstreamSpd = ChargedProtoParticleAddSpdInfo(
"HltAfterburnerDownstreamProtoPAddSpd")
for alg in (downstreamEcal, downstreamBrem, downstreamHcal,
downstreamPrs, downstreamSpd):
alg.setProp("ProtoParticleLocation",
chargedProtosOutputLocation)
alg.setProp("Context", caloPidLocation)
downstreamPIDSequence.Members += [alg]
from Configurables import ChargedProtoCombineDLLsAlg, ChargedProtoANNPIDConf
downstreamCombine_name = "Hlt2AfterburnerDownstreamRichCombDLLs"
downstreamCombine = ChargedProtoCombineDLLsAlg(
downstreamCombine_name)
downstreamCombine.ProtoParticleLocation = downstreamTracking.hlt2ChargedNoPIDsProtos(
).outputSelection()
from Hlt2Lines.Utilities.Utilities import uniqueEverseen
downstreamPIDSequence.Members += [
downstreamMuon, downstreamRichDLL, downstreamCombine
]
probNNDownSeqName = self._instanceName(ChargedProtoANNPIDConf)
probNNDownSeq = GaudiSequencer(probNNDownSeqName + "Seq")
annconfDown = ChargedProtoANNPIDConf(probNNDownSeqName)
annconfDown.DataType = downstreamTracking.DataType
annconfDown.TrackTypes = ["Downstream"]
annconfDown.RecoSequencer = probNNDownSeq
annconfDown.ProtoParticlesLocation = downstreamTracking.hlt2ChargedNoPIDsProtos(
).outputSelection()
downstreamPIDSequence.Members += [probNNDownSeq]
AfterburnerSeq.Members += [downstreamPIDSequence]
# Configure and add the persist reco
AfterburnerSeq.Members += [self._persistRecoSeq()]
def _packers(self):
"""Return a list with the packer algorithms."""
try:
return self._packersCache
except AttributeError:
pass
longTracking = Hlt2BiKalmanFittedForwardTracking()
downstreamTracking = Hlt2BiKalmanFittedDownstreamTracking()
caloHypoPrefix = self.getProp("CaloHypoPrefix")
from Configurables import PackProtoParticle
from Configurables import DataPacking__Pack_LHCb__RichPIDPacker_ as PackRichPIDs
from Configurables import DataPacking__Pack_LHCb__MuonPIDPacker_ as PackMuonPIDs
from Configurables import PackTrack
from Configurables import PackProtoParticle
from Configurables import DataPacking__Pack_LHCb__CaloClusterPacker_ as PackCaloClusters
# from Configurables import DataPacking__Pack_LHCb__CaloHypoPacker_ as PackCaloHypos
from Configurables import PackCaloHypo as PackCaloHypos
algs = [
# ProtoParticles
PackProtoParticle(name="Hlt2PackChargedProtos",
InputName=longTracking.hlt2ChargedAllPIDsProtos(
).outputSelection(),
OutputName="Hlt2/pRec/long/Protos"),
PackProtoParticle(name="Hlt2PackChargedDownProtos",
InputName=downstreamTracking.
hlt2ChargedNoPIDsProtos().outputSelection(),
OutputName="Hlt2/pRec/down/Protos"),
# RICH PIDs
PackRichPIDs(name="Hlt2PackLongRichPIDs",
InputName=longTracking.hlt2RICHID().outputSelection(),
OutputName="Hlt2/pRec/long/RichPIDs"),
PackRichPIDs(
name="Hlt2PackDownRichPIDs",
InputName=downstreamTracking.hlt2RICHID().outputSelection(),
OutputName="Hlt2/pRec/down/RichPIDs"),
# MUON PIDs
PackMuonPIDs(name="Hlt2PackMuonPIDs",
InputName=longTracking.hlt2MuonID().outputSelection(),
OutputName="Hlt2/pRec/long/MuonIDs"),
# Tracks
PackTrack(
name="Hlt2PackLongTracks",
InputName=longTracking.hlt2PrepareTracks().outputSelection(),
OutputName="Hlt2/pRec/long/Tracks"),
PackTrack(name="Hlt2PackDownTracks",
InputName=downstreamTracking.hlt2PrepareTracks().
outputSelection(),
OutputName="Hlt2/pRec/down/Tracks"),
PackTrack(name="Hlt2PackDownPIDMuonSegments",
InputName=downstreamTracking._trackifiedMuonIDLocation(),
OutputName="Hlt2/pRec/down/PID/MuonSegments"),
# Neutral protoparticles are in the same place as the charged with "Neutrals" replacing "Charged"
PackProtoParticle(
name="Hlt2PackNeutralProtoP",
InputName=longTracking.hlt2NeutralProtos().outputSelection(),
OutputName="Hlt2/pRec/neutral/Protos"),
# Neutral CaloClusters
PackCaloClusters(name="Hlt2PackCaloClusters",
InputName="Hlt/Calo/EcalClusters",
OutputName="Hlt2/pRec/neutral/CaloClusters"),
PackCaloClusters(name="Hlt2PackEcalSplitClusters",
InputName=caloHypoPrefix + "/EcalSplitClusters",
OutputName="Hlt2/pRec/neutral/EcalSplitClusters"),
# Neutral Calo Hypos
PackCaloHypos(name="Hlt2PackCaloElectronHypos",
InputName=caloHypoPrefix + "/Electrons",
OutputName="Hlt2/pRec/neutral/Electrons"),
PackCaloHypos(name="Hlt2PackCaloPhotonsHypos",
InputName=caloHypoPrefix + "/Photons",
OutputName="Hlt2/pRec/neutral/Photons"),
PackCaloHypos(name="Hlt2PackCaloMergedPi0Hypos",
InputName=caloHypoPrefix + "/MergedPi0s",
OutputName="Hlt2/pRec/neutral/MergedPi0s"),
PackCaloHypos(name="Hlt2PackCaloSplitPhotonHypos",
InputName=caloHypoPrefix + "/SplitPhotons",
OutputName="Hlt2/pRec/neutral/SplitPhotons"),
]
for alg in algs:
alg.AlwaysCreateOutput = True
alg.DeleteInput = False
alg.OutputLevel = self.getProp("OutputLevel")
if not alg.InputName.startswith('/Event/'):
# This is needed to have the full locations registered in ANNSvc
alg.InputName = '/Event/' + alg.InputName
# Check that the output locations are consistent with the decoder
from DAQSys.Decoders import DecoderDB
try:
decoder = DecoderDB["HltPackedDataDecoder/Hlt2PackedDataDecoder"]
except KeyError:
# TODO remove that for a release on the most recent DAQSys
decoder = None
if decoder:
decoder_outputs = sorted(decoder.listOutputs())
configured_outputs = sorted(alg.OutputName for alg in algs)
if configured_outputs != decoder_outputs:
log.warning('Configured output locations: {}'.format(
configured_outputs))
log.warning(
'Configured decoder locations: {}'.format(decoder_outputs))
raise ValueError(
'Configured output locations do not match the decoder!' +
'Please update the DecoderDB (Decoders.py)!')
self._packersCache = algs
return algs
## # ============================================================================= __author__ = "V. Gligorov [email protected]" # ============================================================================= from Gaudi.Configuration import * from HltLine.HltLine import bindMembers, Hlt2Member from Configurables import FilterDesktop from Configurables import CombinedParticleMaker, BestPIDParticleMaker, NoPIDsParticleMaker, TrackSelector from Configurables import ProtoParticleMUONFilter # # These are all based on fitted tracks # from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedForwardTracking, Hlt2BiKalmanFittedDownstreamTracking Hlt2BiKalmanFittedForwardTracking = Hlt2BiKalmanFittedForwardTracking() Hlt2BiKalmanFittedDownstreamTracking = Hlt2BiKalmanFittedDownstreamTracking() # Tag and probe tracking configurations from HltTracking.Hlt2ProbeTrackingConfigurations import ( Hlt2MuonTTTracking, Hlt2VeloMuonTracking, Hlt2FullDownstreamTracking) Hlt2MuonTTTracking = Hlt2MuonTTTracking() Hlt2VeloMuonTracking = Hlt2VeloMuonTracking() Hlt2FullDownstreamTracking = Hlt2FullDownstreamTracking() ########################################################################## # # Charged protoparticles -> pulls all the pid # caloProtos = Hlt2BiKalmanFittedForwardTracking.hlt2ChargedCaloProtos() muonWithCaloProtos = Hlt2BiKalmanFittedForwardTracking.hlt2ChargedMuonWithCaloProtos(