def AppendOutputList(HIAODItemList=[]):
"""Adds HIJetOutputList to the list passed in as an argument"""
if HIJetFlags.WriteClusters():
AddToOutputList(HIJetFlags.HIClusterKey(),
"xAOD::CaloClusterContainer")
from RecExConfig.RecFlags import rec
if not rec.doESD():
for R in HIJetFlags.AntiKtRValues():
AddToOutputList("AntiKt%dHIJets" % int(10 * R))
if jetFlags.useTruth():
AddToOutputList("AntiKt%dTruthJets" % int(10 * R))
AddToOutputList(HIJetFlags.TrackJetContainerName())
HIAODItemList += HIJetFlags.HIJetOutputList()
def AddPtAssociationTools(R, doTracks=True):
tlist = []
if doTracks and jetFlags.useTracks():
cname = HIJetFlags.TrackJetContainerName()
tname = 'hitrackassoc_04'
if tname not in jtm.tools:
JetPtAssociationTool = CompFactory.JetPtAssociationTool
jtm.add(
JetPtAssociationTool(tname,
InputContainer=cname,
AssociationName="GhostTrack"))
tlist += [jtm.tools[tname]]
if jetFlags.useTruth():
cname = 'AntiKt%dTruthJets' % int(10 * R)
tname = 'truthassoc_0%d' % int(10 * R)
if tname not in jtm.tools:
JetPtAssociationTool = CompFactory.JetPtAssociationTool
jtm.add(
JetPtAssociationTool(tname,
InputContainer=cname,
AssociationName="GhostTruth"))
tlist += [jtm.tools[tname]]
return tlist
def JetAlgFromTools(rtools, suffix="HI", persistify=True):
#insert exe tools at front of list, e.g. tracksel and tvassoc for HI etc.
HIJet_exe_tools = []
from JetRec.JetRecFlags import jetFlags
if jetFlags.useTruth() and not jetFlags.Enabled():
HIJet_exe_tools += HITruthParticleCopy()
#if jetFlags.useCells(): HIJet_exe_tools += [jtm.missingcells]
if HIJetFlags.UseHITracks():
HIJet_exe_tools += [jtm.tracksel_HI, jtm.gtracksel_HI, jtm.tvassoc_HI]
rtools = HIJet_exe_tools + rtools
from JetRec.JetRecConf import JetToolRunner
runner = JetToolRunner("jetrun" + suffix,
Tools=rtools,
Timer=jetFlags.timeJetToolRunner())
jtm.add(runner)
from JetRec.JetRecConf import JetAlgorithm
theAlg = JetAlgorithm("jetalg" + suffix)
theAlg.Tools = [runner]
from AthenaCommon.AlgSequence import AlgSequence
topsequence = AlgSequence()
topsequence += theAlg
from GaudiKernel.Constants import DEBUG
if jetFlags.debug > 0:
jtm.setOutputLevel(runner, DEBUG)
theAlg.OutputLevel = DEBUG
if jetFlags.debug > 3:
jtm.setOutputLevel(jtm.jetBuilderWithoutArea, DEBUG)
if persistify:
for t in rtools:
if hasattr(t, "OutputContainer"):
AddToOutputList(t.OutputContainer)
return theAlg
jtm += PseudoJetGetter("gakt4trackget_HI",
InputContainer = HIJetFlags.TrackJetContainerName(),
Label = "Ghost" + HIJetFlags.TrackJetContainerName(),
SkipNegativeEnergy = True,
OutputContainer = "PseudoJetGhost" + HIJetFlags.TrackJetContainerName(),
GhostScale = 1.e-20)
HIgetters_ghost_track = []
HIgetters_common=[]
if jetFlags.useMuonSegments(): HIgetters_common += [jtm.gmusegget]
if jetFlags.useTracks():
HIgetters_ghost_track += [jtm.gakt4trackget_HI]
if HIJetFlags.UseHITracks() : HIgetters_ghost_track += [jtm.gtrackget_HI]
else: HIgetters_ghost_track += [jtm.gtrackget]
if jetFlags.useTruth():
#HIgetters_common += [jtm.gtruthget]
flavorgetters=[]
for ptype in jetFlags.truthFlavorTags():
flavorgetters += [getattr(jtm, "gtruthget_" + ptype)]
HIgetters_common += flavorgetters
jtm.gettersMap['HI'] = [jtm.get_HI]
jtm.gettersMap['HI'] += HIgetters_common
jtm.gettersMap['HI'] += HIgetters_ghost_track
jtm.gettersMap['HITrack'] = []
if HIJetFlags.UseHITracks() : jtm.gettersMap['HITrack'] += [jtm.trackget_HI]
else : jtm.gettersMap['HITrack'] += [jtm.trackget]
jtm.gettersMap['HITrack'] += HIgetters_common
# Run with
# > athena.py test_RunJetRec.py
#
myname = "JetRec_jobOptions:"
# Import the jet reconstruction control flags.
from JetRec.JetRecFlags import jetFlags
from RecExConfig.ObjKeyStore import cfgKeyStore
from AthenaCommon import Logging
jetlog = Logging.logging.getLogger('JetRec_jobOptions')
# Skip truth if rec says it is absent.
if not rec.doTruth():
jetFlags.useTruth = False
jetlog.info( " Truth enabled ? jetFlags.useTruth == %s", jetFlags.useTruth() )
#skip track if not built or not present in the job
if not rec.doInDet() \
and ( not cfgKeyStore.isInTransient("xAOD::VertexContainer_v1","PrimaryVertices") \
or not cfgKeyStore.isInTransient('xAOD::TrackParticleContainer_v1','InDetTrackParticles') ):
jetFlags.useTracks = False
jetlog.info( " Tracks enabled ? jetFlags.useTracks == %s", jetFlags.useTracks() )
#skip muon segment if not built
if not rec.doMuon() or not rec.doMuonCombined() :
jetFlags.useMuonSegments = False
print rec.doMuon() , rec.doMuonCombined()
jetlog.info( " MuonSegments enabled ? jetFlags.useMuonSegments == %s", jetFlags.useMuonSegments() )
#skip cluster if not built
#--------------------------------------------------------------
# Jet reco infrastructure.
#--------------------------------------------------------------
# Jet pseudojet retriever.
jtm += JetPseudojetRetriever("jpjretriever")
# Jet constituent retriever.
labs = []
if jetFlags.useTracks():
labs += ["Track"]
labs += ["AntiKt3TrackJet", "AntiKt3TrackJet"]
if jetFlags.useMuonSegments():
labs += ["MuonSegment",]
if jetFlags.useTruth():
labs += ["Truth"]
for lab in jetFlags.truthFlavorTags():
labs += [lab]
jtm += JetConstituentsRetriever(
"jconretriever",
UsePseudojet = True,
UseJetConstituents = True,
PseudojetRetriever = jtm.jpjretriever,
GhostLabels = labs,
GhostScale = 1.e-20
)
#--------------------------------------------------------------
# Pseudojet builders.
#--------------------------------------------------------------
if not jetFlags.useVertices():
calibopt = "aj"
jetlog.info(myname + "No vertices -- switch calibopt to " + calibopt)
# Finders.
if jetFlags.detailLevel()==JetContentDetail.Reduced:
if jetFlags.useTopo():
jtm.addJetFinder("AntiKt4EMTopoJets", "AntiKt", 0.4, "emtopo_reduced", "emtopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt4LCTopoJets", "AntiKt", 0.4, "lctopo_reduced", "lctopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt10LCTopoJets", "AntiKt", 1.0, "lctopo_reduced", "lctopo_ungroomed", ghostArea=0.01, ptmin= 40000, ptminFilter=50000, calibOpt="none")
if jetFlags.usePFlow():
jtm.addJetFinder("AntiKt4EMPFlowJets", "AntiKt", 0.4, "empflow_reduced", "pflow_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 10000, calibOpt=calibopt+":pflow")
# if jetFlags.useTruth():
# jtm.addJetFinder("AntiKt4TruthJets", "AntiKt", 0.4, "truth", ptmin= 5000)
elif jetFlags.detailLevel()>=JetContentDetail.Full:
if jetFlags.useTruth():
jtm.addJetFinder("AntiKt4TruthJets", "AntiKt", 0.4, "truth", ptmin= 5000)
jtm.addJetFinder("AntiKt4TruthWZJets", "AntiKt", 0.4, "truthwz", ptmin= 5000)
jtm.addJetFinder("AntiKt10TruthJets", "AntiKt", 1.0, "truth", ptmin=40000)
jtm.addJetFinder("AntiKt10TruthWZJets", "AntiKt", 1.0, "truthwz", ptmin=40000)
if jetFlags.useTracks():
jtm.addJetFinder("AntiKt2PV0TrackJets", "AntiKt", 0.2, "pv0track", ptmin= 2000)
jtm.addJetFinder("AntiKt4PV0TrackJets", "AntiKt", 0.4, "pv0track", ptmin= 2000)
if jetFlags.useTopo():
jtm.addJetFinder("AntiKt4EMTopoJets", "AntiKt", 0.4, "emtopo", "emtopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt4LCTopoJets", "AntiKt", 0.4, "lctopo", "lctopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt10LCTopoJets", "AntiKt", 1.0, "lctopo", "lctopo_ungroomed", ghostArea=0.01, ptmin= 40000, ptminFilter=50000, calibOpt="none")
if jetFlags.usePFlow():
jtm.addJetFinder("AntiKt4EMPFlowJets", "AntiKt", 0.4, "empflow", "pflow_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 10000, calibOpt=calibopt+":pflow")
if jetFlags.detailLevel()==JetContentDetail.Validation:
jtm.addJetTrimmer( "AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets",
ClusterKey = HIJetFlags.HIClusterKey()
#import utility functions
from HIJetRec.HIJetRecUtils import *
HIClusterGetter()
#equip basic tools
from HIJetRec.HIJetRecTools import jtm
#------------------------------
#set flags, keys and configure new event shape algorithm
#>check if is MC or overlay and configure calibration tool properly
from JetRec.JetRecFlags import jetFlags
is_mc_or_overlay = False
is_pp_mc = False
if not jetFlags.useTruth():
if globalflags.DataSource() == 'geant4':
is_mc_or_overlay = True
#Check if it is pp (not HIJING)
if rec.doHIP(): is_pp_mc = True
jetFlags.useTruth.set_Value_and_Lock(is_mc_or_overlay)
#Tower level subtraction - made it false by default to avoid confusion
#HIJetFlags.DoCellBasedSubtraction.set_Value_and_Lock(False)
jetFlags.useTracks.set_Value_and_Lock(True)
#HIP mode
if rec.doHIP(): SetHIPMode()
theSubtrTool = jtm.HIJetClusterSubtractor
theSubtrTool.unlock()
def addJetRecoToAlgSequence(job=None,
useTruth=None,
eventShapeTools=None,
separateJetAlgs=None,
debug=None):
myname = "JetAlgorithm: "
# We need this to modify the global variable.
global jetalg
# Import message level flags.
from GaudiKernel.Constants import DEBUG
# Import the jet reconstruction control flags.
from JetRec.JetRecFlags import jetFlags
# Import the standard jet tool manager.
from JetRec.JetRecStandardToolManager import jtm
# Set sequence and flags as needed.
if job == None:
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if useTruth == None:
useTruth = jetFlags.useTruth()
if eventShapeTools == None:
eventShapeTools = jetFlags.eventShapeTools()
if eventShapeTools == None:
eventShapeTools = []
if separateJetAlgs == None:
separateJetAlgs = jetFlags.separateJetAlgs()
# Event shape tools.
evstools = []
evsDict = {
"emtopo": ("EMTopoEventShape", jtm.emget),
"lctopo": ("LCTopoEventShape", jtm.lcget),
"empflow": ("EMPFlowEventShape", jtm.empflowget),
"emcpflow": ("EMCPFlowEventShape", jtm.emcpflowget),
"lcpflow": ("LCPFlowEventShape", jtm.lcpflowget),
}
if jetFlags.useTracks():
evsDict["emtopo"] = ("EMTopoOriginEventShape", jtm.emoriginget)
evsDict["lctopo"] = ("LCTopoOriginEventShape", jtm.lcoriginget)
jetlog.info(myname + "Event shape tools: " + str(eventShapeTools))
from RecExConfig.AutoConfiguration import IsInInputFile
for evskey in eventShapeTools:
from EventShapeTools.EventDensityConfig import configEventDensityTool
if evskey in evsDict:
(toolname, getter) = evsDict[evskey]
if toolname in jtm.tools:
jetlog.info(myname + "Skipping duplicate event shape: " +
toolname)
else:
jetlog.info(myname + "Adding event shape " + evskey)
if not IsInInputFile("xAOD::EventShape", "Kt4" + toolname):
jtm += configEventDensityTool(toolname, getter, 0.4)
evstools += [jtm.tools[toolname]]
else:
jetlog.info(myname + "Invalid event shape key: " + evskey)
raise Exception
# Add the tool runner. It runs the jetrec tools.
rtools = []
# Add the truth tools.
if useTruth:
from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles
rtools += scheduleCopyTruthParticles()
# build truth jet input :
rtools += [jtm.truthpartcopy, jtm.truthpartcopywz]
## if jetFlags.useCells():
## rtools += [jtm.missingcells] commented out : incompatible with trigger : ATR-9696
if jetFlags.useTracks:
rtools += [
jtm.tracksel,
jtm.tvassoc,
jtm.trackselloose_trackjets,
]
# Add the algorithm. It runs the jetrec tools.
from JetRec.JetRecConf import JetAlgorithm
ctools = []
if jetFlags.useTracks:
if not IsInInputFile("xAOD::CaloClusterContainer",
"LCOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_LCOrigin]
if not IsInInputFile("xAOD::CaloClusterContainer",
"EMOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_EMOrigin]
from JetRec.JetRecConf import JetToolRunner
runners = []
if len(ctools) > 0:
jtm += JetToolRunner("jetconstit",
EventShapeTools=[],
Tools=ctools,
Timer=jetFlags.timeJetToolRunner())
jtm.jetconstit
runners = [jtm.jetconstit]
if jetFlags.separateJetAlgs():
jtm += JetToolRunner("jetrun",
EventShapeTools=evstools,
Tools=rtools,
Timer=jetFlags.timeJetToolRunner())
runners += [jetrun]
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = runners
for t in jtm.jetrecs:
jalg = JetAlgorithm("jetalg" + t.name())
jalg.Tools = [t]
job += jalg
else:
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
EventShapeTools=evstools,
Tools=rtools + jtm.jetrecs,
Timer=jetFlags.timeJetToolRunner())
runners += [jtm.jetrun]
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = runners
if jetFlags.debug > 0:
jtm.setOutputLevel(jtm.jetrun, DEBUG)
jetalg.OutputLevel = DEBUG
if jetFlags.debug > 1:
for tool in jtm.jetrecs:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 2:
for tool in jtm.finders:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 3:
jtm.setOutputLevel(jtm.jetBuilderWithArea, DEBUG)
jtm.setOutputLevel(jtm.jetBuilderWithoutArea, DEBUG)
jetFlags.useBTagging.set_On()
# Lock all the flags used here so that later attempts to change
# the value will fail with an error message.
jetFlags.useTruth.lock()
jetFlags.useTopo.lock()
jetFlags.useTracks.lock()
jetFlags.useMuonSegments.lock()
jetFlags.useBTagging.lock()
jetFlags.useCaloQualityTool.lock()
jetFlags.additionalTopoGetters.lock()
jetFlags.truthFlavorTags.lock()
jetFlags.skipTools.lock()
# Display all flags used here.
print myname + "jetFlags.useTruth: " + str(jetFlags.useTruth())
print myname + "jetFlags.useTopo: " + str(jetFlags.useTopo())
print myname + "jetFlags.useTracks: " + str(jetFlags.useTracks())
print myname + "jetFlags.useMuonSegments: " + str(jetFlags.useMuonSegments())
print myname + "jetFlags.useBTagging: " + str(jetFlags.useBTagging())
print myname + "jetFlags.useCaloQualityTool: " + str(
jetFlags.useCaloQualityTool())
print myname + "jetFlags.additionalTopoGetters: " + str(
jetFlags.additionalTopoGetters())
print myname + "jetFlags.truthFlavorTags: " + str(jetFlags.truthFlavorTags())
print myname + "jetFlags.skipTools: " + str(jetFlags.skipTools())
#########################################################
# Create standard tool manager.
#########################################################
jetFlags.useBTagging.set_On() # Lock all the flags used here so that later attempts to change # the value will fail with an error message. jetFlags.useTruth.lock() jetFlags.useTopo.lock() jetFlags.useTracks.lock() jetFlags.useMuonSegments.lock() jetFlags.useBTagging.lock() jetFlags.useCaloQualityTool.lock() jetFlags.additionalTopoGetters.lock() jetFlags.truthFlavorTags.lock() jetFlags.skipTools.lock() # Display all flags used here. print myname + "jetFlags.useTruth: " + str(jetFlags.useTruth()) print myname + "jetFlags.useTopo: " + str(jetFlags.useTopo()) print myname + "jetFlags.useTracks: " + str(jetFlags.useTracks()) print myname + "jetFlags.useMuonSegments: " + str(jetFlags.useMuonSegments()) print myname + "jetFlags.useBTagging: " + str(jetFlags.useBTagging()) print myname + "jetFlags.useCaloQualityTool: " + str(jetFlags.useCaloQualityTool()) print myname + "jetFlags.additionalTopoGetters: " + str(jetFlags.additionalTopoGetters()) print myname + "jetFlags.truthFlavorTags: " + str(jetFlags.truthFlavorTags()) print myname + "jetFlags.skipTools: " + str(jetFlags.skipTools()) ######################################################### # Create standard tool manager. ######################################################### # Import the jet tool manager. from JetRec.JetToolSupport import JetToolManager
def JetAlgFromTools(rtools, suffix="HI", persistify=True):
from HIJetRec.HIJetRecTools import jtm
#insert exe tools at front of list, e.g. tracksel and tvassoc for HI etc.
HIJet_exe_tools = []
from JetRec.JetRecFlags import jetFlags
if jetFlags.useTruth() and not jetFlags.Enabled():
HIJet_exe_tools += HITruthParticleCopy()
#if jetFlags.useCells(): HIJet_exe_tools += [jtm.missingcells]
if HIJetFlags.UseHITracks():
HIJet_exe_tools += [jtm.tracksel_HI, jtm.gtracksel_HI, jtm.tvassoc_HI]
#Now we split in two algorithms to provide input to PseudoJetAlgorithm
#rtools=HIJet_exe_tools+rtools
from AthenaCommon.AlgSequence import AlgSequence
topsequence = AlgSequence()
JetToolRunner = CompFactory.JetToolRunner
JetAlgorithm = CompFactory.JetAlgorithm
if len(HIJet_exe_tools) > 0:
jtm += JetToolRunner("jetrunconstit" + suffix,
Tools=HIJet_exe_tools,
Timer=jetFlags.timeJetToolRunner())
topsequence += JetAlgorithm("jetalgconstit" + suffix,
Tools=[jtm.jetrunconstitHI])
# Add the PseudoJetAlgorithm
# To avoid massive refactoring and to preserve familiarity,
# jet guys kept calling things "getters", but these are already
# PseudoJetAlgorithms as they eliminated the wrappers
for getter in jtm.allGetters:
print('Adding PseudoJetAlgorithm %s' % getter.name)
print('Input Container %s' % getter.InputContainer)
print('Output Container %s' % getter.OutputContainer)
print('Label %s' % getter.Label)
topsequence += getter
runner = JetToolRunner("jetrun" + suffix,
Tools=rtools,
Timer=jetFlags.timeJetToolRunner())
jtm.add(runner)
theAlg = JetAlgorithm("jetalg" + suffix)
theAlg.Tools = [runner]
topsequence += theAlg
from GaudiKernel.Constants import DEBUG
if jetFlags.debug > 0:
jtm.setOutputLevel(runner, DEBUG)
theAlg.OutputLevel = DEBUG
if jetFlags.debug > 3:
jtm.setOutputLevel(jtm.jetBuilderWithoutArea, DEBUG)
if persistify:
for t in rtools:
if hasattr(t, "OutputContainer"):
AddToOutputList(t.OutputContainer)
return theAlg
def addJetRecoToAlgSequence(job =None, useTruth =None, eventShapeTools =None,
separateJetAlgs= None, debug =None):
myname = "JetAlgorithm: "
# We need this to modify the global variable.
global jetalg
# Import message level flags.
from GaudiKernel.Constants import DEBUG
# Import the jet reconstruction control flags.
from JetRec.JetRecFlags import jetFlags
# Import the standard jet tool manager.
from JetRec.JetRecStandardToolManager import jtm
# Set sequence and flags as needed.
if job == None:
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if useTruth == None:
useTruth = jetFlags.useTruth()
if eventShapeTools == None:
eventShapeTools = jetFlags.eventShapeTools()
if eventShapeTools == None:
eventShapeTools = []
if separateJetAlgs == None:
separateJetAlgs = jetFlags.separateJetAlgs()
# Event shape tools.
evstools = []
evsDict = {
"emtopo" : ("EMTopoEventShape", jtm.emget),
"lctopo" : ("LCTopoEventShape", jtm.lcget),
"empflow" : ("EMPFlowEventShape", jtm.empflowget),
"emcpflow" : ("EMCPFlowEventShape", jtm.emcpflowget),
"lcpflow" : ("LCPFlowEventShape", jtm.lcpflowget),
}
print myname + "Event shape tools: " + str(eventShapeTools)
for evskey in eventShapeTools:
from EventShapeTools.EventDensityConfig import configEventDensityTool
if evskey in evsDict:
(toolname, getter) = evsDict[evskey]
if toolname in jtm.tools:
print myname + "Skipping duplicate event shape: " + toolname
else:
print myname + "Adding event shape " + evskey
jtm += configEventDensityTool(toolname, getter, 0.4)
evstools += [jtm.tools[toolname]]
else:
print myname + "Invalid event shape key: " + evskey
raise Exception
# Add the tool runner. It runs the jetrec tools.
rtools = []
# Add the truth tools.
if useTruth:
from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles
rtools += scheduleCopyTruthParticles()
# build truth jet input :
rtools += [ jtm.truthpartcopy, jtm.truthpartcopywz ]
## if jetFlags.useCells():
## rtools += [jtm.missingcells] commented out : incompatible with trigger : ATR-9696
if jetFlags.useTracks:
rtools += [jtm.tracksel,
jtm.tvassoc,
jtm.trackselloose_trackjets,
jtm.JetConstitSeq_LCOrigin,
jtm.JetConstitSeq_EMOrigin,
]
# Add the algorithm. It runs the jetrec tools.
from JetRec.JetRecConf import JetAlgorithm
if jetFlags.separateJetAlgs():
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
EventShapeTools=evstools,
Tools=rtools,
Timer=jetFlags.timeJetToolRunner()
)
jetrun = jtm.jetrun
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = [jtm.jetrun]
for t in jtm.jetrecs:
# from JetRec.JetRecConf import JetToolRunner
# jetrun_rec = JetToolRunner("jetrun"+t.name(),
# EventShapeTools=[],
# Tools=[t],
# Timer=jetFlags.timeJetToolRunner()
# )
# jtm += jetrun_rec
jalg = JetAlgorithm("jetalg"+t.name())
jalg.Tools = [t]
job+= jalg
else:
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
EventShapeTools=evstools,
Tools=rtools+jtm.jetrecs,
Timer=jetFlags.timeJetToolRunner()
)
jetrun = jtm.jetrun
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = [jtm.jetrun]
if jetFlags.debug > 0:
jtm.setOutputLevel(jtm.jetrun, DEBUG)
jetalg.OutputLevel = DEBUG
if jetFlags.debug > 1:
for tool in jtm.jetrecs:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 2:
for tool in jtm.finders:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 3:
jtm.setOutputLevel(jtm.jetBuilderWithArea, DEBUG)
jtm.setOutputLevel(jtm.jetBuilderWithoutArea, DEBUG)
def addJetRecoToAlgSequence(job=None,
useTruth=None,
eventShapeTools=None,
separateJetAlgs=None,
debug=None):
myname = "JetAlgorithm: "
# We need this to modify the global variable.
global jetalg
# Import message level flags.
from GaudiKernel.Constants import DEBUG
# Import the jet reconstruction control flags.
from JetRec.JetRecFlags import jetFlags
# Import the standard jet tool manager.
from JetRec.JetRecStandard import jtm
# Set sequence and flags as needed.
if job == None:
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if useTruth == None:
useTruth = jetFlags.useTruth()
if eventShapeTools == None:
eventShapeTools = jetFlags.eventShapeTools()
if eventShapeTools == None:
eventShapeTools = []
if separateJetAlgs == None:
separateJetAlgs = jetFlags.separateJetAlgs()
# Event shape tools.
evsDict = {
"emtopo": ("EMTopoEventShape", jtm.emget),
"lctopo": ("LCTopoEventShape", jtm.lcget),
"empflow": ("EMPFlowEventShape", jtm.empflowget),
}
if jetFlags.useTracks():
if jetFlags.useVertices():
evsDict["emtopo"] = ("EMTopoOriginEventShape", jtm.emoriginget)
evsDict["lctopo"] = ("LCTopoOriginEventShape", jtm.lcoriginget)
else:
evsDict["emtopo"] = ("EMTopoOriginEventShape", jtm.emget)
evsDict["lctopo"] = ("LCTopoOriginEventShape", jtm.lcget)
jetlog.info(myname + "Event shape tools: " + str(eventShapeTools))
from RecExConfig.AutoConfiguration import IsInInputFile
for evskey in eventShapeTools:
from EventShapeTools.EventDensityConfig import configEventDensityTool
if evskey in evsDict:
(toolname, getter) = evsDict[evskey]
if toolname in jtm.tools:
jetlog.info(myname + "Skipping duplicate event shape: " +
toolname)
else:
jetlog.info(myname + "Adding event shape " + evskey)
if not IsInInputFile("xAOD::EventShape", toolname):
jtm += configEventDensityTool(toolname, getter.Label, 0.4)
jtm.allEDTools += [jtm.tools[toolname]]
else:
jetlog.info(myname + "Invalid event shape key: " + evskey)
raise Exception
# Add the tool runner. It runs the jetrec tools.
ctools = []
# Add the truth tools.
if useTruth:
from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles
ctools += scheduleCopyTruthParticles()
# build truth jet input :
ctools += [jtm.truthpartcopy, jtm.truthpartcopywz]
## if jetFlags.useCells():
## ctools += [jtm.missingcells] commented out : incompatible with trigger : ATR-9696
if jetFlags.useTracks:
ctools += [jtm.tracksel, jtm.trackselloose_trackjets]
if jetFlags.useVertices:
ctools += [jtm.tvassoc]
# LCOriginTopoClusters and EMOriginTopoClusters are shallow copies
# of CaloCalTopoClusters. This means that if CaloCalTopoClusters gets
# thinned on output, the the two derived containers need to be thinned
# in the same way, else they'll be corrupted in the output.
# FIXME: this should be automatic somehow.
postalgs = []
thinneg = False
from RecExConfig.RecFlags import rec
if rec.doWriteAOD() and not rec.readAOD():
from ParticleBuilderOptions.AODFlags import AODFlags
if AODFlags.ThinNegativeEnergyCaloClusters:
thinneg = True
if jetFlags.useTracks and jetFlags.useVertices:
if not IsInInputFile("xAOD::CaloClusterContainer",
"LCOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_LCOrigin]
if thinneg:
from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyCaloClustersAlg
postalgs.append(
ThinNegativeEnergyCaloClustersAlg(
'ThinNegLCOriginTopoClusters',
ThinNegativeEnergyCaloClusters=True,
CaloClustersKey='LCOriginTopoClusters',
StreamName='StreamAOD'))
if not IsInInputFile("xAOD::CaloClusterContainer",
"EMOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_EMOrigin]
if thinneg:
from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyCaloClustersAlg
postalgs.append(
ThinNegativeEnergyCaloClustersAlg(
'ThinNegEMOriginTopoClusters',
ThinNegativeEnergyCaloClusters=True,
CaloClustersKey='EMOriginTopoClusters',
StreamName='StreamAOD'))
if not IsInInputFile("xAOD::PFOContainer", "CHSParticleFlowObjects"):
if not hasattr(job, "jetalgCHSPFlow"):
ctools += [jtm.JetConstitSeq_PFlowCHS]
if thinneg:
from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyNeutralPFOsAlg
CHSnPFOsThinAlg = ThinNegativeEnergyNeutralPFOsAlg(
"ThinNegativeEnergyCHSNeutralPFOsAlg",
NeutralPFOsKey="CHSNeutralParticleFlowObjects",
ThinNegativeEnergyNeutralPFOs=True,
StreamName='StreamAOD')
postalgs.append(CHSnPFOsThinAlg)
from JetRec.JetRecConf import JetToolRunner
from JetRec.JetRecConf import JetAlgorithm
runners = []
if len(ctools) > 0:
jtm += JetToolRunner("jetconstit",
EventShapeTools=[],
Tools=ctools,
Timer=jetFlags.timeJetToolRunner())
job += JetAlgorithm("jetalgConstituents", Tools=[jtm.jetconstit])
# Add all the PseudoJetAlgorithms now
# To avoid massive refactoring and to preserve familiarity,
# kept calling things "getters", but these are already
# PseudoJetAlgorithms as we eliminated the wrappers
for getter in jtm.allGetters:
job += getter
# Then, add all event shape tools in separate algs
for evstool in jtm.allEDTools:
from EventShapeTools.EventShapeToolsConf import EventDensityAthAlg
job += EventDensityAthAlg("edalg_" + evstool.OutputContainer,
EventDensityTool=evstool)
if separateJetAlgs:
for t in jtm.jetrecs:
jalg = JetAlgorithm("jetalg" + t.name(), Tools=[t])
job += jalg
else:
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
EventShapeTools=[],
Tools=rtools + jtm.jetrecs,
Timer=jetFlags.timeJetToolRunner())
runners += [jtm.jetrun]
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = runners
if jetFlags.debug > 0:
# jtm.setOutputLevel(jtm.jetrun, DEBUG)
jetalg.OutputLevel = DEBUG
if jetFlags.debug > 1:
for tool in jtm.jetrecs:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 2:
for tool in jtm.finders:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 3:
jtm.setOutputLevel(jtm.jetBuilderWithArea, DEBUG)
jtm.setOutputLevel(jtm.jetBuilderWithoutArea, DEBUG)
for postalg in postalgs:
job += postalg
