def configure(self): # objKeyStore stuff needed? from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # --------------------------------------------------------------- # DiTauRec Tools # --------------------------------------------------------------- import DiTauRec.DiTauAlgorithmsHolder as DiTauAlgs from DiTauRec.DiTauRecFlags import diTauFlags from DiTauRec.DiTauRecConf import DiTauBuilder tools = [] tools.append(DiTauAlgs.getSeedJetBuilder(_jet_container)) tools.append(DiTauAlgs.getElMuFinder()) tools.append(DiTauAlgs.getSubjetBuilder()) from InDetRecExample.InDetJobProperties import InDetFlags from JetRec.JetRecFlags import jetFlags if (InDetFlags.doVertexFinding() and jetFlags.useTracks()) or diTauFlags.doVtxFinding: tools.append(DiTauAlgs.getVertexFinder()) pass tools.append(DiTauAlgs.getDiTauTrackFinder()) if diTauFlags.doCellFinding: tools.append( DiTauAlgs.getCellFinder(self.write_jet_cells, self.write_subjet_cells)) pass if not diTauFlags.doCellFinding: self.use_cells = False tools.append(DiTauAlgs.getIDVarCalculator(self.use_cells)) # --------------------------------------------------------------- # add DiTauBuilder to Algorithm Sequence # --------------------------------------------------------------- DiTauBuilder = DiTauBuilder(name=self.name, DiTauContainer=_outputKey, DiTauAuxContainer=_outputAuxKey, Tools=tools, SeedJetName=_jet_container, minPt=diTauFlags.diTauRecJetSeedPt(), maxEta=2.5, OutputLevel=3, Rjet=self.R_jet, Rsubjet=self.R_subjet, Rcore=self.R_core) topSequence += DiTauBuilder #print topSequence return True
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
jetFlags.useTracks = (recTracks or haveTracks) and (recVertices or haveVertices) print myname + " Final useTracks: " + sflagstat(jetFlags.useTracks) if not jetFlags.useVertices.statusOn: jetFlags.useVertices = (recVertices or haveVertices) print myname + " useVertices: " + sflagstat(jetFlags.useVertices) # Disable usage of vertices in pflow jets, if we are using cosmic data. from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == 'cosmics': jetFlags.useVertices = False # Skip pflow if we are not using tracks. print myname + "Initial usePFlow: " + sflagstat(jetFlags.usePFlow) if not jetFlags.usePFlow.statusOn: jetFlags.usePFlow = jetFlags.useTracks() print myname + "Final usePFlow: " + sflagstat(jetFlags.usePFlow) # Skip use of muon segments if not built. # No action if someone has already set the flag. print myname + "Initial use muon segments: " + sflagstat(jetFlags.useMuonSegments) if not jetFlags.useMuonSegments.statusOn: jetFlags.useMuonSegments = rec.doMuon() and rec.doMuonCombined() print myname + " Final use muon segments: " + sflagstat(jetFlags.useMuonSegments) # Use rec flag to control BTagging. # No. Disable this unit we get support from Btagging to do this. # No action if someone has already set the flag. print myname + "Initial use Btagging: " + str(jetFlags.useBTagging) print myname + " rec do BTagging: " + str(rec.doBTagging()) if not jetFlags.useBTagging.statusOn:
"Truth collection %s already exists, no need to rebuild it" % tname) collExists = True break if collExists: continue f = jtm.addJetFinder(tname, "AntiKt", R, "truth", ptmin=HIJetFlags.TruthJetPtMin()) print("Adding %s" % tname) AddToOutputList(tname) #jtm.HIJetRecs+=[f] #track jets if jetFlags.useTracks(): tname = "AntiKt4HITrackJets" hi_trk_modifiers = jtm.modifiersMap["HITrack"] hi_trk_modifiers += AddPtAssociationTools(0.4, False) f = jtm.addJetFinder(tname, "AntiKt", 0.4, "HITrack", hi_trk_modifiers, ptmin=HIJetFlags.TrackJetPtMin()) HIJetFlags.TrackJetContainerName = tname AddToOutputList(tname) jtm.HIJetRecs += [f] #initial unsubtracted jets for R in HIJetFlags.AntiKtRValues():
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)
def configure(self): mlog = logging.getLogger('TauCoreBuilder.py::configure:') mlog.info('entering') from RecExConfig.RecFlags import rec from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addManyTypesStreamESD(self._output) objKeyStore.addManyTypesStreamAOD(self._output) objKeyStore.addManyTypesTransient(self._output) import tauRec.TauAlgorithmsHolder as taualgs from tauRec.tauRecFlags import tauFlags #switch off TJVA if jet reco don't use tracks. from JetRec.JetRecFlags import jetFlags if not tauFlags.isStandalone() and not jetFlags.useTracks(): self.do_TJVA = False # switch off TJVA tools = [] try: tools.append(taualgs.getJetSeedBuilder()) # run vertex finder only in case vertexing is available. This check can also be done in TauAlgorithmsHolder instead doing it here. from InDetRecExample.InDetJobProperties import InDetFlags from tauRec.tauRecFlags import jobproperties doMVATrackClassification = jobproperties.tauRecFlags.tauRecMVATrackClassification( ) doRNNTrackClassification = jobproperties.tauRecFlags.tauRecRNNTrackClassification( ) if tauFlags.isStandalone() or InDetFlags.doVertexFinding(): tools.append( taualgs.getTauVertexFinder(doUseTJVA=self.do_TJVA)) tools.append(taualgs.getTauAxis()) tools.append( taualgs.getTauTrackFinder( removeDuplicateTracks=(not doMVATrackClassification))) if doMVATrackClassification: tools.append(taualgs.getTauTrackClassifier()) if not doMVATrackClassification and doRNNTrackClassification: tools.append(taualgs.getTauTrackRNNClassifier()) if jobproperties.Beam.beamType() != "cosmics": tools.append( taualgs.getEnergyCalibrationLC(correctEnergy=True, correctAxis=False, postfix='_onlyEnergy')) tools.append(taualgs.getCellVariables()) tools.append(taualgs.getElectronVetoVars()) tools.append(taualgs.getTauShotFinder()) if self.doPi0Clus: tools.append(taualgs.getPi0ClusterFinder()) from tauRec.tauRecFlags import tauFlags tools += tauFlags.tauRecToolsDevToolList() except Exception: mlog.error("could not append tools to TauBuilder") traceback.print_exc() return False # run first part of Tau Builder TauRecConfigured.WrapTauRecToolExecHandle(self, tool=tools) return True
OutputName="JetInputTruthParticlesNoWZ", MCTruthClassifier=truthClassifier, IncludePromptLeptons=False, IncludeMuons=True, IncludeNeutrinos=True) #-------------------------------------------------------------- # Jet reco infrastructure. #-------------------------------------------------------------- # Jet pseudojet retriever. jtm += JetPseudojetRetriever("jpjretriever") # Jet constituent retriever. labs = [] if jetFlags.useTracks(): labs += ["Track"] labs += ["AntiKt2TrackJet", "AntiKt2TrackJet"] 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,
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 if not rec.doCalo(): jetFlags.useTopo = False jetlog.info( " TopCluster enabled ? jetFlags.useTopo == %s", jetFlags.useTopo() ) # The following can be used to exclude tools from reconstruction.
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", rclus=0.2, ptfrac=0.05, input="AntiKt10LCTopoJets", modifiersin="lctopo_groomed" ) #-------------------------------------------------------------- # Build output container list. #--------------------------------------------------------------
# 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. jetlog.info(myname + "jetFlags.useTruth: " + str(jetFlags.useTruth())) jetlog.info(myname + "jetFlags.useTopo: " + str(jetFlags.useTopo())) jetlog.info(myname + "jetFlags.useTracks: " + str(jetFlags.useTracks())) jetlog.info(myname + "jetFlags.useMuonSegments: " + str(jetFlags.useMuonSegments())) jetlog.info(myname + "jetFlags.useBTagging: " + str(jetFlags.useBTagging())) jetlog.info(myname + "jetFlags.useCaloQualityTool: " + str(jetFlags.useCaloQualityTool())) jetlog.info(myname + "jetFlags.additionalTopoGetters: " + str(jetFlags.additionalTopoGetters())) jetlog.info(myname + "jetFlags.truthFlavorTags: " + str(jetFlags.truthFlavorTags())) jetlog.info(myname + "jetFlags.skipTools: " + str(jetFlags.skipTools())) ######################################################### # Create standard tool manager. #########################################################
histoPathBase="/Tile/Muid") ManagedAthenaTileMon.AthenaMonTools += [TileMuIdMon] TileL2MuMon = CfgMgr.TileL2MonTool(name='TileL2MuMon', OutputLevel=INFO, FillHistogramsForL1Triggers=[], histoPathBase="/Tile/L2Muon") ManagedAthenaTileMon.AthenaMonTools += [TileL2MuMon] if (jobproperties.Beam.beamType() == 'collisions'): from JetRec.JetRecFlags import jetFlags jetPtMin = 20000. jetContainer = 'AntiKt4EMTopoJets' doJetCleaning = jetFlags.useTracks() doEventCleaning = True if DQMonFlags.monManDataType == 'heavyioncollisions': if not rec.doHIP(): jetContainer = 'AntiKt4HIJets' doEventCleaning = False doJetCleaning = False TileJetMonTool = CfgMgr.TileJetMonTool( name='TileJetMonTool', OutputLevel=INFO, jetPtMin=jetPtMin, jetEtaMax=1.6, jetCollectionName=jetContainer, do_1dim_histos=False,
def buildGenericGroomAlg(jetalg, rsize, inputtype, groomedName, jetToolBuilder, includePreTools=False, algseq=None, outputGroup="CustomJets", writeUngroomed=False, variableRMassScale=-1.0, variableRMinRadius=-1.0, constmods=[]): algname = "jetalg" + groomedName[:-4] from RecExConfig.AutoConfiguration import IsInInputFile if algseq is None: dfjetlog.info("No algsequence passed! Will not schedule " + algname) return elif IsInInputFile("xAOD::JetContainer", groomedName): dfjetlog.info("Collection " + groomedName + " is already in input AOD!") return from JetRec.JetRecUtils import buildJetContName constmodstr = "".join(constmods) inputname = inputtype + constmodstr label = inputtype + constmodstr ungroomedName = buildJetContName(jetalg, rsize, inputname, variableRMassScale, variableRMinRadius) ungroomedalgname = "jetalg" + ungroomedName[:-4] # Remove "Jets" from name # add these groomed jets to the output (use setdefault() to constuct the list if not existing yet) OutputJets.setdefault(outputGroup, []).append(groomedName) if writeUngroomed: OutputJets.setdefault(outputGroup, []).append(ungroomedName) dfjetlog.info("Write " + ungroomedName) from JetRec.JetRecConf import JetAlgorithm # return if the alg is already scheduled here : if hasattr(algseq, ungroomedalgname): finderalg = getattr(algseq, ungroomedalgname) dfjetlog.warning("Algsequence " + algseq.name() + " already has an instance of " + ungroomedalgname) elif ungroomedalgname in DFJetAlgs: dfjetlog.info("Added jet finder " + ungroomedalgname + " to sequence" + algseq.name()) finderalg = DFJetAlgs[ungroomedalgname] algseq += DFJetAlgs[ungroomedalgname] else: # 1. make sure we have pseudo-jet in our original container # this returns a list of the needed tools to do so. jetalgTools = reCreatePseudoJets(jetalg, rsize, inputtype, variableRMassScale, variableRMinRadius, algseq, constmods=constmods) if includePreTools and jetFlags.useTracks( ) and not "Truth" in inputtype: # enable track ghost association and JVF jetalgTools = [jtm.tracksel, jtm.tvassoc] + jetalgTools finderalg = JetAlgorithm(ungroomedalgname, Tools=jetalgTools) DFJetAlgs[ungroomedalgname] = finderalg dfjetlog.info("Added jet finder " + ungroomedalgname + " to sequence " + algseq.name()) algseq += finderalg # 2nd step run the trimming alg. We can re-use the original largeR jet since we reassociated the PseudoJet already. fatjet_groom = jetToolBuilder(groomedName, ungroomedName) print(finderalg.Tools) print(ungroomedName) fatjet_rectool = [ t for t in finderalg.Tools if t.name().endswith(ungroomedName) ][0] fatjet_groom.InputPseudoJets = fatjet_rectool.InputPseudoJets # recopy the InputPseudoJets so tools know how to map fastjet constituents with xAOD constituents dfjetlog.info("Added jet groomer " + algname + " to sequence " + algseq.name()) groomeralg = JetAlgorithm(algname, Tools=[fatjet_groom]) DFJetAlgs[algname] = groomeralg algseq += groomeralg return groomeralg
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
theCalibTool.CalibSequence='EtaJES' theCalibTool.lock() #use existing R=0.2 jets from previous reco, only making use of discriminant seed_prefix='AntiKt%dHIJets' % int(10*HIJetFlags.SeedRValue()) seeds0=jtm.addJetCopier("%s_%s0" % (seed_prefix, HIJetFlags.SeedSuffix()),seed_prefix,[jtm.discrim],shallow=False) jtm.HIJetRecs+=[seeds0] iter0=AddIteration(seed_container=seeds0.OutputContainer,shape_name=EventShapeKey,suffix="iter0") modulator0=iter0.Modulator subtr1=MakeSubtractionTool(iter0.OutputEventShapeKey,modulator=modulator0) #now iterate seeds1=jtm.addJetCopier("%s_%s1" % (seed_prefix,HIJetFlags.SeedSuffix()),seed_prefix,[subtr1,jtm.HICalibMap[seed_prefix],jtm.jetfilHISeeds],shallow=False) jtm.HIJetRecs+=[seeds1] iteration_dict=dict(suffix="iter1") if jetFlags.useTracks() and HIJetFlags.TrackJetSeeds() : iteration_dict['track_jet_seeds']=HIJetFlags.TrackJetContainerName() iter1=AddIteration(seed_container=seeds1.OutputContainer,shape_name=EventShapeKey,**iteration_dict) HIJetFlags.IteratedEventShapeKey=iter1.OutputEventShapeKey modulator1=iter1.Modulator jtm.modulator=modulator1 from HIJetRec.HIJetRecConf import HIClusterSubtraction cluster_update=HIClusterSubtraction('HIClusterUpdate') cluster_update.ClusterKey="HIClusters" cluster_update.EventShapeKey=HIJetFlags.IteratedEventShapeKey() cluster_update.Subtractor=jtm.HIJetClusterSubtractor cluster_update.Modulator=modulator1 cluster_update.UpdateOnly=True jtm.add(cluster_update) jtm.jetrecs += [cluster_update]
inpdmp = ToolSvc.inpdmp inpdmp.ContainerName = clname inpdmp.Detail = 1 inpdmp.MaxObject = 20 inpdmp.OutputLevel = INFO jetalg.Tools += [inpdmp] # Dump pseudojets after reco. names = [] if dumpPseudojets: if jetFlags.useTruth(): names += ["PseudoJetTruth"] names += ["PseudoJetTruthWZ"] names += ["PseudoJetEMTopo"] names += ["PseudoJetLCTopo"] if jetFlags.useTracks(): names += ["PseudoJetTracks"] if jetFlags.useTruth(): names += ["PseudoJetGhostTruth"] for ptype in jetFlags.truthFlavorTags(): names += ["PseudoJetGhost" + ptype] if jetFlags.useMuonSegments(): names += ["PseudoJetGhostMuonSegment"] icount = 0 for name in names: tname = "psjdmp" + str(icount) icount += 1 from JetRec.JetRecConf import JetDumper psjdmp = JetDumper(tname) ToolSvc += psjdmp psjdmp.ContainerName = name
or haveVertices) print myname + " Final useTracks: " + sflagstat(jetFlags.useTracks) if not jetFlags.useVertices.statusOn: jetFlags.useVertices = (recVertices or haveVertices) print myname + " useVertices: " + sflagstat(jetFlags.useVertices) # Disable usage of vertices in pflow jets, if we are using cosmic data. from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == 'cosmics': jetFlags.useVertices = False # Skip pflow if we are not using tracks. print myname + "Initial usePFlow: " + sflagstat(jetFlags.usePFlow) if not jetFlags.usePFlow.statusOn: jetFlags.usePFlow = jetFlags.useTracks() print myname + "Final usePFlow: " + sflagstat(jetFlags.usePFlow) # Skip use of muon segments if not built. # No action if someone has already set the flag. print myname + "Initial use muon segments: " + sflagstat( jetFlags.useMuonSegments) if not jetFlags.useMuonSegments.statusOn: jetFlags.useMuonSegments = rec.doMuon() and rec.doMuonCombined() print myname + " Final use muon segments: " + sflagstat( jetFlags.useMuonSegments) # Use rec flag to control BTagging. # No. Disable this unit we get support from Btagging to do this. # No action if someone has already set the flag. print myname + "Initial use Btagging: " + str(jetFlags.useBTagging)
# 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 # Global jet tool manager with standard definitions
if jetFlags.useTruth: jtm += CopyTruthJetParticles("truthpartcopy", OutputName="JetInputTruthParticles" ) jtm += CopyTruthJetParticles("truthpartcopywz", OutputName="JetInputTruthParticlesNoWZ" ,IncludeWZLeptons=False, IncludeTauLeptons=False) #-------------------------------------------------------------- # 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
# 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
SkipNegativeEnergy = False, TreatNegativeEnergyAsGhost=True, GhostScale = 1.e-20 ) 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
from METReconstruction.METRecoFlags import metFlags from METReconstruction.METRecoConfig import BuildConfig, RefConfig, METConfig, clusterSigStates from RecExConfig.RecFlags import rec doInDet = rec.doInDet() from JetRec.JetRecFlags import jetFlags jetsUseTracks = jetFlags.useTracks() ############################################################################ # MET_RefFinal rf_builders = [ BuildConfig('Ele'), BuildConfig('Gamma'), BuildConfig('Tau'), BuildConfig('Jet'), BuildConfig('SoftClus'), BuildConfig('SoftTrk') ] rf_refiners = [RefConfig('TrackFilter', 'PVSoftTrk')] cfg_mrf = METConfig('RefFinal', rf_builders, rf_refiners, doSum=True, doTracks=(doInDet and jetsUseTracks), doRegions=True) # Configure the tools explicitly with defaults # These are mostly already set in the constructor declareProperty calls cfg_mrf.builders['Ele'].MinPt = 10e3 cfg_mrf.builders['Ele'].MaxEta = 2.47