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