 |
ATLAS Offline Software
|
|
def | formatFilteredJetsName (jetsIn, jetPtMinGeV) |
|
def | JetRecoDataDeps (flags, **jetRecoDict) |
| Data dependency generation for the stages of jet reconstruction This is used to precompute the collections that will be generated, which can be passed as needed out to other steps. More...
|
|
def | StandardJetBuildDataDeps (flags, **jetRecoDict) |
|
def | StandardJetRecoDataDeps (flags, **jetRecoDict) |
|
def | ReclusteredJetRecoDataDeps (flags, **jetRecoDict) |
|
def | GroomedJetRecoDataDeps (flags, **jetRecoDict) |
|
def | JetRecoCfg (flags, **jetDefDict) |
| Configuration of the HLT jet reconstruction Takes as input the dictionaries of JetDefs from the data dependency generators above. More...
|
|
def | JetViewAlgCfg (flags, jetDef, jetPtMinGeV=JET_DEFAULT_VIEW_PT_MIN_GEV) |
|
def | StandardJetBuildCfg (flags, jetDef) |
|
def | StandardJetRecoCfg (flags, **jetDefDict) |
|
def | GroomedJetRecoCfg (flags, **jetDefDict) |
|
def | ReclusteredJetRecoCfg (flags, **jetDefDict) |
|
def | FastFtaggedJetCopyAlgCfg (flags, jetDef) |
|
def | JetRoITrackJetTagSequenceCfg (flags, jetsIn, trkopt, RoIs) |
|
◆ FastFtaggedJetCopyAlgCfg()
def python.HLT.Jet.JetRecoSequencesConfig.FastFtaggedJetCopyAlgCfg |
( |
|
flags, |
|
|
|
jetDef |
|
) |
| |
Definition at line 585 of file JetRecoSequencesConfig.py.
588 jetsIn = jetDef.fullname()
590 ftagJetDef = jetDef.clone(suffix=jetDef.suffix+
'_fastftag',modifiers=[],lock=
True)
592 acc.addEventAlgo(JetRecConfig.getJetCopyAlg(jetsin=jetsIn,jetsoutdef=ftagJetDef,decorations=decorList))
593 return acc, ftagJetDef
◆ formatFilteredJetsName()
def python.HLT.Jet.JetRecoSequencesConfig.formatFilteredJetsName |
( |
|
jetsIn, |
|
|
|
jetPtMinGeV |
|
) |
| |
◆ GroomedJetRecoCfg()
def python.HLT.Jet.JetRecoSequencesConfig.GroomedJetRecoCfg |
( |
|
flags, |
|
|
** |
jetDefDict |
|
) |
| |
Create the groomed jets
First the ungroomed jets are created (using the standard configuration), then the grooming
is applied
Definition at line 481 of file JetRecoSequencesConfig.py.
482 """ Create the groomed jets
484 First the ungroomed jets are created (using the standard configuration), then the grooming
490 ungroomedJetsName, ungroomedDef = jetDefDict[
'ungroomed']
491 groomedJets, groomDef = jetDefDict[
'groomed']
494 seqname =
"JetGroomSeq_"+jetDefStr
496 acc.addSequence(
parOR(seqname),primary=
True)
502 acc.merge(build_acc,seqname)
504 groom_extraoutputs = []
505 if '_ftf' in jetDefStr:
506 groom_extraoutputs.append((
'xAOD::JetContainer',f
'{groomedJets}.GhostTrack_ftf'))
507 acc.addEventAlgo( JetRecConfig.getJetRecGroomAlg(
510 extraOutputs=groom_extraoutputs,
515 recoAlg, constitType, _ = jetDefStr.split(
'_',2)
519 groomDef.basename.startswith(
"AntiKt10EMPFlowCSSKSoftDrop")
520 and jetCalib==jetCalibDef
522 trackingColls = groomDef._contextDic
524 ftagseqname = f
"jetFtagSeq_{groomDef.context}_largeR"
525 acc.addSequence(
parOR(ftagseqname), seqname)
531 trackingColls[
'Vertices'],
532 trackingColls[
'Tracks'],
534 doXbbtagLargeRJet =
True,
◆ GroomedJetRecoDataDeps()
def python.HLT.Jet.JetRecoSequencesConfig.GroomedJetRecoDataDeps |
( |
|
flags, |
|
|
** |
jetRecoDict |
|
) |
| |
Definition at line 225 of file JetRecoSequencesConfig.py.
229 recoAlg=jetRecoDict[
"recoAlg"].rstrip(
"tsd"),
231 jetCalib =
"nojcalib",
235 ungroomedJetsName, ungroomedDef = jetDefDict[
'build']
238 groomedJetsName = groomDef.fullname()
240 groomDef.modifiers += [
247 return {
'ungroomed':(ungroomedJetsName, ungroomedDef),
'groomed':(groomedJetsName, groomDef)}
◆ JetRecoCfg()
def python.HLT.Jet.JetRecoSequencesConfig.JetRecoCfg |
( |
|
flags, |
|
|
** |
jetDefDict |
|
) |
| |
Configuration of the HLT jet reconstruction Takes as input the dictionaries of JetDefs from the data dependency generators above.
The top-level sequence
Forwards arguments to the standard jet reco, grooming or reclustering sequences.
Definition at line 254 of file JetRecoSequencesConfig.py.
255 """The top-level sequence
257 Forwards arguments to the standard jet reco, grooming or reclustering sequences.
260 if 'reclustered' in jetDefDict:
264 elif 'groomed' in jetDefDict:
◆ JetRecoDataDeps()
def python.HLT.Jet.JetRecoSequencesConfig.JetRecoDataDeps |
( |
|
flags, |
|
|
** |
jetRecoDict |
|
) |
| |
Data dependency generation for the stages of jet reconstruction This is used to precompute the collections that will be generated, which can be passed as needed out to other steps.
Definition at line 56 of file JetRecoSequencesConfig.py.
60 if jetRecoDict[
'ionopt']
in [
'ion',
'ionp']:
68 jetDefDict[
'final'] = jetDefDict[
'reclustered']
69 elif extra
in [
"t",
"sd"]:
73 jetDefDict[
'final'] = jetDefDict[
'groomed']
78 jetDefDict[
'final'] = jetDefDict[
'calib']
82 assert jetRecoDict[
'jetDefStr'] == gen_jetDefStr, (
83 f
"Expected jetDefStr {jetRecoDict['jetDefStr']} from reco dict, generated {gen_jetDefStr}"
◆ JetRoITrackJetTagSequenceCfg()
def python.HLT.Jet.JetRecoSequencesConfig.JetRoITrackJetTagSequenceCfg |
( |
|
flags, |
|
|
|
jetsIn, |
|
|
|
trkopt, |
|
|
|
RoIs |
|
) |
| |
◆ JetViewAlgCfg()
def python.HLT.Jet.JetRecoSequencesConfig.JetViewAlgCfg |
( |
|
flags, |
|
|
|
jetDef, |
|
|
|
jetPtMinGeV = JET_DEFAULT_VIEW_PT_MIN_GEV |
|
) |
| |
Definition at line 278 of file JetRecoSequencesConfig.py.
278 def JetViewAlgCfg(flags,jetDef,jetPtMinGeV=JET_DEFAULT_VIEW_PT_MIN_GEV):
281 filteredJetsName = f
"{jetDef.fullname()}_pt{int(jetPtMinGeV)}"
284 CompFactory.JetViewAlg(
285 "jetview_"+filteredJetsName,
286 InputContainer=jetDef.fullname(),
287 OutputContainer=filteredJetsName,
288 PtMin=jetPtMinGeV*1e3,
◆ ReclusteredJetRecoCfg()
def python.HLT.Jet.JetRecoSequencesConfig.ReclusteredJetRecoCfg |
( |
|
flags, |
|
|
** |
jetDefDict |
|
) |
| |
Create the reclustered jets
First the input jets are built, then the reclustering algorithm is run
Definition at line 541 of file JetRecoSequencesConfig.py.
542 """ Create the reclustered jets
544 First the input jets are built, then the reclustering algorithm is run
547 basicJetsFiltered, basicJetDef = jetDefDict[
'calib']
548 rcJets, rcJetDef = jetDefDict[
'reclustered']
551 seqname =
"JetReclusterSeq_"+jetDefStr
553 acc.addSequence(
parOR(seqname),primary=
True)
558 acc.merge(basic_acc,seqname)
564 jetPtMinGeV=rcJetPtMin,
566 acc.merge(jetViewAcc,seqname)
568 rcConstitPJAlg = JetRecConfig.getConstitPJGAlg(rcJetDef.inputdef, suffix=jetDefStr)
569 acc.addEventAlgo(rcConstitPJAlg,seqname)
572 JetRecConfig.getJetRecAlg(
575 f
"HLTJets/{rcJetDef.fullname()}/"
◆ ReclusteredJetRecoDataDeps()
def python.HLT.Jet.JetRecoSequencesConfig.ReclusteredJetRecoDataDeps |
( |
|
flags, |
|
|
** |
jetRecoDict |
|
) |
| |
Definition at line 192 of file JetRecoSequencesConfig.py.
200 flags, **basicJetRecoDict
202 basicJetsName, basicJetDef = jetDefDict[
'calib']
206 rc_suffix = f
"_{jetRecoDict['jetCalib']}" + (f
"_{jetRecoDict['trkopt']}" if doTracking(jetRecoDict)
else "")
211 basicJetDef.inputdef.label,
216 rcConstitPJKey = JetRecConfig.getPJContName(rcJetDef.inputdef, suffix=jetRecoDict[
'jetDefStr'])
217 rcJetDef._internalAtt[
"finalPJContainer"] = rcConstitPJKey
220 rcJetsOut = rcJetDef.fullname()
221 jetDefDict[
'reclustered'] = (rcJetsOut, rcJetDef)
◆ StandardJetBuildCfg()
def python.HLT.Jet.JetRecoSequencesConfig.StandardJetBuildCfg |
( |
|
flags, |
|
|
|
jetDef |
|
) |
| |
Standard jet reconstruction, no reclustering or grooming
The clusters (and tracks, if necessary) should be built beforehand,
but this config will build the PFOs if they are needed.
The reconstruction is configured from the input JetDefinition
Definition at line 297 of file JetRecoSequencesConfig.py.
298 """ Standard jet reconstruction, no reclustering or grooming
300 The clusters (and tracks, if necessary) should be built beforehand,
301 but this config will build the PFOs if they are needed.
303 The reconstruction is configured from the input JetDefinition
307 trackColls = jetDef._contextDic
309 seqname =
"JetBuildSeq_"+jetDefStr
311 acc.addSequence(
parOR(seqname),primary=
True)
314 if 'PFlow' in jetDef.inputdef.label:
315 from eflowRec.PFHLTConfig
import PFCfg
317 clustersKey = jetDef.inputdef.prereqs[0].
split(
':')[1]
322 clustersin=clustersKey,
324 tracksin=trackColls[
"Tracks"],
325 verticesin=trackColls[
"Vertices"],
331 alg = JetRecConfig.getConstitModAlg(
332 jetDef, jetDef.inputdef,
337 acc.addEventAlgo(alg,seqname)
339 pj_alg = JetRecConfig.getConstitPJGAlg(jetDef.inputdef)
340 acc.addEventAlgo(pj_alg,seqname)
342 jra_extra_outputs = []
343 if jetDef.context==
'ftf':
344 pj_name = pj_alg.OutputContainer.Path
346 merge_alg = CompFactory.PseudoJetMerger(
347 f
"PJMerger_{pj_name}MergedWithGhostTracks",
348 InputPJContainers=[pj_name, trackColls[
"GhostTracks"]],
349 OutputContainer=f
"{pj_name}MergedWithGhostTracks",
351 jra_extra_outputs.append((
'xAOD::JetContainer',f
"{jetDef.fullname()}.{trackColls['GhostTracksLabel']}"))
353 acc.addEventAlgo(merge_alg,seqname)
356 JetRecConfig.getJetRecAlg(
359 extraOutputs=jra_extra_outputs,
◆ StandardJetBuildDataDeps()
def python.HLT.Jet.JetRecoSequencesConfig.StandardJetBuildDataDeps |
( |
|
flags, |
|
|
** |
jetRecoDict |
|
) |
| |
Jet clustering step -- generally only called through StandardJetRecoDataDeps
Definition at line 89 of file JetRecoSequencesConfig.py.
90 """Jet clustering step -- generally only called through StandardJetRecoDataDeps"""
92 trkopt = jetRecoDict[
'trkopt']
100 pfoPrefix=f
"HLT_{trkopt}",
105 jetDef.inputdef.prereqs = [f
'extinput:{clustersKey}']
110 clustersKey=clustersKey,
117 "ConstitFourMom_copy",
119 if jetRecoDict[
"recoAlg"] ==
"a4":
120 jetDef.modifiers += [
"CaloEnergies"]
122 jetDef.modifiers += [
"CaloEnergiesClus"]
124 jetDef.modifiers += [
"TrackMoments",
"JVF",
"JVT",
"NNJVT_TrkAugV1"]
126 pj_name = JetRecConfig.getPJContName(jetDef.inputdef)
128 pj_name = f
"{pj_name}MergedWithGhostTracks"
129 jetDef._internalAtt[
"finalPJContainer"] = pj_name
131 jetsOut = jetDef.fullname()
135 return {
'build': (jetsOut, jetDef)}
◆ StandardJetRecoCfg()
def python.HLT.Jet.JetRecoSequencesConfig.StandardJetRecoCfg |
( |
|
flags, |
|
|
** |
jetDefDict |
|
) |
| |
Full reconstruction for 'simple' (ungroomed, not reclustered) jets
First the uncalibrated jets are built, then (if necessary) the calibrated jets are provided
as a shallow copy.
Definition at line 367 of file JetRecoSequencesConfig.py.
368 """ Full reconstruction for 'simple' (ungroomed, not reclustered) jets
370 First the uncalibrated jets are built, then (if necessary) the calibrated jets are provided
374 jetsOut, jetDef = jetDefDict[
'calib']
376 seqname =
"JetRecSeq_"+jetDefStr
379 if jetDef.suffix[1:] ==
"nojcalib":
382 reco_acc.addSequence(
parOR(seqname))
384 buildJets, buildJetDef = jetDefDict[
'build']
388 reco_acc.merge(build_acc, seqname)
395 jetPtMinGeV=JET_DEFAULT_VIEW_PT_MIN_GEV,
397 reco_acc.merge(jetViewAcc, seqname)
402 acc.addSequence(
parOR(seqname))
404 buildJets, buildJetDef = jetDefDict[
'build']
408 acc.merge(build_acc,seqname)
410 jetsNoCalib, jetDefNoCalib = jetDefDict[
'nojcalib']
414 jetPtMinGeV=JET_DEFAULT_VIEW_PT_MIN_GEV,
416 acc.merge(jetViewAcc, seqname)
421 if "sub" in jetCalib:
424 eventShapeAlg = JetInputConfig.buildEventShapeAlg(jetDef,
getHLTPrefix(),voronoiRf = 1.0 )
425 acc.addEventAlgo(eventShapeAlg,seqname)
432 JetRecConfig.getJetCopyAlg(
433 jetsin=jetDefNoCalib.fullname(),
435 decorations=decorList,
437 f
"HLTJets/{jetDef.fullname()}/"
444 recoAlg, constitType, _ = jetDefStr.split(
'_',2)
447 flags.Trigger.Jet.fastbtagPFlow
448 and jetDef.basename==
"AntiKt4EMPFlow"
449 and jetCalib==jetCalibDef
452 ftagseqname = f
"jetFtagSeq_{jetDef.context}"
453 acc.addSequence(
parOR(ftagseqname),seqname)
455 trackingColls = jetDef._contextDic
462 trackingColls[
"Vertices"],
463 trackingColls[
"Tracks"],
474 jetPtMinGeV=JET_DEFAULT_VIEW_PT_MIN_GEV,
476 acc.merge(jetViewAcc,seqname)
◆ StandardJetRecoDataDeps()
def python.HLT.Jet.JetRecoSequencesConfig.StandardJetRecoDataDeps |
( |
|
flags, |
|
|
** |
jetRecoDict |
|
) |
| |
Jet clustering + calibration (via shallow copy)
Definition at line 138 of file JetRecoSequencesConfig.py.
139 """Jet clustering + calibration (via shallow copy)"""
140 if jetRecoDict[
"jetCalib"] ==
"nojcalib":
145 jetsNoCalib, jetDef = jetDefDict[
'build']
149 jetDefDict.update({
'nojcalib': (jetsNoCalibFiltered, jetDef),
'calib': (jetsNoCalibFiltered, jetDef)})
160 jetsNoCalib, jetDefNoCalib = jetDefDict[
'build']
163 jetDef = jetDefNoCalib.clone()
164 jetDef.suffix = jetDefNoCalib.suffix.replace(
"nojcalib", jetRecoDict[
"jetCalib"])
166 if "sub" in jetRecoDict[
"jetCalib"]:
173 is_pflow =
isPFlow(jetRecoDict)
175 jetDef.modifiers =
getCalibMods(flags, jetRecoDict, rhoKey)
177 jetDef.modifiers += [
"JVT",
"NNJVT_TrkAugV1"]
179 if jetRecoDict[
"recoAlg"] ==
"a4":
180 jetDef.modifiers += [
"CaloQuality"]
182 if not is_pflow
and jetRecoDict[
"recoAlg"] ==
"a4":
183 from TriggerMenuMT.HLT.Jet.JetRecoCommon
import cleaningDict
184 jetDef.modifiers += [f
'Cleaning:{clean_wp}' for _,clean_wp
in cleaningDict.items()]
189 jetDefDict.update({
'nojcalib':(jetsViewNoCalib, jetDefNoCalib),
'calib':(jetsOut, jetDef)})
def formatFilteredJetsName(jetsIn, jetPtMinGeV)
def JetRoITrackJetTagSequenceCfg(flags, jetsIn, trkopt, RoIs)
def defineGroomedJets(jetRecoDict, ungroomedDef)
def fastFlavourTaggingCfg(flags, inputJets, inputVertex, inputTracks, isPFlow=False, fastDipsMinimumPt=None, doXbbtagLargeRJet=False)
def getMonTool_Algorithm(flags, path)
def ReclusteredJetRecoCfg(flags, **jetDefDict)
def jetCalibFromJetDef(jetDef)
def JetRecoCfg(flags, **jetDefDict)
Configuration of the HLT jet reconstruction Takes as input the dictionaries of JetDefs from the data ...
def JetRoITrackingCfg(flags, jetsIn, trkopt, RoIs)
def doFSTracking(jetRecoDict)
def getClustersKey(recoDict)
def JetRecoDataDeps(flags, **jetRecoDict)
Data dependency generation for the stages of jet reconstruction This is used to precompute the collec...
def getCalibMods(flags, jetRecoDict, rhoKey="auto")
— Modifier and decoration list getters —
def cloneAndUpdateJetRecoDict(jetRecoDict, **kwargs)
def GroomedJetRecoDataDeps(flags, **jetRecoDict)
def getMonTool_TrigJetAlgorithm(flags, path)
def getEventShapeName(defOrLabel, nameprefix="", suffix=None, radius=0.4)
def jetDefToString(jetDef)
— Interpreting JetDefinition —
def StandardJetBuildCfg(flags, jetDef)
def defineReclusteredJets(jetRecoDict, smallRjets, inputlabel, prefix, suffix)
def getJetCalibDefaultString(recoAlg, constitType, trkopt)
def StandardJetRecoDataDeps(flags, **jetRecoDict)
def FastFtaggedJetCopyAlgCfg(flags, jetDef)
def solveDependencies(jetdef0, flags)
def StandardJetBuildDataDeps(flags, **jetRecoDict)
def JetViewAlgCfg(flags, jetDef, jetPtMinGeV=JET_DEFAULT_VIEW_PT_MIN_GEV)
def getHLTPrefix()
— String getters —
def solveGroomingDependencies(groomdef0, flags)
def interpretRecoAlg(recoAlg)
— General helpers —
def defineJets(flags, jetRecoDict, clustersKey=None, prefix='', suffix='', pfoPrefix=None)
def StandardJetRecoCfg(flags, **jetDefDict)
def HeavyIonJetRecoDataDeps(flags, **jetRecoDict)
def GroomedJetRecoCfg(flags, **jetDefDict)
def getFilterCut(recoAlg)
def doTracking(jetRecoDict)
def ReclusteredJetRecoDataDeps(flags, **jetRecoDict)