def WrapTauRecToolExecHandle(self, tool=None): self.TauProcessorAlgHandle().Tools = tool from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() if jobproperties.Beam.beamType() != "cosmics": # Can I move this to different script? from AthenaCommon.AppMgr import ToolSvc from JetRec.JetRecConf import JetAlgorithm jetTrackAlg = JetAlgorithm("JetTrackAlg_forTaus") from JetRecTools.JetRecToolsConf import TrackVertexAssociationTool TauTVATool = TrackVertexAssociationTool( TrackParticleContainer="InDetTrackParticles", TrackVertexAssociation="JetTrackVtxAssoc_forTaus", VertexContainer="PrimaryVertices", MaxTransverseDistance=2.5 * mm, #MaxLongitudinalDistance = 2 *mm, MaxZ0SinTheta=3.0 * mm, #OutputLevel=2 ) ToolSvc += TauTVATool jetTrackAlg.Tools = [TauTVATool] topSequence += jetTrackAlg # import tauRec.TauAlgorithmsHolder as taualgs # add tauJVF tool to topSequence # taualgs.setupTauJVFTool topSequence += self.TauProcessorAlgHandle()
def addKmeansCollection(nsubjet, recordNameAppendix = "", ToolSvc = ToolSvc, Sequencer = FTAG5Seq): global KmeansJetCollection__SubJet output = [] for JetCollectionKmeans in KmeansJetCollection__FatJet: # build KmeansbbTagTool instance (KmeansbbTagToolInstance, SubjetContainerName) = buildKmeansSubjets(JetCollectionKmeans, nsubjet, recordNameAppendix, ToolSvc) KmeansJetCollection__SubJet += [SubjetContainerName] output += [SubjetContainerName] # build subjet collection through JetRecTool from JetRec.JetRecConf import JetRecTool jetrec = JetRecTool( name = "JetRecTool_Kmeansbb%i%s_%s" % (nsubjet, recordNameAppendix, JetCollectionKmeans), OutputContainer = JetCollectionKmeans, InputContainer = JetCollectionKmeans, JetModifiers = [KmeansbbTagToolInstance], ) ToolSvc += jetrec Sequencer += JetAlgorithm( name = "JetAlgorithm_Kmeansbb%i%s_%s" % (nsubjet, recordNameAppendix, JetCollectionKmeans), Tools = [jetrec], ) return output
def replaceBuggyAntiKt10TruthWZJets(algseq, outputGroup='BugFix'): if jetFlags.useTruth: jetnamebase = 'AntiKt10TruthWZ' jetname = jetnamebase + 'Jets' algname = 'jetalg' + jetnamebase OutputJets.setdefault(outputGroup, []).append(jetname) # return if the alg is already scheduled here : if algseq is None: print 'ExtendedJetCommon: No algsequence passed! Will not schedule', algname return elif algname in DFJetAlgs: if hasattr(algseq, algname): print 'ExtendedJetCommon: Algsequence', algseq, 'already has an instance of', algname else: print 'ExtendedJetCommon: Added', algname, 'to sequence', algseq algseq += DFJetAlgs[algname] return DFJetAlgs[algname] if not jetname in jtm.tools: finderTool = jtm.addJetFinder(jetname, 'AntiKt', 1.0, 'truthwz', ptmin=40000, overwrite=True, warnIfDuplicate=False) from JetRec.JetRecConf import JetAlgorithm alg = JetAlgorithm(algname, Tools=[finderTool]) print 'ExtendedJetCommon: Added', algname, 'to sequence', algseq algseq += alg DFJetAlgs[algname] = alg
def replaceBuggyAntiKt10TruthWZJets(algseq, outputGroup="BugFix"): if jetFlags.useTruth: jetnamebase = "AntiKt10TruthWZ" jetname = jetnamebase + "Jets" algname = "jetalg" + jetnamebase OutputJets.setdefault(outputGroup, []).append(jetname) # return if the alg is already scheduled here : if algseq is None: print "No algsequence passed! Will not schedule", algname return elif algname in DFJetAlgs: if hasattr(algseq, algname): print " Algsequence", algseq, "already has an instance of", algname else: print " Added", algname, "to sequence", algseq algseq += DFJetAlgs[algname] return DFJetAlgs[algname] if not jetname in jtm.tools: finderTool = jtm.addJetFinder(jetname, "AntiKt", 1.0, "truthwz", ptmin=40000, overwrite=True, warnIfDuplicate=False) from JetRec.JetRecConf import JetAlgorithm alg = JetAlgorithm(algname, Tools=[finderTool]) print " Added", algname, "to sequence", algseq algseq += alg DFJetAlgs[algname] = alg
def setupTauJVFTool(): from AthenaCommon.AppMgr import ToolSvc """ #Configures tau track selector tool for TJVA from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetDetailedTrackSelectorTool InDetTrackSelectorToolForTJVA = InDet__InDetDetailedTrackSelectorTool(name = sPrefix + 'InDetTrackSelectorToolForTJVA', pTMin = 1000., IPd0Max = 9999.*mm, IPz0Max = 9999.*mm, nHitPix = 2, # PixelHits + PixelDeadSensors nHitSct = 0, # SCTHits + SCTDeadSensors nHitSi = 7, # PixelHits + SCTHits + PixelDeadSensors + SCTDeadSensors fitChi2OnNdfMax = 99999, TrackSummaryTool = None, Extrapolator = getAtlasExtrapolator()) ToolSvc += InDetTrackSelectorToolForTJVA """ from JetRec.JetRecConf import JetAlgorithm jetTrackAlg = JetAlgorithm(sPrefix+"JetTrackAlg_forTaus") """ from JetRecTools.JetRecToolsConf import JetTrackSelectionTool ToolSvc += JetTrackSelectionTool(InputContainer = _DefaultTrackContainer, OutputContainer="JetSelectedTracks_forTaus", Selector=InDetTrackSelectorToolForTJVA, OutputLevel=2 # what is about ptmin, eta min/max??? ) """ from JetRecTools.JetRecToolsConf import TrackVertexAssociationTool ToolSvc += TrackVertexAssociationTool(TrackParticleContainer = _DefaultTrackContainer , TrackVertexAssociation=sPrefix+"JetTrackVtxAssoc_forTaus", VertexContainer= _DefaultVertexContainer, MaxTransverseDistance = 2.5 *mm, MaxLongitudinalDistance = 2 *mm, #OutputLevel=2 ) #jetTrackAlg.Tools = [ToolSvc.JetTrackSelectionTool , ToolSvc.TrackVertexAssociationTool ] jetTrackAlg.Tools = [ToolSvc.TrackVertexAssociationTool ] from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence+=jetTrackAlg
def addPFlowJets(inputtype="EM", rsize=0.4, algseq=None, outputGroup="PFlow"): from JetRec.JetRecStandard import jtm jtm.modifiersMap["mods"] = ["jetfilter", jtm.nsubjettiness, jtm.pull] pflowName = "AntiKt" + str(int( rsize * 10)) + inputtype + "Pflow" # input : EM, EMC, LC algname = "jetalg" + pflowName OutputJets.setdefault(outputGroup, []).append(pflowName) # return if the alg is already scheduled here : if algseq is None: print "No algsequence passed! Will not schedule", algname return elif cfgKeyStore.isInInput("xAOD::JetContainer", pflowName): print "Collection ", algname, "is already in input AOD!" return elif algname in DFJetAlgs: if hasattr(algseq, algname): print " Algsequence", algseq, "already has an instance of", algname else: print " Added", algname, "to sequence", algseq algseq += DFJetAlgs[algname] return DFJetAlgs[algname] if inputtype == "EM": inputName = "empflow" elif inputtype == "EMC": inputName = "emcpflow" elif inputtype == "LC": inputName = "lcpflow" if pflowName in jtm.tools: pflowjet = jtm.tools[pflowName] else: pflowjet = jtm.addJetFinder(pflowName + "Jets", "AntiKt", rsize, inputName, "mods", ghostArea=0.01, ptmin=2000, ptminFilter=7000) from JetRec.JetRecConf import JetAlgorithm print "Adding PFlow jets : ", pflowName alg = JetAlgorithm(algname, Tools=[pflowjet]) print " Added", algname, "to sequence", algseq algseq += alg DFJetAlgs[algname] = alg return alg
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
def buildGenericGroomAlg(jetalg, rsize, inputtype, groomedName, jetToolBuilder, includePreTools=False, algseq=None, outputGroup="CustomJets"): algname = "jetalg" + groomedName # add these groomed jets to the output (use setdefault() to constuct the list if not existing yet) OutputJets.setdefault(outputGroup, []).append(groomedName + "Jets") # return if the alg is already scheduled here : if algseq is None: print "No algsequence passed! Will not schedule", algname return elif cfgKeyStore.isInInput("xAOD::JetContainer", groomedName): print "Collection ", algname, "is already in input AOD!" return elif algname in DFJetAlgs: if hasattr(algseq, algname): print " Algsequence", algseq, "already has an instance of", algname else: print " Added", algname, "to sequence", algseq algseq += DFJetAlgs[algname] return DFJetAlgs[algname] from JetRec.JetRecUtils import buildJetContName ungroomedname = buildJetContName(jetalg, rsize, inputtype) # 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) # 2nd step run the trimming alg. We can re-use the original largeR jet since we reassociated the PseudoJet already. fatjet_trim = jetToolBuilder(groomedName + "Jets", ungroomedname) from JetRec.JetRecConf import JetAlgorithm if includePreTools: # enable track ghost association and JVF jetalgTools = [jtm.tracksel, jtm.tvassoc] + jetalgTools alg = JetAlgorithm(algname, Tools=jetalgTools + [fatjet_trim]) DFJetAlgs[algname] = alg print " Added", algname, "to sequence", algseq algseq += alg return alg
def getTVATool(): _name = sPrefix + 'TVATool' if _name in cached_instances: return cached_instances[_name] from JetRecTools.JetRecToolsConf import TrackVertexAssociationTool TVATool = TrackVertexAssociationTool( "TVATool_forDiTaus", TrackParticleContainer="InDetTrackParticles", TrackVertexAssociation="JetTrackVtxAssoc_forDiTaus", VertexContainer="PrimaryVertices", MaxTransverseDistance=2.5, # in mm MaxLongitudinalDistance=2 # in mm ) from AthenaCommon.AppMgr import ToolSvc ToolSvc += TVATool from JetRec.JetRecConf import JetAlgorithm jetTrackAlg = JetAlgorithm(name=_name) jetTrackAlg.Tools = [TVATool] cached_instances[_name] = jetTrackAlg return jetTrackAlg
def addPhysValAODContent(algseq, doJets, doTopoCluster): ''' Schedule the addition of collections needed for validation of primary xAODs: AntiKt4TruthJets and LC/EMOriginTopoClusters ''' logger.info( '****************** Adding content for AOD PhysVal *****************') # Check some flags for steering from RecExConfig.AutoConfiguration import IsInInputFile requiresTruthJets = IsInInputFile( 'xAOD::TruthParticleContainer', 'TruthParticles') and not IsInInputFile('xAOD::JetContainer', 'AntiKt4TruthJets') requiresLCOriginTC = not IsInInputFile('xAOD::CaloClusterContainer', 'LCOriginTopoClusters') requiresEMOriginTC = not IsInInputFile('xAOD::CaloClusterContainer', 'EMOriginTopoClusters') jettools_PhysVal = [] # Truth jets if doJets and requiresTruthJets: jettools_PhysVal += addAntiKt4TruthJets(algseq) # Origin-corrected topoclusters if doTopoCluster and (requiresLCOriginTC or requiresEMOriginTC): jettools_PhysVal += addOriginCorrectedClusters(algseq, requiresLCOriginTC, requiresEMOriginTC) # Only add the algorithm if there is a need for it if jettools_PhysVal: from JetRec.JetRecStandard import jtm from JetRec.JetRecConf import JetToolRunner jtm += JetToolRunner( "jetrun_PhysVal", EventShapeTools=[], Tools=jettools_PhysVal, Timer=0 # No timing information ) from JetRec.JetRecConf import JetAlgorithm algseq += JetAlgorithm("jetalgPhysVal", Tools=[jtm.jetrun_PhysVal]) logger.info( '****************** Done *****************')
def addCopyJet(FTAG5Seq, ToolSvc, InputJetCollectionName, OutputJetCollectionName, **options): doShallowCopy = options.pop("ShallowCopy", False) from JetRec.JetRecConf import JetRecTool jetrec = JetRecTool(name="JetRecTool_CopyJet_%s_%s" % (InputJetCollectionName, OutputJetCollectionName), OutputContainer=OutputJetCollectionName, InputContainer=InputJetCollectionName, ShallowCopy=doShallowCopy, **options) ToolSvc += jetrec FTAG5Seq += JetAlgorithm( name="JetAlgorithm_CopyJet_%s_%s" % (InputJetCollectionName, OutputJetCollectionName), Tools=[jetrec], ) return OutputJetCollectionName
def setupTJVFTool(): from AthenaCommon.AppMgr import ToolSvc from JetRec.JetRecConf import JetAlgorithm jetTrackAlg = JetAlgorithm("JetTrackAlg_forDiTaus") from JetRecTools.JetRecToolsConf import TrackVertexAssociationTool TVATool = TrackVertexAssociationTool( "TVATool_forDiTaus", TrackParticleContainer="InDetTrackParticles", TrackVertexAssociation="JetTrackVtxAssoc_forDiTaus", VertexContainer="PrimaryVertices", MaxTransverseDistance=2.5, # in mm MaxLongitudinalDistance=2 # in mm ) ToolSvc += TVATool jetTrackAlg.Tools += [TVATool] from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += jetTrackAlg
def buildTOPQCA15jets(algseq): if not cfgKeyStore.isInInput("xAOD::JetContainer", "CamKt15LCTopoJets"): from JetRec.JetRecConf import JetAlgorithm jtm.modifiersMap["lctopoCA15"] = list(jtm.modifiersMap["lctopo"]) if globalflags.DataSource() == 'geant4': jtm.modifiersMap["lctopoCA15"].remove('truthassoc') if hasattr(jtm, "CamKt15LCTopoJets"): TOPQCA15LC = getattr(jtm, "CamKt15LCTopoJets") else: TOPQCA15LC = jtm.addJetFinder("CamKt15LCTopoJets", "CamKt", 1.5, "lctopo", "lctopoCA15", ghostArea=0.01, ptmin=2000, ptminFilter=100000, calibOpt="aro") if not hasattr(algseq, "jetalgCamKt15LCTopo"): TOPQCA15LCalg = JetAlgorithm("jetalgCamKt15LCTopo", Tools=[TOPQCA15LC]) algseq += TOPQCA15LCalg print("Running jet finding algorithm for CamKt15LCTopoJets")
def addCopyJets(NewJetCollectionName, OldJetCollectionName, algseq=None, outputGroup="JetCopy", mods=[], doShallow=False): algname = "CopyJets_%s_%s" % (OldJetCollectionName, NewJetCollectionName) if algseq is None: print "No algsequence passed! Will not schedule", algname return jetcopytool = jtm.addJetCopier(NewJetCollectionName, OldJetCollectionName, mods, shallow=doShallow) from JetRec.JetRecConf import JetAlgorithm alg = JetAlgorithm(algname, Tools=[jetcopytool]) print " Added", algname, "to sequence", algseq algseq += alg DFJetAlgs[algname] = alg OutputJets.setdefault(outputGroup, []).append(NewJetCollectionName)
def addStandardJets(jetalg, rsize, inputtype, ptmin=2000, ptminFilter=5000, mods="calib", calibOpt="none", ghostArea=0.01, algseq=None, outputGroup="CustomJets", exclusiveSubjetBuilderList=[], **extraOptions): ############################################### # supported options in extraOptions: # jetnamebase # variableRMinRadius # variableRMassScale ############################################### # "jetnamebase" can be configured through extraOptions if 'jetnamebase' not in extraOptions.keys(): jetnamebase = "{0}{1}{2}".format(jetalg, int(rsize * 10), inputtype) else: jetnamebase = extraOptions['jetnamebase'] jetname = jetnamebase + "Jets" algname = "jetalg" + jetnamebase OutputJets.setdefault(outputGroup, []).append(jetname) # exclusive kt subjet builder list if type(mods) is str: mods = jtm.modifiersMap[mods] for exclusiveSubjetBuilder in exclusiveSubjetBuilderList: (subjetfinder, SubjetContainerName) = exclusiveSubjetBuilder(jetname) mods += [subjetfinder] # add subjet container to the output OutputJets.setdefault(outputGroup, []).append(SubjetContainerName) # return if the alg is already scheduled here : if algseq is None: print "No algsequence passed! Will not schedule", algname return elif cfgKeyStore.isInInput("xAOD::JetContainer", jetname): print "Collection ", algname, "is already in input AOD!" return elif algname in DFJetAlgs: if hasattr(algseq, algname): print " Algsequence", algseq, "already has an instance of", algname else: print " Added", algname, "to sequence", algseq algseq += DFJetAlgs[algname] return DFJetAlgs[algname] if not jetname in jtm.tools: # Set default for the arguments to be passd to addJetFinder finderArgs = dict(modifiersin=[], consumers=[]) finderArgs['ptmin'] = ptmin finderArgs['ptminFilter'] = ptminFilter finderArgs['ghostArea'] = ghostArea # configs for variable-R if ("variableRMinRadius" in extraOptions.keys()) and ("variableRMassScale" in extraOptions.keys()): print 'INFO: You are running varaible-R jets!' finderArgs['variableRMinRadius'] = extraOptions[ 'variableRMinRadius'] finderArgs['variableRMassScale'] = extraOptions[ 'variableRMassScale'] # no container exist. simply build a new one. if inputtype == "LCTopo": finderArgs['modifiersin'] = mods finderArgs['calibOpt'] = "none" else: # be careful here -- when inputtype is not "LCTopo", many modifers in "calib" will not work # therefore, it is highly recommended to set mods=[], or something that you know that will work with non-calo type jet print 'Warning! Make sure you know what you are doing!' print 'Running addStandardJets for', jetname print 'Here is a list of modifiers:', mods finderArgs['modifiersin'] = mods #finderArgs.pop('modifiersin') # leave the default modifiers. # map the input to the jtm code for PseudoJetGetter getterMap = dict(LCTopo='lctopo', Truth='truth', TruthWZ='truthwz', PV0Track='pv0track') # create the finder for the temporary collection. finderTool = jtm.addJetFinder( jetname, jetalg, rsize, getterMap[inputtype], **finderArgs # pass the prepared arguments ) from JetRec.JetRecConf import JetAlgorithm alg = JetAlgorithm(algname, Tools=[finderTool]) print " Added", algname, "to sequence", algseq algseq += alg DFJetAlgs[algname] = alg
rtools += [jtm.tvassoc] rtools += jtm.jetrecs from JetRec.JetRecConf import JetToolRunner jtm += JetToolRunner("jetrun", EventShapeTools=evstools, Tools=rtools, Timer=jetFlags.timeJetToolRunner() ) jetrun = jtm.jetrun # Add the algorithm. It runs the jetrec tools. from JetRec.JetRecConf import JetAlgorithm if jetFlags.separateJetAlgs(): for t in rtools: jalg = JetAlgorithm("jetalg"+t.name()) jalg.Tools = [t] job+= jalg else: 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)
"Partons", ] if dfInputIsEVNT: # Standard truth jets # To recover jet constituents remove the last modifier. akt4 = jtm.addJetFinder("AntiKt4TruthJets", "AntiKt", 0.4, "truth", modifiersin=[ jtm.truthpartondr, jtm.partontruthlabel, jtm.removeconstit, jtm.jetdrlabeler, jtm.trackjetdrlabeler ], ptmin=5000) akt4alg = JetAlgorithm("jetalgAntiKt4TruthJets", Tools=[akt4]) DerivationFrameworkJob += akt4alg # WZ Truth Jets akt4wz = jtm.addJetFinder("AntiKt4TruthWZJets", "AntiKt", 0.4, "truthwz", ptmin=5000, modifiersin=[ jtm.truthpartondr, jtm.partontruthlabel, jtm.removeconstit ]) akt4wzalg = JetAlgorithm("jetalgAntiKt4TruthWZJets", Tools=[akt4wz]) DerivationFrameworkJob += akt4wzalg #jtm.addJetFinder("AntiKt6TruthWZJets", "AntiKt", 0.6, "truthwz", ptmin= 5000)
## Large VR truth jets jfind_largevr_truth = jtm.addJetFinder("AntiKtVR600Rmax10Rmin2TruthJets", "AntiKt", 1.0, "truth", "largevr_truth_modifiers", ghostArea=0, ptmin=40000, ptminFilter=40000, variableRMinRadius=0.2, variableRMassScale=600000, calibOpt="") from JetRec.JetRecConf import JetAlgorithm jetalg_smallvr_lctopo = JetAlgorithm("jfind_smallvr_lctopo", Tools=[jfind_smallvr_lctopo]) jetalg_largevr_lctopo = JetAlgorithm("jfind_largevr_lctopo", Tools=[jfind_largevr_lctopo]) jetalg_smallvr_track = JetAlgorithm("jfind_smallvr_track", Tools=[jfind_smallvr_track]) jetalg_mediumvr_track = JetAlgorithm("jfind_mediumvr_track", Tools=[jfind_mediumvr_track]) jetalg_largevr_track = JetAlgorithm("jfind_largevr_track", Tools=[jfind_largevr_track]) if isMC: jetalg_smallvr_truth = JetAlgorithm("jfind_smallvr_truth", Tools=[jfind_smallvr_truth]) jetalg_largevr_truth = JetAlgorithm("jfind_largevr_truth", Tools=[jfind_largevr_truth])
def other_postSystemRec(self, topSequence): """ Please seperate out this function into multiple functions """ from AthenaCommon.AppMgr import ToolSvc if self.isMC: from ParticleJetTools.ParticleJetToolsConf import CopyFlavorLabelTruthParticles from ParticleJetTools.ParticleJetToolsConf import ParticleJetDeltaRLabelTool ptypes = ["TausFinal", "BHadronsFinal", "CHadronsFinal"] for ptype in ptypes: AODFix_ctp = CopyFlavorLabelTruthParticles( "AODFix_CopyTruthTag" + ptype) AODFix_ctp.ParticleType = ptype AODFix_ctp.OutputName = "AODFix_TruthLabel" + ptype ToolSvc += AODFix_ctp AODFix_JetDeltaRLabelTool = ParticleJetDeltaRLabelTool( "AODFix_jetdrlabeler", LabelName="HadronConeExclTruthLabelID", BLabelName="ConeExclBHadronsFinal", CLabelName="ConeExclCHadronsFinal", TauLabelName="ConeExclTausFinal", BParticleCollection="AODFix_TruthLabelBHadronsFinal", CParticleCollection="AODFix_TruthLabelCHadronsFinal", TauParticleCollection="AODFix_TruthLabelTausFinal", PartPtMin=5000.0, JetPtMin=0.0, DRMax=0.3, MatchMode="MinDR") ToolSvc += AODFix_JetDeltaRLabelTool AODFix_FatJetDeltaRLabelTool = ParticleJetDeltaRLabelTool( "AODFix_fatjetdrlabeler", LabelName="HadronConeExclTruthLabelID", BLabelName="ConeExclBHadronsFinal", CLabelName="ConeExclCHadronsFinal", TauLabelName="ConeExclTausFinal", BParticleCollection="AODFix_TruthLabelBHadronsFinal", CParticleCollection="AODFix_TruthLabelCHadronsFinal", TauParticleCollection="AODFix_TruthLabelTausFinal", PartPtMin=5000.0, JetPtMin=0.0, DRMax=1.0, MatchMode="MinDR") ToolSvc += AODFix_FatJetDeltaRLabelTool AODFix_TrackJetDeltaRLabelTool = ParticleJetDeltaRLabelTool( "AODFix_trackjetdrlabeler", LabelName="HadronConeExclTruthLabelID", BLabelName="ConeExclBHadronsFinal", CLabelName="ConeExclCHadronsFinal", TauLabelName="ConeExclTausFinal", BParticleCollection="AODFix_TruthLabelBHadronsFinal", CParticleCollection="AODFix_TruthLabelCHadronsFinal", TauParticleCollection="AODFix_TruthLabelTausFinal", PartPtMin=5000.0, JetPtMin=4500.0, DRMax=0.3, MatchMode="MinDR") ToolSvc += AODFix_TrackJetDeltaRLabelTool from JetRec.JetRecConf import JetRecTool JetRecTool_AntiKt4EMTopo = JetRecTool( "AODFix_AntiKt4EMTopoJets", InputContainer="AntiKt4EMTopoJets", OutputContainer="AntiKt4EMTopoJets", JetModifiers=[ToolSvc.AODFix_jetdrlabeler]) ToolSvc += JetRecTool_AntiKt4EMTopo JetRecTool_AntiKt4LCTopo = JetRecTool( "AODFix_AntiKt4LCTopoJets", InputContainer="AntiKt4LCTopoJets", OutputContainer="AntiKt4LCTopoJets", JetModifiers=[ToolSvc.AODFix_jetdrlabeler]) ToolSvc += JetRecTool_AntiKt4LCTopo JetRecTool_AntiKt10LCTopo = JetRecTool( "AODFix_AntiKt10LCTopoJets", InputContainer="AntiKt10LCTopoJets", OutputContainer="AntiKt10LCTopoJets", JetModifiers=[ToolSvc.AODFix_fatjetdrlabeler]) ToolSvc += JetRecTool_AntiKt10LCTopo JetRecTool_AntiKt2PV0Track = JetRecTool( "AODFix_AntiKt2PV0TrackJets", InputContainer="AntiKt2PV0TrackJets", OutputContainer="AntiKt2PV0TrackJets", JetModifiers=[ToolSvc.AODFix_trackjetdrlabeler]) ToolSvc += JetRecTool_AntiKt2PV0Track JetRecTool_AntiKt3PV0Track = JetRecTool( "AODFix_AntiKt3PV0TrackJets", InputContainer="AntiKt3PV0TrackJets", OutputContainer="AntiKt3PV0TrackJets", JetModifiers=[ToolSvc.AODFix_trackjetdrlabeler]) ToolSvc += JetRecTool_AntiKt3PV0Track JetRecTool_AntiKt4PV0Track = JetRecTool( "AODFix_AntiKt4PV0TrackJets", InputContainer="AntiKt4PV0TrackJets", OutputContainer="AntiKt4PV0TrackJets", JetModifiers=[ToolSvc.AODFix_trackjetdrlabeler]) ToolSvc += JetRecTool_AntiKt4PV0Track from JetRec.JetRecConf import JetAlgorithm topSequence += JetAlgorithm( "jetalgAODFix", Tools=[ ToolSvc.AODFix_CopyTruthTagCHadronsFinal, ToolSvc.AODFix_CopyTruthTagBHadronsFinal, ToolSvc.AODFix_CopyTruthTagTausFinal, ToolSvc.AODFix_AntiKt2PV0TrackJets, ToolSvc.AODFix_AntiKt3PV0TrackJets, ToolSvc.AODFix_AntiKt4PV0TrackJets, ToolSvc.AODFix_AntiKt4EMTopoJets, ToolSvc.AODFix_AntiKt4LCTopoJets, ToolSvc.AODFix_AntiKt10LCTopoJets ]) JetCollectionList = [ 'AntiKt4EMTopoJets', 'AntiKt4LCTopoJets', 'AntiKt2TrackJets', 'AntiKt3TrackJets', 'AntiKt4TrackJets' ] SA = 'AODFix_' from BTagging.BTaggingConfiguration import getConfiguration BTagConf = getConfiguration("AODFix") BTagConf.PrefixxAODBaseName(False) BTagConf.PrefixVertexFinderxAODBaseName(False) BTagConf.doNotCheckForTaggerObstacles() from BTagging.BTaggingConf import Analysis__StandAloneJetBTaggerAlg as StandAloneJetBTaggerAlg btag = "BTagging_" AuthorSubString = [btag + name[:-4] for name in JetCollectionList] for i, jet in enumerate(JetCollectionList): try: btagger = BTagConf.setupJetBTaggerTool(ToolSvc, JetCollection=jet[:-4], AddToToolSvc=True, SetupScheme="Retag", TaggerList=[ 'IP3D', 'MV2c00', 'MV2c10', 'MV2c20', 'MV2c100', 'MV2m', 'MV2c10hp', 'MV2cl100', 'MVb' ]) jet = jet.replace("Track", "PV0Track") SAbtagger = StandAloneJetBTaggerAlg( name=SA + AuthorSubString[i].lower(), JetBTaggerTool=btagger, JetCollectionName=jet, ) topSequence += SAbtagger except AttributeError as error: print '#BTAG# --> ' + str(error) print '#BTAG# --> ' + jet print '#BTAG# --> ' + AuthorSubString[i] # MET AODFix from METReconstruction.METAssocConfig import AssocConfig, getAssociator from METReconstruction.METReconstructionConf import METBadTrackEventFilter from AthenaCommon.AlgSequence import AthSequencer METMapSequence = AthSequencer("MET_LCEM_SelectionSequence_AODFix") topSequence += METMapSequence from AthenaCommon import CfgMgr newtrkseltool = CfgMgr.InDet__InDetTrackSelectionTool( "IDTrkSel_METAssoc_AODFix", CutLevel="TightPrimary", maxZ0SinTheta=3, maxD0overSigmaD0=2) ToolSvc += newtrkseltool METMapSequence += METBadTrackEventFilter( "METBadTrackEventFilter_AODFix", TrackSelectorTool=newtrkseltool) LCtermlist = ['LCJet', 'Muon', 'Ele', 'Gamma', 'Tau', 'Soft'] LCAssociators = [ getAssociator(AssocConfig(config), suffix='AntiKt4LCTopo', doPFlow=False, trkseltool=newtrkseltool) for config in LCtermlist ] LCAssocTool = CfgMgr.met__METAssociationTool( 'MET_AssociationTool_AntiKt4LCTopo_AODFix', METAssociators=LCAssociators, METSuffix='AntiKt4LCTopo', AllowOverwrite=True, TCSignalState=1) # LC clusters ToolSvc += LCAssocTool EMtermlist = ['EMJet', 'Muon', 'Ele', 'Gamma', 'Tau', 'Soft'] EMAssociators = [ getAssociator(AssocConfig(config), suffix='AntiKt4EMTopo', doPFlow=False, trkseltool=newtrkseltool) for config in EMtermlist ] EMAssocTool = CfgMgr.met__METAssociationTool( 'MET_AssociationTool_AntiKt4EMTopo_AODFix', METAssociators=EMAssociators, METSuffix='AntiKt4EMTopo', AllowOverwrite=True, TCSignalState=0) # EM clusters ToolSvc += EMAssocTool METAssocAlg_LCEM = CfgMgr.met__METRecoAlg( name='METAssociation_LCEM_AODFix', RecoTools=[LCAssocTool, EMAssocTool]) METMapSequence += METAssocAlg_LCEM from METUtilities.METMakerConfig import getMETMakerAlg METMakerAlg_LC = getMETMakerAlg('AntiKt4LCTopo', confsuffix="_AODFix") METMakerAlg_LC.AllowOverwrite = True METMakerAlg_EM = getMETMakerAlg('AntiKt4EMTopo', confsuffix="_AODFix") METMakerAlg_EM.AllowOverwrite = True METMapSequence += METMakerAlg_LC METMapSequence += METMakerAlg_EM #Only run pflow AOD fix if input file contains AntKt4EMPFlowJets - should be the case for all samples, except HI samples from RecExConfig.ObjKeyStore import cfgKeyStore if cfgKeyStore.isInInputFile("xAOD::JetContainer", "AntiKt4EMPFlowJets"): #Now we need to rerun the particle flow jet finding #This configuration should be identical to the AntiKt4EMPflowJets configured in: #http://acode-browser2.usatlas.bnl.gov/lxr-rel20/source/atlas/Reconstruction/Jet/JetRec/share/JetRec_jobOptions.py #with the addJetFinder function (in the svn tag for 20.7) particleFlowJetFinder_AntiKt4 = CfgMgr.JetFinder( "AntiKt4EMPFlowJetsFinder_AODFix") particleFlowJetFinder_AntiKt4.JetAlgorithm = "AntiKt" particleFlowJetFinder_AntiKt4.JetRadius = 0.4 particleFlowJetFinder_AntiKt4.GhostArea = 0.01 particleFlowJetFinder_AntiKt4.PtMin = 2000 #Then we setup a jet builder to calculate the areas needed for the rho subtraction particleFlowJetBuilder_AntiKt4 = CfgMgr.JetFromPseudojet( "jblda_AODFix", Attributes=["ActiveArea", "ActiveArea4vec"]) ToolSvc += particleFlowJetBuilder_AntiKt4 particleFlowJetFinder_AntiKt4.JetBuilder = particleFlowJetBuilder_AntiKt4 ToolSvc += particleFlowJetFinder_AntiKt4 #Now we setup a JetRecTool which will use the above JetFinder particleFlowJetRecTool = CfgMgr.JetRecTool( "AntiKt4EMPFlowJets_AODFix") particleFlowJetRecTool.JetFinder = particleFlowJetFinder_AntiKt4 ToolSvc += particleFlowJetRecTool jpjretriever = CfgMgr.JetPseudojetRetriever("jpjretriever") ToolSvc += jpjretriever pflowRetriever = CfgMgr.CP__RetrievePFOTool( "pflowretriever_AODFix") ToolSvc += pflowRetriever trk_trackselloose = CfgMgr.InDet__InDetTrackSelectionTool( "trk_trackselloose_AODFix", CutLevel="Loose") ToolSvc += trk_trackselloose trackselloose = CfgMgr.JetTrackSelectionTool( "trackselloose", InputContainer="InDetTrackParticles", OutputContainer="JetSelectedTracks", Selector=trk_trackselloose) ToolSvc += trackselloose tracksel = CfgMgr.JetTrackSelectionTool( "tracksel_AODFix", InputContainer="InDetTrackParticles", OutputContainer="JetSelectedTracks_AODFix", Selector=trk_trackselloose) ToolSvc += tracksel tighttva = CfgMgr.CP__TightTrackVertexAssociationTool( "jetTighTVAtool_AODFix", dzSinTheta_cut=3, doPV=True) ToolSvc += tighttva tvassoc = CfgMgr.TrackVertexAssociationTool( "tvassoc_AODFix", TrackParticleContainer="InDetTrackParticles", TrackVertexAssociation="JetTrackVtxAssoc_AODFix", VertexContainer="PrimaryVertices", TrackVertexAssoTool=tighttva, ) ToolSvc += tvassoc # Ghost tracks. ghostScaleFactor = 1e-40 gtrackget = CfgMgr.TrackPseudoJetGetter( "gtrackget_AODFix", InputContainer=tracksel.OutputContainer, Label="GhostTrack", OutputContainer="PseudoJetGhostTracks_AODFix", TrackVertexAssociation=tvassoc.TrackVertexAssociation, SkipNegativeEnergy=True, GhostScale=ghostScaleFactor) ToolSvc += gtrackget # Muon segments gmusegget = CfgMgr.MuonSegmentPseudoJetGetter( "gmusegget_AODFix", InputContainer="MuonSegments", Label="GhostMuonSegment", OutputContainer="PseudoJetGhostMuonSegment_AODFix", Pt=1.e-20) ToolSvc += gmusegget # AntiKt2 track jets. gakt2trackget = CfgMgr.PseudoJetGetter( "gakt2trackget_AODFix", # give a unique name InputContainer="AntiKt2PV0TrackJets", # SG key Label= "GhostAntiKt2TrackJet", # this is the name you'll use to retrieve associated ghosts OutputContainer="PseudoJetGhostAntiKt2TrackJet_AODFix", SkipNegativeEnergy=True, GhostScale= ghostScaleFactor, # This makes the PseudoJet Ghosts, and thus the reco flow will treat them as so. ) ToolSvc += gakt2trackget # AntiKt3 track jets. gakt3trackget = CfgMgr.PseudoJetGetter( "gakt3trackget_AODFix", # give a unique name InputContainer="AntiKt3PV0TrackJets", # SG key Label= "GhostAntiKt3TrackJet", # this is the name you'll use to retrieve associated ghosts OutputContainer="PseudoJetGhostAntiKt3TrackJet_AODFix", SkipNegativeEnergy=True, GhostScale= ghostScaleFactor, # This makes the PseudoJet Ghosts, and thus the reco flow will treat them as so. ) ToolSvc += gakt3trackget # AntiKt4 track jets. gakt4trackget = CfgMgr.PseudoJetGetter( "gakt4trackget_AODFix", # give a unique name InputContainer="AntiKt4PV0TrackJets", # SG key Label= "GhostAntiKt4TrackJet", # this is the name you'll use to retrieve associated ghosts OutputContainer="PseudoJetGhostAntiKt4TrackJet_AODFix", SkipNegativeEnergy=True, GhostScale= ghostScaleFactor, # This makes the PseudoJet Ghosts, and thus the reco flow will treat them as so. ) ToolSvc += gakt4trackget # Truth. mctc = None truthpartcopy = None gtruthget = None gtruthgetters = [] rtools = [] rtools += [tracksel, tvassoc] if self.isMC: mctc = CfgMgr.MCTruthClassifier( name="JetMCTruthClassifier_AODFix", ParticleCaloExtensionTool="") ToolSvc += mctc truthpartcopy = CfgMgr.CopyTruthJetParticles( "truthpartcopy_AODFix", OutputName="JetInputTruthParticles_AODFix", MCTruthClassifier=mctc) ToolSvc += truthpartcopy gtruthget = CfgMgr.PseudoJetGetter( "gtruthget_AODFix", Label="GhostTruth", InputContainer=truthpartcopy.OutputName, OutputContainer="PseudoJetGhostTruth_AODFix", GhostScale=ghostScaleFactor, SkipNegativeEnergy=True, ) ToolSvc += gtruthget # Truth flavor tags. truthFlavourTags = [ "BHadronsInitial", "BHadronsFinal", "BQuarksFinal", "CHadronsInitial", "CHadronsFinal", "CQuarksFinal", "TausFinal", "WBosons", "ZBosons", "HBosons", "TQuarksFinal", "Partons", ] for ptype in truthFlavourTags: gtruthgetters.append( CfgMgr.PseudoJetGetter( "gtruthget_" + ptype + "_AODFix", InputContainer="TruthLabel" + ptype + "_AODFix", Label="Ghost" + ptype, OutputContainer="PseudoJetGhost" + ptype + "_AODFix", SkipNegativeEnergy=True, GhostScale=ghostScaleFactor, )) ToolSvc += gtruthgetters[-1] toolname = "CopyTruthTag" + ptype + "_AODFix" print "Scheduling " + toolname ptmin = 5000 if ptype == "Partons": ctp = CfgMgr.CopyTruthPartons(toolname) elif ptype in [ "WBosons", "ZBosons", "HBosons", "TQuarksFinal" ]: ctp = CfgMgr.CopyBosonTopLabelTruthParticles(toolname) ctp.ParticleType = ptype ptmin = 100000 else: ctp = CfgMgr.CopyFlavorLabelTruthParticles(toolname) ctp.ParticleType = ptype ctp.OutputName = "TruthLabel" + ptype + "_AODFix" ctp.PtMin = ptmin ToolSvc += ctp rtools.append(ctp) # build truth jet input : rtools += [truthpartcopy] jetrun = CfgMgr.JetToolRunner( "jetrun_AODFix", Tools=rtools, ) ToolSvc += jetrun #Setup a pseudojetgetter to deal with input objects empflowget = CfgMgr.PFlowPseudoJetGetter( "empflowget_AODFix", Label="EMPFlow", OutputContainer="PseudoJetEMPFlow_AODFix", RetrievePFOTool=pflowRetriever, InputIsEM=True, CalibratePFO=False, SkipNegativeEnergy=True, UseVertices=True) ToolSvc += empflowget empfgetters = [ empflowget, gtrackget, gmusegget, gakt2trackget, gakt3trackget, gakt4trackget ] if self.isMC: empfgetters += [gtruthget] + gtruthgetters particleFlowJetRecTool.PseudoJetGetters = empfgetters particleFlowJetRecTool.Overwrite = True particleFlowJetRecTool.OutputContainer = "AntiKt4EMPFlowJets" #setup calibration tools - only want to do area subtraction (as is done in Tier0) jetdefn = particleFlowJetFinder_AntiKt4.JetAlgorithm + str( int(10 * particleFlowJetFinder_AntiKt4.JetRadius + 0.1)) + empflowget.Label pflowJetCalibToolName_AODFix = "calib_" + jetdefn + "_pflow_A_AODFix" ToolSvc += CfgMgr.JetCalibrationTool( "pflowJetCalibTool_AODFix", JetCollection=jetdefn, ConfigFile="PFlowJES_September2014.config", CalibSequence="JetArea", RhoKey="Kt4EMPFlowEventShape") particleFlowJetRecTool.JetModifiers = [ ToolSvc.pflowJetCalibTool_AODFix ] #now we setup the other modifiers we need ToolSvc += CfgMgr.JetFilterTool("jetFilter_AODFix", PtMin=5000) particleFlowJetRecTool.JetModifiers += [ToolSvc.jetFilter_AODFix] #common_ungroomed_modifiers start here ToolSvc += CfgMgr.JetWidthTool("width_AODFix") particleFlowJetRecTool.JetModifiers += [ToolSvc.width_AODFix] ToolSvc += CfgMgr.JetIsolationTool( "jetisol_AODFix", IsolationCalculations=["IsoDelta:2:SumPt", "IsoDelta:3:SumPt"]) particleFlowJetRecTool.JetModifiers += [ToolSvc.jetisol_AODFix] ToolSvc += CfgMgr.KtDeltaRTool("ktdr_AODFix", JetRadius=0.4) particleFlowJetRecTool.JetModifiers += [ToolSvc.ktdr_AODFix] ToolSvc += CfgMgr.NSubjettinessTool("nsubjettiness_AODFix", Alpha=1.0) particleFlowJetRecTool.JetModifiers += [ ToolSvc.nsubjettiness_AODFix ] ToolSvc += CfgMgr.KTSplittingScaleTool("ktsplitter_AODFix") particleFlowJetRecTool.JetModifiers += [ToolSvc.ktsplitter_AODFix] ToolSvc += CfgMgr.AngularityTool("angularity_AODFix") particleFlowJetRecTool.JetModifiers += [ToolSvc.angularity_AODFix] ToolSvc += CfgMgr.DipolarityTool("dipolarity_AODFix", SubJetRadius=0.3) particleFlowJetRecTool.JetModifiers += [ToolSvc.dipolarity_AODFix] ToolSvc += CfgMgr.PlanarFlowTool("planarflow_AODFix") particleFlowJetRecTool.JetModifiers += [ToolSvc.planarflow_AODFix] ToolSvc += CfgMgr.KtMassDropTool("ktmassdrop_AODFix") particleFlowJetRecTool.JetModifiers += [ToolSvc.ktmassdrop_AODFix] ToolSvc += CfgMgr.EnergyCorrelatorTool("encorr_AODFix", Beta=1.0) particleFlowJetRecTool.JetModifiers += [ToolSvc.encorr_AODFix] ToolSvc += CfgMgr.CenterOfMassShapesTool("comshapes_AODFix") particleFlowJetRecTool.JetModifiers += [ToolSvc.comshapes_AODFix] #common_ungroomed_modifiers that are for MC only ## (JM) Now introduced an isMC flag, so can remove this suff. # #First we check if the file is MC or data using the metadata (not allowed to use reco flags om AODFix) # from AthenaCommon.AthenaCommonFlags import athenaCommonFlags # theInputFile_AODFix = athenaCommonFlags.PoolAODInput.get_Value()[0] # import PyUtils.AthFile as af # haveParticleJetTools_AODFix = False # f = af.fopen(theInputFile_AODFix) # if 'evt_type' in f.infos.keys(): # import re # if re.match(str(f.infos['evt_type'][0]), 'IS_SIMULATION') : # try: # haveParticleJetTools_AODFix = True # except: # haveParticleJetTools_AODFix = False # if haveParticleJetTools_AODFix: # ToolSvc += CfgMgr.Analysis__JetPartonTruthLabel("partontruthlabel_AODFix") # particleFlowJetRecTool.JetModifiers += [ToolSvc.partontruthlabel_AODFix] # ToolSvc += CfgMgr.Analysis__JetQuarkLabel("jetquarklabel_AODFix",McEventCollection = "TruthEvents") # ToolSvc += CfgMgr.Analysis__JetConeLabeling("truthpartondr_AODFix",JetTruthMatchTool = ToolSvc.jetquarklabel_AODFix) # particleFlowJetRecTool.JetModifiers += [ToolSvc.truthpartondr_AODFix] #This is the replacement if self.isMC: ToolSvc += CfgMgr.Analysis__JetPartonTruthLabel( "partontruthlabel_AODFix") particleFlowJetRecTool.JetModifiers += [ ToolSvc.partontruthlabel_AODFix ] ToolSvc += CfgMgr.Analysis__JetQuarkLabel( "jetquarklabel_AODFix", McEventCollection="TruthEvents") ToolSvc += CfgMgr.Analysis__JetConeLabeling( "truthpartondr_AODFix", JetTruthMatchTool=ToolSvc.jetquarklabel_AODFix) particleFlowJetRecTool.JetModifiers += [ ToolSvc.truthpartondr_AODFix ] ## end of JM modificatoin #common_ungroomed_modifiers end here # Modifiers for topo (and pflow) jets. jetens = CfgMgr.JetCaloEnergies("jetens_AODFix") ToolSvc += jetens larhvcorr = CfgMgr.JetLArHVTool("larhvcorr_AODFix") ToolSvc += larhvcorr caloqual_cluster = CfgMgr.JetCaloQualityTool( "caloqual_cluster_AODFix", TimingCuts=[5, 10], Calculations=[ "LArQuality", "N90Constituents", "FracSamplingMax", "NegativeE", "Timing", "HECQuality", "Centroid", "AverageLArQF", "BchCorrCell" ], ) ToolSvc += caloqual_cluster # Jet vertex fraction with selection. jvf = CfgMgr.JetVertexFractionTool( "jvf_AODFix", VertexContainer="PrimaryVertices", AssociatedTracks="GhostTrack", TrackVertexAssociation=tvassoc.TrackVertexAssociation, TrackSelector=trackselloose, JVFName="JVF") ToolSvc += jvf # Jet vertex tagger. jvt = CfgMgr.JetVertexTaggerTool( "jvt_AODFix", VertexContainer="PrimaryVertices", TrackParticleContainer="InDetTrackParticles", AssociatedTracks="GhostTrack", TrackVertexAssociation=tvassoc.TrackVertexAssociation, TrackSelector=trackselloose, JVTName="Jvt", K_JVFCorrScale=0.01, Z0Cut=3.0, PUTrkPtCut=30000.0) ToolSvc += jvt # Jet track info. trkmoms = CfgMgr.JetTrackMomentsTool( "trkmoms_AODFix", VertexContainer="PrimaryVertices", AssociatedTracks="GhostTrack", TrackVertexAssociation=tvassoc.TrackVertexAssociation, TrackMinPtCuts=[500, 1000], TrackSelector=trackselloose) ToolSvc += trkmoms charge = CfgMgr.JetChargeTool("charge_AODFix", K=1.0) ToolSvc += charge particleFlowJetRecTool.JetModifiers += [ jetens, larhvcorr, caloqual_cluster, jvf, jvt, trkmoms, charge ] if self.isMC: truthassoc = CfgMgr.JetPtAssociationTool( "truthassoc_AntiKt4_AODFix", InputContainer="AntiKt4TruthJets", AssociationName="GhostTruth") ToolSvc += truthassoc jetdrlabeler = CfgMgr.ParticleJetDeltaRLabelTool( "jetdrlabeler_AODFix", LabelName="HadronConeExclTruthLabelID", BLabelName="ConeExclBHadronsFinal", CLabelName="ConeExclCHadronsFinal", TauLabelName="ConeExclTausFinal", BParticleCollection="TruthLabelBHadronsFinal_AODFix", CParticleCollection="TruthLabelCHadronsFinal_AODFix", TauParticleCollection="TruthLabelTausFinal_AODFix", PartPtMin=5000.0, JetPtMin=4500.0, DRMax=0.3, MatchMode="MinDR") ToolSvc += jetdrlabeler particleFlowJetRecTool.JetModifiers += [ truthassoc, jetdrlabeler ] JetType = 'PFlowJet' PFtermlist = ['PFlowJet', 'Muon', 'Ele', 'Gamma', 'Tau', 'Soft'] newpfotool = CfgMgr.CP__RetrievePFOTool('MET_PFOTool_AODFix') ToolSvc += newpfotool PFAssociators = [ getAssociator(AssocConfig(config), suffix='AntiKt4EMPFlow', doPFlow=True, trkseltool=newtrkseltool, pfotool=newpfotool) for config in PFtermlist ] PFAssocTool = CfgMgr.met__METAssociationTool( 'MET_AssociationTool_AntiKt4EMPFlow_AODFix', METAssociators=PFAssociators, METSuffix='AntiKt4EMPFlow', AllowOverwrite=True) ToolSvc += PFAssocTool METAssocAlg_PFlow = CfgMgr.met__METRecoAlg( name='METAssociation_PFlow_AODFix', RecoTools=[PFAssocTool]) METMakerAlg_PF = getMETMakerAlg('AntiKt4EMPFlow', confsuffix="_AODFix") METMakerAlg_PF.AllowOverwrite = True #Set up our own sequence ParticleFlowJetSequence = AthSequencer( "ParticleFlowSelectionSequence") topSequence += ParticleFlowJetSequence #Add an event filter to our sequence ParticleFlowJetSequence += CfgMgr.ParticleFlowEventFilter_r207( "ParticleFlowEventFilter_r207") #Add the particle flow jet finding to our sequence ParticleFlowJetSequence += CfgMgr.JetAlgorithm( "pflowJetAlg_AODFix", Tools=[jetrun, ToolSvc.AntiKt4EMPFlowJets_AODFix]) #Add MET map builder to our sequence ParticleFlowJetSequence += METAssocAlg_PFlow #Build the reference MET container ParticleFlowJetSequence += METMakerAlg_PF
theApp.EvtMax = 1 #-------------------------------------------------------------- # Configure algorithm. #-------------------------------------------------------------- # Allow messge service more than default 500 lines. ServiceMgr.MessageSvc.infoLimit = 10000 # Full job is a list of algorithms from AthenaCommon.AlgSequence import AlgSequence job = AlgSequence() # Add the algorithm. It runs the demo tools. from JetRec.JetRecConf import JetAlgorithm job += JetAlgorithm("jetalg") jetalg = job.jetalg jetalg.OutputLevel = INFO #-------------------------------------------------------------- # Configure tools. #-------------------------------------------------------------- # Dump before reco. if 1: from JetRec.JetRecConf import JetDumper ToolSvc += JetDumper("inpdmp") inpdmp = ToolSvc.inpdmp inpdmp.ContainerName = "JetClusters" inpdmp.Detail = 1 inpdmp.MaxObject = 20
# Variable R track jets #=================================================================== from DerivationFrameworkExotics.JetDefinitions import * from JetRec.JetRecStandard import jtm FTAG5Seq = CfgMgr.AthSequencer("FTAG5Sequence") jtm.modifiersMap["smallvr_track_modifiers"] = jtm.modifiersMap["pv0track"] jtm.modifiersMap["largevr_track_modifiers"] = [jtm.ktsplitter] # (nikola: what is this used for?) jfind_smallvr_track = jtm.addJetFinder("AntiKtVR50Rmax4Rmin0TrackJets", "AntiKt", 0.4, "pv0track", "smallvr_track_modifiers", ghostArea = 0 , ptmin = 2000, ptminFilter = 7000, variableRMinRadius = 0, variableRMassScale = 50000, calibOpt = "none") from JetRec.JetRecConf import JetAlgorithm jetalg_smallvr_track= JetAlgorithm("jfind_smallvr_track", Tools = [jfind_smallvr_track]) FTAG5Seq += jetalg_smallvr_track from JetRec.JetRecConf import PseudoJetGetter jtm += PseudoJetGetter( "gvr50rmax4rmin0trackget", # give a unique name InputContainer = jetFlags.containerNamePrefix() + "AntiKtVR50Rmax4Rmin0TrackJets", # SG key Label = "GhostVR50Rmax4Rmin0TrackJet", # this is the name you'll use to retrieve ghost associated VR track jets OutputContainer = "PseudoJetGhostVR50Rmax4Rmin0TrackJet", SkipNegativeEnergy = True, GhostScale = 1.e-20, # this makes the PseudoJet Ghosts, and thus the reco flow will treat them as such ) jtm.gettersMap["lctopo"]+= [jtm.gvr50rmax4rmin0trackget] # has to happen before the trimmed jet gets clustered for the VR track jets to be ghost associated
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 buildVRJets(sequence, do_ghost, logger=None, doFlipTagger=False, training='201810'): from AthenaCommon import Logging if logger is None: logger = Logging.logging.getLogger('VRLogger') supported_trainings = ['201810', '201903'] # Check allowed trainings # Is there a better way to do this with a central DB? if training not in ['201810', '201903']: logger.warning( "WARNING: Using an unsupported training tag! This is UNDEFINED and will probably break. Please choose a training tag from" ) logger.warning(supported_trainings) from JetRec.JetRecStandard import jtm # Making Chris Happy: all VR track-jet b-tagging should have the training campaign label trainingTag = '_BTagging%s' % (training) VRJetName = "AntiKtVR30Rmax4Rmin02Track%s" % (trainingTag) VRGhostLabel = "GhostVR30Rmax4Rmin02TrackJet%s" % (trainingTag) VRJetAlg = "AntiKt" VRJetRadius = 0.4 VRJetInputs = 'pv0track' VRJetOptions = dict(ghostArea=0, ptmin=4000, variableRMinRadius=0.02, variableRMassScale=30000, calibOpt="none") # Change some options if we have do_ghost set to true. Hopefully # this will be the only VR collection in the future. if do_ghost: ghost_suffix = "GhostTag" VRJetName += ghost_suffix VRGhostLabel += ghost_suffix #========================================================== # Build VR jets #========================================================== from DerivationFrameworkJetEtMiss.ExtendedJetCommon import nameJetsFromAlg VRJetRecToolName = nameJetsFromAlg(VRJetName) VRJetAlgName = "jfind_%s" % (VRJetRecToolName) VRJetBTagName = "BTagging_%s" % (VRJetName.replace('BTagging', '')) logger.info("VR Btag name: %s" % VRJetBTagName) logger.info("VR jet name: %s" % VRJetRecToolName) from AthenaCommon.AppMgr import ToolSvc #make the btagging tool for VR jets from BTagging.BTaggingFlags import BTaggingFlags BTaggingFlags.CalibrationChannelAliases += [ "AntiKtVR30Rmax4Rmin02Track->AntiKtVR30Rmax4Rmin02Track,AntiKt4EMTopo" ] BTaggingFlags.CalibrationChannelAliases += [ "%s->AntiKtVR30Rmax4Rmin02Track,AntiKt4EMTopo" % (VRJetName) ] btag_vrjets = ConfInst.setupJetBTaggerTool( ToolSvc, JetCollection=VRJetRecToolName, AddToToolSvc=True, Verbose=True, options={ "name": VRJetBTagName.lower(), "BTagName": VRJetBTagName, "BTagJFVtxName": "JFVtx", "BTagSVName": "SecVtx", }, SetupScheme="", TaggerList=BTaggingFlags.ExpertTaggers if doFlipTagger else BTaggingFlags.StandardTaggers, TrackAssociatorName="GhostTrack" if do_ghost else "MatchedTracks", ) # add Ghost label id from ParticleJetTools.ParticleJetToolsConf import ( ParticleJetGhostLabelTool as GhostLabelTool) gl_tool = GhostLabelTool(name=VRJetRecToolName + "_GhostLabeling") ToolSvc += gl_tool from BTagging.BTaggingConfiguration import defaultTrackAssoc, defaultMuonAssoc # Slice the array - this forces a copy so that if we modify it we don't also # change the array in jtm. pseudoJetGetters = jtm.gettersMap[VRJetInputs][:] # We want to include ghost associated tracks in the pv0 tracks so that # we can use the looser ghost association criteria for b-tagging. if VRJetInputs == "pv0track": pseudoJetGetters.append(jtm["gtrackget"]) if VRJetAlgName in DFJetAlgs: logger.info("Algorithm %s already built before" % VRJetAlgName) if hasattr(sequence, VRJetAlgName): logger.info("Sequence %s already has an instance of algorithm %s" % (sequence, VRJetAlgName)) else: logger.info("Add algorithm %s to sequence %s" % (VRJetAlgName, sequence)) sequence += DFJetAlgs[VRJetAlgName] else: logger.info("Create algorithm %s" % VRJetAlgName) if hasattr(jtm, VRJetRecToolName): logger.info("JetRecTool %s is alredy in jtm.tools in sequence %s" % (VRJetRecToolName, sequence)) else: logger.info("Create JetRecTool %s" % VRJetRecToolName) #can only run trackjetdrlabeler with truth labels, so MC only mods = [defaultTrackAssoc, defaultMuonAssoc, btag_vrjets] if isMC: mods += [jtm.trackjetdrlabeler, gl_tool] jtm.addJetFinder(VRJetRecToolName, VRJetAlg, VRJetRadius, pseudoJetGetters, modifiersin=mods, ivtxin=0, **VRJetOptions) from JetRec.JetRecConf import JetAlgorithm jetalg_smallvr30_track = JetAlgorithm(VRJetAlgName, Tools=[jtm[VRJetRecToolName]]) sequence += jetalg_smallvr30_track DFJetAlgs[VRJetAlgName] = jetalg_smallvr30_track #========================================================== # Build PseudoJet Getter #========================================================== pjgettername = VRGhostLabel.lower() from DerivationFrameworkJetEtMiss.ExtendedJetCommon import nameJetsFromAlg if hasattr(jtm, pjgettername): logger.info("Found %s in jtm in sequence %s" % (pjgettername, sequence)) else: logger.info("Add %s to jtm in sequence %s" % (pjgettername, sequence)) inputContainerName = jetFlags.containerNamePrefix() + nameJetsFromAlg( VRJetName) from JetRec.JetRecConf import PseudoJetGetter jtm += PseudoJetGetter( pjgettername, # give a unique name InputContainer=inputContainerName, # SG key Label= VRGhostLabel, # this is the name you'll use to retrieve ghost associated VR track jets OutputContainer="PseudoJet" + VRGhostLabel, SkipNegativeEnergy=True, GhostScale= 1.e-20, # this makes the PseudoJet Ghosts, and thus the reco flow will treat them as such ) return VRJetName, VRGhostLabel
def linkVRJetsToLargeRJets(sequence, collection, getters): """Re-run jet finding for a jet collection using a new list of PseudoJetGetters. These PseudoJetGetters should already have been loaded into jtm. collection should be the name of the jet collection, which should already have been sequenced, so it's jet rec tool will exist in jtm. getters should be a map of PseudoJetGetters, each key being the name of the (non ghost) collection, with the value being the name of the PseudoJetGetter in jtm. Returns the name of the ungroomed collection that is the parent of 'collection' (this will be the same as 'collection' if this isn't groomed) *and* the list of ghost labels (these are the element link names). """ from JetRec.JetRecStandardToolManager import jtm import DerivationFrameworkJetEtMiss.JetCommon as JetCommon from DerivationFrameworkJetEtMiss.ExtendedJetCommon import nameJetsFromAlg logger = Logging.logging.getLogger('HbbTaggerLog') # First, retrieve the original JetRecTool - this is the one that made the # *ungroomed* jets, not the groomed ones. Ghost association is done to # ungroomed objects originalJetRecTool = getJetRecTool(collection, getParent=True) originalUngroomedName = originalJetRecTool.name() ungroomedJetAlg = originalUngroomedName if ungroomedJetAlg.endswith("Jets"): ungroomedJetAlg = ungroomedJetAlg[:-4] originalFinder = jtm[originalJetRecTool.JetFinder.getName()] originalGetters = [ jtm[g.getName()] for g in originalJetRecTool.PseudoJetGetters ] newGetters = [jtm[g] for g in getters.values()] # Next, prepare the names of the new objects we'll need from jtm comb_name = "_".join(getters.keys()) LargeRJetFindingAlg = "jfind_{0}_{1}".format(collection, comb_name).lower() LargeRJetPrefix = "{0}_{1}".format(collection, comb_name) LargeRJets = nameJetsFromAlg(LargeRJetPrefix) LinkTransferAlg = "LinkTransfer_{0}_{1}".format(collection, comb_name) # Check to see if this large R jet collection is already known to JetCommon if LargeRJetFindingAlg in JetCommon.DFJetAlgs: logger.info("Found {0} in DFJetAlgs".format(LargeRJetFindingAlg)) # Is it in our sequence? if hasattr(sequence, LargeRJetFindingAlg): logger.info( "Algorithm already exists in the input sequence. Will not " "add again") else: logger.info( "Adding algorithm into the sequence {0}".format(sequence)) sequence += JetCommon.DFJetAlgs[LargeRJetFindingAlg] else: # Check to see if the corresponding JetRecTool already exists if hasattr(jtm, LargeRJets): logger.info( "JetRecTool {0} already exists in jtm".format(LargeRJets)) else: logger.info("Create a new JetRecTool {0}".format(LargeRJets)) JetCommon.OutputJets.setdefault("CustomJets", []).append(LargeRJets) originalModifiers = [ jtm[m.getName()] for m in originalJetRecTool.JetModifiers ] jtm.addJetFinder( output=LargeRJets, alg=originalFinder.JetAlgorithm, radius=originalFinder.JetRadius, gettersin=originalGetters + newGetters, modifiersin=originalModifiers, ghostArea=0, ptmin=originalFinder.PtMin, variableRMinRadius=originalFinder.VariableRMinRadius, variableRMassScale=originalFinder.VariableRMassScale, calibOpt="none") # Note that we don't need ptminFilter as this was included in the original # list of JetModifiers logger.info( "Creating new jet algorithm {0} and adding it to sequence {1}". format(LargeRJetFindingAlg, sequence)) theJetAlg = JetAlgorithm(LargeRJetFindingAlg, Tools=[jtm[LargeRJets]]) sequence += theJetAlg JetCommon.DFJetAlgs[LargeRJetFindingAlg] = theJetAlg # Everything so far has been to create the links on a copy of the ungroomed # collection. Now we need to copy those links over to the original ungroomed # collection. from DerivationFrameworkJetEtMiss.ExtendedJetCommon import getJetExternalAssocTool, applyJetAugmentation assocTool = getJetExternalAssocTool( ungroomedJetAlg, LargeRJetPrefix, MomentPrefix='', ListOfOldLinkNames=[g.Label for g in newGetters]) applyJetAugmentation(ungroomedJetAlg, LinkTransferAlg, sequence, assocTool) return originalUngroomedName, [g.Label for g in newGetters]
#Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration # ScheduleCHSPFlowMods.py # # Teng Jian Khoo # July 2017 # # Apply PFlow p4 corrections (nPFO origin & cPFO weights) and # Charged Hadron Subtraction with jet constituent modification tools from JetRec.JetRecStandard import jtm from JetRec.JetRecConf import JetToolRunner jtm += JetToolRunner( "jetconstitCHSPFlow", EventShapeTools=[], Tools=[jtm.JetConstitSeq_PFlowCHS], ) from AthenaCommon.AlgSequence import AlgSequence job = AlgSequence() from JetRec.JetRecConf import JetAlgorithm job += JetAlgorithm("jetalgCHSPFlow", Tools=[jtm.jetconstitCHSPFlow]) from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyNeutralPFOsAlg CHSnPFOsThinAlg = ThinNegativeEnergyNeutralPFOsAlg( "ThinNegativeEnergyNCHSeutralPFOsAlg", NeutralPFOsKey="CHSNeutralParticleFlowObjects", ThinNegativeEnergyNeutralPFOs=True, StreamName='StreamAOD') job += CHSnPFOsThinAlg
def addTruthJetsIfNotExising(truth_jets_name): ''' Add algorithm to create the truth jets collection unless the collection exists already, or a truth jet finder is already running ''' from RecExConfig.AutoConfiguration import IsInInputFile # the jet collection name does not exist in the input file # add a jet finder algorithm in front of the monitoring if the algorithm # does not yet exist. if not IsInInputFile('xAOD::JetContainer', truth_jets_name): try: from AthenaCommon.Logging import logging log = logging.getLogger('InDetPhysValMonitoring/addTruthJets.py') from PyUtils.MetaReaderPeeker import convert_itemList, metadata eventdata_itemsDic = convert_itemList(layout='dict') log.info( 'DEBUG addTruthJetsIfNotExising {} not in {} [file_type={}]'. format(truth_jets_name, eventdata_itemsDic, metadata['file_type'])) if truth_jets_name in eventdata_itemsDic: return except: pass # Access the algorithm sequence: from AthenaCommon.AlgSequence import AlgSequence, AthSequencer topSequence = AlgSequence() # extract the jet finder type and main parameter import re extract_alg = re.search('^([^0-9]+)([0-9]+)TruthJets', truth_jets_name) if extract_alg != None: alg_type = extract_alg.group(1) alg_param_str = extract_alg.group(2) else: alg_type = 'AntiKt' alg_param_str = 4 jet_finder_alg_name = "jetalg" + alg_type + alg_param_str + 'TruthJets' # add the jet finder unless it exists already in the alg sequence from InDetPhysValDecoration import findAlg, findMonMan alg_pos = findAlg([jet_finder_alg_name]) if alg_pos == None: from JetRec.JetRecStandard import jtm mon_man_index = findMonMan() # configure truth jet finding ? from JetRec.JetRecFlags import jetFlags jetFlags.useTruth = True jetFlags.useTracks = False jetFlags.truthFlavorTags = [ "BHadronsInitial", "BHadronsFinal", "BQuarksFinal", "CHadronsInitial", "CHadronsFinal", "CQuarksFinal", "TausFinal", "Partons", ] # tool to create truth jet finding inputs truth_part_copy_name = 'truthpartcopy' dir(jtm) create_truth_jet_input = None if not hasattr(jtm, truth_part_copy_name): from MCTruthClassifier.MCTruthClassifierConfig import firstSimCreatedBarcode from MCTruthClassifier.MCTruthClassifierConf import MCTruthClassifier truth_classifier_name = 'JetMCTruthClassifier' if not hasattr(jtm, truth_classifier_name): from AthenaCommon.AppMgr import ToolSvc if not hasattr(ToolSvc, truth_classifier_name): truthClassifier = MCTruthClassifier( name=truth_classifier_name, barcodeG4Shift=firstSimCreatedBarcode(), ParticleCaloExtensionTool="") else: truthClassifier = getattr(ToolSvc, truth_classifier_name) truthClassifier.barcodeG4Shift = firstSimCreatedBarcode( ) jtm += truthClassifier else: truthClassifier = getattr(jtm, truth_classifier_name) truthClassifier.barcodeG4Shift = firstSimCreatedBarcode() from ParticleJetTools.ParticleJetToolsConf import CopyTruthJetParticles create_truth_jet_input = CopyTruthJetParticles( truth_part_copy_name, OutputName="JetInputTruthParticles", MCTruthClassifier=truthClassifier) jtm += create_truth_jet_input else: create_truth_jet_input = getattr(jtm, truth_part_copy_name) jet_finder_tool = jtm.addJetFinder(truth_jets_name, alg_type, float(alg_param_str) / 10., "truth", ptmin=5000) jet_tools = [] from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles jet_tools += scheduleCopyTruthParticles() jet_tools += [create_truth_jet_input] jet_tools += jtm.jetrecs # add the jet finder in front of the monitoring from JetRec.JetRecConf import JetAlgorithm from JetRec.JetRecConf import JetToolRunner jtm += JetToolRunner( "jetrun", Tools=jet_tools, EventShapeTools=[], # OutputLevel = 1, Timer=jetFlags.timeJetToolRunner()) # jet_finder_alg = JetAlgorithm(jet_finder_alg_name, jet_tools) jet_finder_alg = JetAlgorithm(jet_finder_alg_name) # jet_finder_alg.OutputLevel = 1 jet_finder_alg.Tools = [jtm.jetrun] if mon_man_index != None: topSequence.insert(mon_man_index, jet_finder_alg) else: topSequence += jet_finder_alg
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 addExKtCoM(sequence, ToolSvc, JetCollectionExCoM, nSubjets, doTrackSubJet, doGhostAssoc=False, ExGhostLabels=[ "GhostBHadronsFinal", "GhostCHadronsFinal", "GhostTrack" ], min_subjet_pt_mev=0, subjetAlgName="Kt"): if (subjetAlgName != "Kt" and subjetAlgName != "CoM"): print("WARNING: Subjet type must be Kt or CoM. Using Kt as default!") subjetAlgName = "Kt" from JetRec.JetRecStandard import jtm ExCoMJetCollection__SubJet = [] (ExCoMbbTagToolInstance, SubjetContainerName) = buildExclusiveSubjets( ToolSvc, JetCollectionExCoM, subjetAlgName, nSubjets, doGhostAssoc, doTrackSubJet, ExGhostLabels, min_subjet_pt_mev) ExCoMJetCollection__SubJet += [SubjetContainerName] excomELresetName = "ELreset_subjet_%s" % (SubjetContainerName.replace( "Jets", "")) excomELresetNameLJet = "ELreset_Large_%sjet_%s" % ( SubjetContainerName.replace( "Jets", ""), JetCollectionExCoM.replace("Jets", "")) excomAlgName = "jfind_%s" % (SubjetContainerName) excomJetRecToolName = "%s" % (SubjetContainerName) excomBTagName = "BTagging_%s" % (SubjetContainerName.replace("Jets", "")) if excomAlgName in DFJetAlgs: print(" Algorithm Ex%s " % subjetAlgName, excomAlgName, "already built before sequence ", sequence) if hasattr(sequence, excomAlgName): print(" sequence Ex%s " % subjetAlgName, sequence, "already has an instance of algorithm", excomAlgName) else: print(" Add algorithm Ex%s " % subjetAlgName, excomAlgName, "to sequence", sequence) sequence += DFJetAlgs[excomAlgName] sequence += CfgMgr.xAODMaker__ElementLinkResetAlg( excomELresetName, SGKeys=[SubjetContainerName + "Aux."]) sequence += DFJetAlgs[excomAlgName + "_btag"] sequence += CfgMgr.xAODMaker__ElementLinkResetAlg( excomELresetNameLJet, SGKeys=[JetCollectionExCoM + "Aux."]) else: print(" Algorithm Ex%s " % subjetAlgName, excomAlgName, " to be built sequence ", sequence) if hasattr(jtm, excomJetRecToolName): print(" Ex%sJetRecTool " % subjetAlgName, excomJetRecToolName, " already built sequence ", sequence) jetrec = jtm[excomJetRecToolName] else: print(" Ex%s tool " % subjetAlgName, excomJetRecToolName, " to be built sequence ", sequence) from JetRec.JetRecConf import JetRecTool jetrec = JetRecTool( name=excomJetRecToolName, OutputContainer=JetCollectionExCoM, InputContainer=JetCollectionExCoM, JetModifiers=[ExCoMbbTagToolInstance], ) jtm.add(jetrec) ToolSvc += jetrec excomJetRecBTagToolName = str("%s_sub" % excomJetRecToolName) if hasattr(jtm, excomJetRecBTagToolName): print(" Ex%sJetRecBTagTool " % subjetAlgName, excomJetRecBTagToolName, " already built sequence ", sequence) jetrec_btagging = jtm[excomJetRecBTagToolName] else: print(" Ex%sJetRecBTagTool " % subjetAlgName, excomJetRecBTagToolName, " to be built sequence ", sequence) #make the btagging tool for excom jets from BTagging.BTaggingFlags import BTaggingFlags btag_excom = ConfInst.setupJetBTaggerTool( ToolSvc, JetCollection=excomJetRecToolName.replace("Jets", ""), AddToToolSvc=True, Verbose=True, options={ "name": excomBTagName.lower(), "BTagName": excomBTagName, "BTagJFVtxName": "JFVtx", "BTagSVName": "SecVtx", }, SetupScheme="", TaggerList=BTaggingFlags.StandardTaggers, TrackAssociatorName="GhostTrack" if doGhostAssoc else "MatchedTracks") # running association + b-tagging on subjets now from BTagging.BTaggingConfiguration import comTrackAssoc, comMuonAssoc, defaultTrackAssoc, defaultMuonAssoc mods = [defaultTrackAssoc, defaultMuonAssoc, btag_excom] if (subjetAlgName == "CoM"): mods = [comTrackAssoc, comMuonAssoc, btag_excom] if isMC: mods.append(jtm.jetdrlabeler) jetrec_btagging = JetRecTool(name=excomJetRecBTagToolName, InputContainer=SubjetContainerName, OutputContainer=SubjetContainerName, JetModifiers=mods) jtm.add(jetrec_btagging) ToolSvc += jetrec_btagging jetalg_excom = JetAlgorithm( name=excomAlgName, Tools=[jetrec], ) sequence += jetalg_excom DFJetAlgs[excomAlgName] = jetalg_excom # Reset EL for ExCoM subjets after all of them are built # Otherwise crashing for CoM during TrackToJetAssociation due to failure of finding the large-R parent jet. sequence += CfgMgr.xAODMaker__ElementLinkResetAlg( excomELresetName, SGKeys=[SubjetContainerName + "Aux."]) jetalg_excom_btag = JetAlgorithm( name=excomAlgName + "_btag", Tools=[jetrec_btagging], ) sequence += jetalg_excom_btag DFJetAlgs[excomAlgName + "_btag"] = jetalg_excom_btag sequence += CfgMgr.xAODMaker__ElementLinkResetAlg( excomELresetNameLJet, SGKeys=[JetCollectionExCoM + "Aux."]) return ExCoMJetCollection__SubJet
def scheduleRTTJetTests(): global containerToRebuild from JetRec.JetRecFlags import jetFlags from RecExConfig.RecFlags import rec jetFlags.useTruth = rec.doTruth() from JetRec.JetRecStandard import jtm from JetRec.JetRecConf import JetAlgorithm from JetRec.JetRecUtils import interpretJetName from JetRec.JetRecStandardToolManager import calib_topo_ungroomed_modifiers, topo_ungroomed_modifiers #calibarg = 'calib' if jetFlags.applyCalibrationName()!="none" else None #calibarg = 'calib' if jetFlags.applyCalibrationName!= "none" else "none" # arguments to give to addJetFinder # format is 'input' : dict_of_args inputArgs = { 'LCTopo': dict( gettersin='lctopo', modifiersin='calib', ghostArea=0.01, ), 'EMTopo': dict( gettersin='emtopo', modifiersin='calib', ghostArea=0.01, ), 'ZTrack': {}, } fullnameArgs = { "AntiKt4LCTopoJetsTest": dict(ptminFilter=7000, calibOpt='ar'), "AntiKt4EMTopoJetsTest": dict(ptminFilter=5000, calibOpt='ar'), "AntiKt10LCTopoJetsTest": dict(ptminFilter=50000, calibOpt='a'), "CamKt12LCTopoJetsTest": dict(ptminFilter=50000, calibOpt='a'), } tools = [] for jname in containerToRebuild: # decompose arg name finder, mainParam, input = interpretJetName(jname) args = fullnameArgs[jname] args.update(inputArgs[input]) # call addJetFinderArgs with the relavant args for this collection t = jtm.addJetFinder(jname, finder, mainParam, ptmin=2000, **args) tools.append(t) from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() if jetFlags.useTruth: from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles tools = [jtm.truthpartcopy, jtm.truthpartcopywz ] + scheduleCopyTruthParticles() + tools topSequence += JetAlgorithm("JetAlgorithmTest", Tools=[ jtm.tracksel, jtm.tvassoc, ] + tools)
"CHadronsInitial", "CHadronsFinal", "CQuarksFinal", "TausFinal", "Partons", ] # Standard truth jets # To recover jet constituents remove the last modifier. akt4 = jtm.addJetFinder( "AntiKt4TruthJets", "AntiKt", 0.4, "truth", modifiersin=[jtm.truthpartondr, jtm.partontruthlabel, jtm.removeconstit], ptmin=5000) akt4alg = JetAlgorithm("jetalgAntiKt4TruthJets", Tools=[akt4]) DerivationFrameworkJob += akt4alg # WZ Truth Jets #jtm.addJetFinder("AntiKt4TruthWZJets", "AntiKt", 0.4, "truthwz", ptmin= 5000) #jtm.addJetFinder("AntiKt6TruthWZJets", "AntiKt", 0.6, "truthwz", ptmin= 5000) # Other jets #akt6 = jtm.addJetFinder("AntiKt6TruthJets", "AntiKt", 0.6, "truth", ptmin= 5000) #akt10 = jtm.addJetFinder("AntiKt10TruthJets", "AntiKt", 1.0, "truth", ptmin= 5000) #akt10trim = jtm.addJetTrimmer("TrimmedAntiKt10TruthJets", rclus=0.3, ptfrac=0.05, input='AntiKt10TruthJets') # Add truth-based MET algorithm here import METReconstruction.METConfig_Truth from METReconstruction.METRecoFlags import metFlags # not sure if you even need this line from METReconstruction.METRecoConfig import getMETRecoAlg metAlg = getMETRecoAlg('METReconstruction')
name="ParticleCaloCellAssociationInDet", ParticleCaloExtensionTool=ParticleToCaloExtrapolationTool, CaloClusterLocation="TimedCaloCalTopoClusters", ClustersInConeTool=CaloClustersInCone, ConeSize=0.1, UseCovariance=True) ParticleCaloCellAssociation.OutputLevel = DEBUG ToolSvc += ParticleCaloCellAssociation print ParticleCaloCellAssociation # Access the algorithm sequence: from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # Add the algorithm. jetalg = JetAlgorithm("JetAlg_OriginAndTime") jetalg.OutputLevel = INFO jetalg.Tools += [PFSequence] topSequence += jetalg from TrackParticleAssociationAlgs.TrackParticleAssociationAlgsConf import TrackParticleClusterAssociationAlg TrackParticleClusterAssociation = TrackParticleClusterAssociationAlg( name="TrackParticleClusterAssociationInDet", ParticleCaloClusterAssociationTool=ParticleCaloCellAssociation, TrackParticleContainerName="InDetTrackParticles", PtCut=400., OutputCollectionPostFix="Test", CaloClusterLocation="TimedCaloCalTopoClusters") # TrackParticleClusterAssociation.OutputLevel = DEBUG topSequence += TrackParticleClusterAssociation
from DerivationFrameworkCore.DerivationFrameworkMaster import * from DerivationFrameworkJetEtMiss.JetCommon import * from JetRec.JetRecConf import JetAlgorithm from DerivationFrameworkJetEtMiss.DFJetMetFlags import * if dfjmFlags.doJetTrackMomentFix: print "Scheduling jet track moment fix: " jtm.modifiersMap["jetmomfix"] = [jtm.trkmoms] else: print "Copying jet track moments: " jtm.modifiersMap["jetmomfix"] = [] jetmomfix_LC = jtm.addJetCopier("DFJetFix_AntiKt4LCTopoJets", "AntiKt4LCTopoJets", "jetmomfix") DerivationFrameworkJob += JetAlgorithm("jetalgDFJetFix_AntiKt4LCTopoJets", Tools = [jetmomfix_LC] ) jetmomfix_EM = jtm.addJetCopier("DFJetFix_AntiKt4EMTopoJets", "AntiKt4EMTopoJets", "jetmomfix") DerivationFrameworkJob += JetAlgorithm("jetalgDFJetFix_AntiKt4EMTopoJets", Tools = [jetmomfix_EM] ) from DerivationFrameworkJetEtMiss.DerivationFrameworkJetEtMissConf import DerivationFramework__JetDecorAlg DerivationFrameworkJob += DerivationFramework__JetDecorAlg("DecorJet_LC") DerivationFrameworkJob.DecorJet_LC.InputCollection="DFJetFix_AntiKt4LCTopoJets" DerivationFrameworkJob.DecorJet_LC.MomentsToCopy=[ "vector<int>#NumTrkPt500@NumTrkPt500_IDLoose","vector<float>#SumPtTrkPt500@SumPtTrkPt500_IDLoose","vector<float>#TrackWidthPt500@TrackWidthPt500_IDLoose", "vector<int>#NumTrkPt1000@NumTrkPt1000_IDLoose","vector<float>#SumPtTrkPt1000@SumPtTrkPt1000_IDLoose","vector<float>#TrackWidthPt1000@TrackWidthPt1000_IDLoose"] DerivationFrameworkJob += DerivationFramework__JetDecorAlg("DecorJet_EM") DerivationFrameworkJob.DecorJet_EM.InputCollection="DFJetFix_AntiKt4EMTopoJets" DerivationFrameworkJob.DecorJet_EM.MomentsToCopy=[ "vector<int>#NumTrkPt500@NumTrkPt500_IDLoose","vector<float>#SumPtTrkPt500@SumPtTrkPt500_IDLoose","vector<float>#TrackWidthPt500@TrackWidthPt500_IDLoose",