ATLAS Offline Software
Loading...
Searching...
No Matches
BuildSignatureFlags.py
Go to the documentation of this file.
1# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
2
3from AthenaConfiguration.AthConfigFlags import AthConfigFlags
4from TrkConfig.TrackingPassFlags import createTrackingPassFlags,createITkTrackingPassFlags
5from ActsConfig.ActsTrackingPassFlags import createActsTrackingPassFlags
6from TrigEDMConfig.TriggerEDM import recordable
7
8from AthenaCommon.Logging import logging
9import AthenaCommon.SystemOfUnits as Units
10import math
11from copy import deepcopy
12from collections.abc import Callable
13
14log = logging.getLogger("__name__")
15
16def defaultTrigTrackingFlags(flags : AthConfigFlags):
17
18 flags.addFlag("input_name", "")
19 flags.addFlag("name", "")
20 flags.addFlag("suffix", "")
21
22 flags.addFlag("TripletDoPPS", True)
23 flags.addFlag("Triplet_D0Max", 4.0)
24 flags.addFlag("Triplet_D0_PPS_Max", 1.7)
25 flags.addFlag("DoPhiFiltering", True)
26 flags.addFlag("doZFinder", False)
27 flags.addFlag("doZFinderOnly", False)
28 flags.addFlag("doResMon", False)
29 flags.addFlag("doCloneRemoval", True)
30 flags.addFlag("doSeedRedundancyCheck",False)
31 flags.addFlag("DoubletDR_Max", 270)
32 flags.addFlag("SeedRadBinWidth", 2)
33 flags.addFlag("holeSearch_FTF", False)
34 flags.addFlag("electronPID", False)
35 flags.addFlag("etaHalfWidth", 0.1)
36 flags.addFlag("phiHalfWidth", 0.1)
37 flags.addFlag("zedHalfWidth", -999) # don't set this parameter unless it is >= 0)
38 flags.addFlag("doTRT", True)
39 #flags.addFlag("keepTrackParameters", False) # TODO Keep track parameters in conversion to TrackParticles
40 flags.addFlag("UsePixelSpacePoints", True)
41 flags.addFlag("TrackInitialD0Max", 20.0)
42 flags.addFlag("TrackZ0Max", 300.0)
43 flags.addFlag("isLRT", False)
44 flags.addFlag("UseTrigSeedML", 0)
45 flags.addFlag("nClustersMin", 7)
46 flags.addFlag("roi", "")
47 flags.addFlag("LRT_D0Min", 2.0)
48 flags.addFlag("LRT_HardPtMin", 1.0*Units.GeV)
49 flags.addFlag("vertex", "")
50 flags.addFlag("adaptiveVertex", False)
51 flags.addFlag("addSingleTrackVertices", False)
52 flags.addFlag("TracksMaxZinterval", 1*Units.mm)
53 flags.addFlag("minNSiHits_vtx", 10) #from vtxCuts
54 flags.addFlag("vertex_jet", "")
55 flags.addFlag("dodEdxTrk", False)
56 flags.addFlag("doHitDV", False)
57 flags.addFlag("doDisappearingTrk", False)
58 flags.addFlag("useDynamicRoiZWidth", False)
59
60
61 #precision tracking configuration values
62 #__provisional change__:
63 #the following settings are incorrect but this is what is being used in the production running
64 #at the moment. Setting them explicitly here will prevent trigger count differences in
65 #https://gitlab.cern.ch/atlas/athena/-/merge_requests/56607
66 flags.maxEta = 2.7
67 flags.addFlag("minSiClusters", 7)
68 flags.addFlag("maxSiHoles", 5)
69 flags.maxPixelHoles = 5
70 flags.addFlag("maxSCTHoles", 5) #fix2024 - consolidate names maxSctHoles and others in addFlag here
71 flags.maxDoubleHoles = 2
72 flags.addFlag("doEmCaloSeed", False)
73
74 flags.useSeedFilter = False
75 flags.doBremRecoverySi = False #fix2023 setTrue for electron once validated
76
77 flags.addFlag("refitROT", True)
78 flags.addFlag("doTruth", False)
79 flags.addFlag("perigeeExpression","BeamLine") #always use beamline regardless of Reco.EnableHI
80
81 flags.addFlag("trkTracks_FTF", "")
82 flags.addFlag("trkTracks_IDTrig","")
83 flags.addFlag("tracks_FTF", "")
84 flags.addFlag("tracks_IDTrig", "")
85 flags.addFlag("useGBTSeedingTool", False)
86
87def defaultInDetTrigTrackingFlags() -> AthConfigFlags:
88
89 flags = createTrackingPassFlags()
90 defaultTrigTrackingFlags(flags)
91
92 flags.minPT = 1.0*Units.GeV
93 flags.minClusters = 7 #hardcoded to preserve trigger settings (not used for FTF config)
94 flags.minSiNotShared = 5
95 flags.maxShared = 2
96 flags.Xi2max = 9.
97 flags.Xi2maxNoAdd = 25.
98 flags.nHolesMax = 2
99 flags.nHolesGapMax = 2
100 flags.nWeightedClustersMin= 6
101 flags.roadWidth =10.
102
103
104 flags.maxPrimaryImpact = 10.
105 flags.maxEMImpact = 50.
106 flags.maxZImpact = 250.
107
108 flags.minTRTonTrk =9
109
110 #TODO - simple ambiguitues
111 flags.useTIDE_Ambi = False
112
113 #2023fix - it should read 2
114 flags.maxSiHoles = 5
115 flags.maxSCTHoles = 5
116 #end
117
118 return flags
119
120def defaultITkTrigTrackingFlags() -> AthConfigFlags:
121 flags = createITkTrackingPassFlags()
122 defaultTrigTrackingFlags(flags)
123
124 flags.minPT = [1.0*Units.GeV,0.45*Units.GeV,0.45*Units.GeV] #ITk flags have eta dependant settings
125 flags.minClusters = [9,8,7] #offline defaults are [9,8,7]
126 flags.Xi2max = [9.]
127 flags.Xi2maxNoAdd = [25.]
128 flags.nHolesMax = [2]
129 flags.nHolesGapMax = [2]
130 flags.nWeightedClustersMin= [6]
131 flags.maxDoubleHoles = [2]
132 flags.maxPixelHoles = [5]
133 flags.maxZImpact = [250.0]
134 flags.doTRT = False
135 flags.doZFinder = False
136 flags.DoPhiFiltering = True
137 flags.UsePixelSpacePoints = True # In LRT they use only SCT SP, but for ITk we want pixel SP
138 flags.doDisappearingTrk = False # Not working yet for ITk
139 flags.doCaloSeededBremSi = False
140 flags.doCaloSeededAmbiSi = False
141 flags.DoubletDR_Max = 150.0
142 flags.useTIDE_Ambi = False
143 flags.maxEta = 4.0
144
145 return flags
146
147def defaultITkActsTrigTrackingFlags() -> AthConfigFlags:
148 flags = createActsTrackingPassFlags()
149 defaultTrigTrackingFlags(flags)
150
151 flags.minPT = [0.9*Units.GeV, 0.4*Units.GeV, 0.4*Units.GeV]
152 flags.minClusters = [9, 8, 7]
153 flags.doTRT = False
154 flags.maxEta = 4.0
155 flags.maxShared = [2]
156 flags.maxHoles = [1]
157 flags.maxPixelHoles = [2]
158 flags.maxSctHoles = [2]
159 flags.maxShared = [2]
160 flags.maxDoubleHoles = [1]
161
162 return flags
163
164def actsLRTTrigTrackingFlags(flags: AthConfigFlags) -> None:
165 """Apply the Acts-specific steering and cuts needed by trigger LRT."""
166 flags.isLargeD0 = True
167 flags.etaBins = [-1.0, 2.7]
168 flags.minPT = [1.0 * Units.GeV]
169 flags.minPTSeed = 1.0 * Units.GeV
170 flags.maxPrimaryImpactSeed = 300.0 * Units.mm
171 flags.maxZImpactSeed = 500.0 * Units.mm
172 flags.minPixel = [0]
173
174def defaultModeTrigTrackingFlags(flags: AthConfigFlags) -> AthConfigFlags:
175 return flags
176
177def signatureTrigTrackingFlags(mode : str) -> AthConfigFlags:
178
179 signatureSet = {
180 "electron" : electron,
181 "photon" : electron,
182
183 "muon" : muon,
184 "muonIso" : muonIso,
185 "muonIsoMS" : muonIso,
186 "muonCore" : muon,
187 "muonFS" : muon,
188 "muonLate" : muon,
189
190 "tauCore" : tauCore,
191 "tauCoreEM" : tauCoreEM,
192 "tauIso" : tauIso,
193 "tauIsoEM" : tauIsoEM,
194 "tauHitsHitZ" : tauHitsHitZ,
195 "tauCoreHitZ" : tauCoreHitZ,
196 "tauIsoHitZ" : tauIsoHitZ,
197
198 "diTau" : diTau,
199
200 "bjet" : bjet,
201
202 "fullScan" : fullScan,
203 "jetSuper" : jetSuper,
204
205 "beamSpot" : beamSpot,
206 "beamSpotFS" : beamSpotFS,
207
208 "cosmics" : cosmics,
209 "bmumux" : bmumux,
210 "bhh" : bhh,
211
212 "minBias" : minBias,
213 "minBiasPixel" : minBiasPixel,
214
215 "electronLRT" : electronLRT,
216 "muonLRT" : muonLRT,
217 "tauLRT" : tauLRT,
218 "bjetLRT" : bjetLRT,
219 "fullScanLRT" : fullScanLRT,
220 "DJetLRT" : DJetLRT,
221 "DVtxLRT" : DVtxLRT,
222 }
223
224 flags = AthConfigFlags()
225
226 if mode == "InDet":
227 category = 'Trigger.InDetTracking'
228 defaults = defaultInDetTrigTrackingFlags
229 elif mode == "ITk":
230 category = 'Trigger.ITkTracking'
231 defaults = defaultITkTrigTrackingFlags
232 elif mode == "Acts":
233 category = "Trigger.ActsTracking"
234 defaults = defaultITkActsTrigTrackingFlags
235 else:
236 log.error("Unsupported reconstruction mode %s", mode)
237
238
239 class categoryGeneratorWrapper():
240 """ wrap function which can be consumed by addFlagsCategory and provide its args """
241 def __init__(self, fun : Callable[[AthConfigFlags, str, str], AthConfigFlags],
242 flags : AthConfigFlags, signatureInstance : str, recoMode : str):
243 self.flags = flags
244 self.sig = signatureInstance
245 self.fun = fun
246 self.mode= recoMode
247 def run(self):
248 return self.fun(self.flags,self.sig,self.mode)
249
250 for i in signatureSet:
251 trackingflags = deepcopy(defaults())
252 a = categoryGeneratorWrapper(signatureSet[i],trackingflags,i,mode)
253 signatureCategory = "{}.{}".format(category,i)
254 flags.addFlagsCategory(signatureCategory,a.run,prefix=True)
255
256 addGlobalFlags(flags, category) # they should not be needed / backward compatibility
257
258 return flags
259
260
261def signatureActions(func):
262 """ convenience decorator to automate config steps """
263 def invokeSteps(*args, **kwargs):
264 flagsSig = func(*args, **kwargs) #invoke signature specific code
265 recoMode = args[2]
266 derivedFromSignatureFlags(flagsSig,recoMode) #invoke code dependant on signature flags
267 return flagsSig
268 return invokeSteps
269
270
271def lrtSignatureActions(func):
272 """Set common LRT flags before applying per-signature overrides."""
273 @signatureActions
274 def invokeSteps(flags: AthConfigFlags, instanceName: str, recoMode: str):
275 flags.isLRT = True
276 if recoMode == "Acts":
277 actsLRTTrigTrackingFlags(flags)
278 return func(flags, instanceName, recoMode)
279 return invokeSteps
280
281
282def tsetter(var, value):
283 """ use previous type of the var and convert value to it
284 for the moment just makes list of a value if needed
285 """
286 type2set = type(var)
287 typeOfValue = type(value)
288 if type2set == typeOfValue:
289 var = value
290 else:
291 basic = (bool, str, int, float, type(None))
292 var = value if isinstance(var, basic) else [value]
293
294 return var
295
296def processEtaDepSettings(var, settings):
297 """ depending on the destination flag type either keep list of values or flatten to a single value
298 """
299 type2set = type(var)
300 typeOfValue = type(settings)
301 if type2set == typeOfValue:
302 var = settings
303 else:
304 if isinstance(settings, list):
305 var = settings[0] if settings else None
306 else:
307 var = settings
308
309 return var
310
311@signatureActions
312def electron(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
313
314 flags.input_name = instanceName
315 flags.name = "electron"
316 flags.suffix = "Electron"
317 flags.roi = "HLT_Roi_Electron"
318 flags.etaHalfWidth = 0.05 # this size should be increased to 0.1
319 flags.phiHalfWidth = 0.1
320 flags.doCloneRemoval = True
321 flags.doSeedRedundancyCheck = True
322 if recoMode=="InDet":
323 flags.doTRT = True
324 flags.electronPID = True
325 return flags
326
327@signatureActions
328def muon(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
329
330 flags.input_name = instanceName
331 flags.name = "muon"
332 flags.suffix = "Muon"
333 flags.roi = "HLT_Roi_L2SAMuon"
334 flags.Triplet_D0Max = 10.0
335 flags.doResMon = True
336 flags.DoPhiFiltering = False
337 flags.doSeedRedundancyCheck = True
338 return flags
339
340@signatureActions
341def muonIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
342
343 flags.input_name = instanceName
344 flags.name = "muonIso"
345 flags.suffix = "MuonIso"
346 flags.roi = "HLT_Roi_MuonIso"
347 flags.etaHalfWidth = 0.35
348 flags.phiHalfWidth = 0.35
349 flags.zedHalfWidth = 10.0
350 return flags
351
352@signatureActions
353def tauHitsHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
354 # RoI used only for SP-formation (no tracking)
355
356 flags.input_name = instanceName
357 flags.name = "tauHitsHitZ"
358 flags.suffix = "TauHits"
359 flags.roi = "HLT_Roi_TauHitsHitZ"
360 return flags
361
362@signatureActions
363def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
364
365 flags.input_name = instanceName
366 flags.name = "tauCore"
367 flags.suffix = "TauCore"
368 flags.roi = "HLT_Roi_TauCore"
369 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
370 flags.holeSearch_FTF = True
371 return flags
372
373@signatureActions
374def tauCoreEM(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
375 flags = tauCore(flags, instanceName, recoMode)
376 flags.name = "tauCoreEM"
377 flags.suffix = "TauCoreEM"
378 flags.roi = "HLT_Roi_TauCoreEM"
379 return flags
380
381@signatureActions
382def tauCoreHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
383 flags = tauCore(flags, instanceName, recoMode)
384 flags.name = "tauCoreHitZ"
385 flags.roi = "HLT_Roi_TauCoreHitZ"
386 flags.zedHalfWidth = 30.0
387 return flags
388
389@signatureActions
390def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
391
392 flags.input_name = instanceName
393 flags.name = "tauIso"
394 flags.suffix = "TauIso"
395 flags.roi = "HLT_Roi_TauIso"
396 flags.etaHalfWidth = 0.4
397 flags.phiHalfWidth = 0.4
398 flags.zedHalfWidth = 7.0
399 flags.adaptiveVertex = True
400 flags.addSingleTrackVertices = True
401 flags.vertex = "HLT_IDVertex_Tau"
402 flags.electronPID = False
403 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
404 return flags
405
406@signatureActions
407def tauIsoEM(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
408 flags = tauIso(flags, instanceName, recoMode)
409 flags.name = "tauIsoEM"
410 flags.suffix = "TauIsoEM"
411 flags.roi = "HLT_Roi_TauIsoEM"
412 return flags
413
414@signatureActions
415def tauIsoHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
416 flags = tauIso(flags, instanceName, recoMode)
417 flags.name = "tauIsoHitZ"
418 flags.roi = "HLT_Roi_TauIsoHitZ"
419 return flags
420
421@signatureActions
422def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
423
424 flags.input_name = instanceName
425 flags.name = "diTau"
426 flags.suffix = "DiTau"
427 flags.roi = "HLT_Roi_DiTau"
428 flags.etaHalfWidth = 1.0
429 flags.phiHalfWidth = 1.0
430 flags.zedHalfWidth = 7.0
431 flags.adaptiveVertex = True
432 flags.addSingleTrackVertices = True
433 flags.vertex = "HLT_IDVertex_DiTau"
434 flags.electronPID = False
435 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
436 return flags
437
438@signatureActions
439def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
440
441 flags.input_name = instanceName
442 flags.name = "bjet"
443 flags.suffix = "Bjet"
444 flags.roi = "HLT_Roi_Bjet"
445 flags.etaHalfWidth = 0.4
446 flags.phiHalfWidth = 0.4
447 flags.zedHalfWidth = 10.0
448 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
449 flags.Xi2max = tsetter(flags.Xi2max,12.)
450 if recoMode == "Acts":
451 flags.Xi2maxSigma = [math.sqrt(12.)]
452 return flags
453
454@signatureActions
455def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
456
457 flags.input_name = instanceName
458 flags.name = "jetSuper"
459 flags.suffix = "JetSuper"
460 flags.vertex = "HLT_IDVertex_JetSuper"
461 flags.adaptiveVertex = True
462 flags.addSingleTrackVertices = True
463 flags.roi = "HLT_Roi_JetSuper"
464 flags.etaHalfWidth = 0.3
465 flags.phiHalfWidth = 0.3
466 flags.minPT = processEtaDepSettings(flags.minPT,[1.*Units.GeV])
467
468 #-----
469 flags.doTRT = False
470 flags.DoubletDR_Max = 200
471 flags.SeedRadBinWidth = 10
472 flags.doSeedRedundancyCheck = True
473 flags.TripletDoPPS = False
474 flags.nClustersMin = 8
475 flags.UseTrigSeedML = 4
476 flags.roadWidth = 5.
477 return flags
478
479@signatureActions
480def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
481
482 flags.input_name = instanceName
483 flags.name = "minBias"
484 flags.suffix = "MinBias"
485 flags.roi = "HLT_Roi_MinBias"
486 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
487
488 flags.doTRT = False
489 flags.etaHalfWidth = 3
490 flags.phiHalfWidth = math.pi
491 flags.doZFinder = True
492 flags.doZFinderOnly = True
493
494 flags.nClustersMin = 5
495 flags.useSeedFilter = True
496 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
497 flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
498 flags.roadWidth = 20
499 flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
500 return flags
501
502
503@signatureActions
504def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
505
506 flags.input_name = instanceName
507 flags.name = "minBiasPixel"
508 flags.suffix = "MinBiasPixel"
509 flags.roi = "HLT_Roi_MinBias"
510 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
511
512
513 flags.maxHoles = 0 # HI setup
514 flags.maxPixelHoles = 0 # HI setup
515 flags.maxSctHoles = 0
516 flags.maxDoubleHoles = 0
517 flags.minSiNotShared = 3
518 flags.maxShared = 0
519 if recoMode != "Acts":
520 flags.nHolesMax = 0
521 flags.nHolesGapMax = 0
522 if recoMode=="InDet":
523 flags.useSCT = False
524 flags.useSCTSeeding = False
525
526 flags.roadWidth = 12.0
527 flags.Xi2max = 15
528 flags.Xi2maxNoAdd = 35.0
529 flags.nWeightedClustersMin = 6
530 flags.doBremRecoverySi = False
531 flags.RunPixelPID = False # we use these tracks only for counting
532
533 flags.doTRT = False
534 flags.etaHalfWidth = 3
535 flags.phiHalfWidth = math.pi
536 flags.doZFinder = False
537 flags.doZFinderOnly = True
538
539 flags.minClusters = 3
540 flags.nClustersMin = 3
541 flags.useSeedFilter = True
542 flags.maxPrimaryImpact = 10.*Units.mm
543 flags.maxZImpact = 150.*Units.mm
544 flags.roadWidth = 20
545 flags.usePrdAssociationTool = False
546 return flags
547
548
549
550@signatureActions
551def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
552
553 flags.input_name = instanceName
554 flags.name = "beamSpot"
555 flags.suffix = "BeamSpot"
556 flags.roi = "HLT_Roi_FS"
557 flags.doZFinder = True
558 flags.DoubletDR_Max = 200
559 flags.SeedRadBinWidth = 10
560 flags.etaHalfWidth = 3
561 flags.phiHalfWidth = math.pi
562 flags.doTRT = False
563 flags.doSeedRedundancyCheck = True
564 return flags
565
566
567@signatureActions
568def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
569
570 flags.input_name = instanceName
571 flags.name = "fullScan"
572 flags.suffix = "FS"
573 flags.roi = "HLT_Roi_FS"
574 flags.vertex = "HLT_IDVertex_FS"
575 flags.adaptiveVertex = True
576 # these are being evaluated and may be added
577 # flags.addSingleTrackVertices = True
578 # flags.TracksMaxZinterval = 3
579 flags.vertex_jet = "HLT_IDVertex_FS"
580 flags.etaHalfWidth = 3.
581 flags.phiHalfWidth = math.pi
582 flags.doTRT = False
583 flags.DoubletDR_Max = 200
584 flags.SeedRadBinWidth = 10
585 flags.doSeedRedundancyCheck = True
586 flags.TripletDoPPS = False
587 flags.nClustersMin = 8
588 flags.UseTrigSeedML = 4
589 flags.dodEdxTrk = True
590 flags.doHitDV = True
591 flags.doDisappearingTrk = recoMode=="InDet"
592 flags.roadWidth = 5.
593 return flags
594
595
596@signatureActions
597def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
598
599 flags.input_name = instanceName
600 flags.name = "fullScan"
601 flags.suffix = "FS"
602 flags.roi = "HLT_Roi_FS"
603 flags.etaHalfWidth = 3.
604 flags.phiHalfWidth = math.pi
605 flags.doTRT = False
606 flags.DoubletDR_Max = 200
607 flags.SeedRadBinWidth = 10
608 flags.TripletDoPPS = False
609 flags.nClustersMin = 8
610 flags.UseTrigSeedML = 4
611 return flags
612
613
614@signatureActions
615def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
616
617 flags.input_name = instanceName
618 flags.name = "cosmics"
619 flags.suffix = "Cosmic"
620 flags.roi = "HLT_Roi_Cosmics"
621 flags.Triplet_D0Max = 1000.0
622 flags.Triplet_D0_PPS_Max = 1000.0
623 flags.TrackInitialD0Max = 1000.
624 flags.TrackZ0Max = 1000.
625 flags.doTRT = False
626 flags.etaHalfWidth = 3
627 flags.phiHalfWidth = math.pi
628
629 flags.minPT = processEtaDepSettings(flags.minPT,[0.5*Units.GeV])
630
631 flags.nClustersMin = 4
632 flags.minSiNotShared = 3
633 flags.maxShared = 0
634 if recoMode != "Acts":
635 flags.nHolesMax = 3
636 flags.maxSiHoles = 3
637 flags.maxSCTHoles = 3
638 flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
639 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
640
641 flags.Xi2max = tsetter(flags.Xi2max, 60.)
642 flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
643 if recoMode == "Acts":
644 flags.Xi2maxSigma = [math.sqrt(60.)]
645 flags.Xi2maxNoAddSigma = [10.]
646 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
647
648 flags.nWeightedClustersMin = 8
649 flags.useSeedFilter = True
650 flags.usePrdAssociationTool= False #for backward compatibility #2023fix?
651 flags.roadWidth = 75.
652 flags.maxZImpact = tsetter(flags.maxZImpact, 10000.*Units.mm)
653 if recoMode=="InDet":
654 flags.minTRTonTrk = 20
655
656 return flags
657
658@signatureActions
659def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
660
661 flags.input_name = instanceName
662 flags.name = "bphysics"
663 flags.suffix = "Bmumux"
664 flags.roi = "HLT_Roi_Bmumux"
665 flags.Triplet_D0Max = 10.
666 flags.DoPhiFiltering = False
667 flags.etaHalfWidth = 0.75
668 flags.phiHalfWidth = 0.75
669 flags.zedHalfWidth = 50.
670 flags.doSeedRedundancyCheck = True
671 return flags
672
673@signatureActions
674def bhh(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
675
676 flags.input_name = instanceName
677 flags.name = "bhh"
678 flags.suffix = "Bhh"
679 flags.roi = "HLT_Roi_Bhh"
680 flags.Triplet_D0Max = 10.
681 flags.DoPhiFiltering = False
682 flags.etaHalfWidth = 2.5
683 flags.phiHalfWidth = math.pi-1.e-5
684 flags.zedHalfWidth = 30.
685 flags.minPT = processEtaDepSettings(flags.minPT,[2*Units.GeV])
686
687 flags.doSeedRedundancyCheck = True
688 return flags
689
690@lrtSignatureActions
691def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
692
693 flags.input_name = instanceName
694 flags.name = "electronLRT"
695 flags.suffix = "ElecLRT"
696 flags.roi = "HLT_Roi_Electron"
697 flags.etaHalfWidth = 0.1
698 flags.phiHalfWidth = 0.4
699 flags.UsePixelSpacePoints = False
700 flags.Triplet_D0Max = 300.
701 flags.TrackInitialD0Max = 300.
702 flags.TrackZ0Max = 500.
703 flags.zedHalfWidth = 225.
704 flags.doSeedRedundancyCheck = True
705 flags.nClustersMin = 8
706 #pt config
707 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
708 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
709 flags.maxEta = 2.7
710 flags.doEmCaloSeed = False
711 return flags
712
713
714@lrtSignatureActions
715def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
716
717 flags.input_name = instanceName
718 flags.name = "muonLRT"
719 flags.suffix = "MuonLRT"
720 flags.roi = "HLT_Roi_Muon"
721 flags.UsePixelSpacePoints = False
722 flags.etaHalfWidth = 0.2
723 flags.phiHalfWidth = 0.4
724 flags.Triplet_D0Max = 300.
725 flags.TrackInitialD0Max = 300.
726 flags.TrackZ0Max = 500.
727 flags.zedHalfWidth = 225.
728 flags.doSeedRedundancyCheck = True
729 flags.nClustersMin = 8
730 flags.doResMon = True
731 flags.DoPhiFiltering = False
732 #pt config
733 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
734 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
735 flags.maxEta = 2.7
736 flags.doEmCaloSeed = False
737
738 return flags
739
740
741
742@lrtSignatureActions
743def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
744
745 flags.input_name = instanceName
746 flags.name = "tauLRT"
747 flags.suffix = "TauLRT"
748 flags.roi = "HLT_Roi_TauLRT"
749 flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
750 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
751
752 flags.etaHalfWidth = 0.4
753 flags.phiHalfWidth = 0.4
754 flags.zedHalfWidth = 225.
755 flags.UsePixelSpacePoints = False
756 flags.Triplet_D0Max = 300.
757 flags.TrackInitialD0Max = 300.
758 flags.TrackZ0Max = 500.
759 flags.nClustersMin = 8
760 #pt config
761 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
762 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
763 flags.maxEta = 2.7
764 flags.doEmCaloSeed = False
765 if recoMode=="InDet":
766 flags.doTRT = True
767
768 return flags
769
770
771@lrtSignatureActions
772def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
773
774 flags.input_name = instanceName
775 flags.name = "bjetLRT"
776 flags.suffix = "BjetLRT"
777 flags.roi = "HLT_Roi_Bjet"
778 flags.etaHalfWidth = 0.4
779 flags.phiHalfWidth = 0.4
780 flags.UsePixelSpacePoints = False
781 flags.Triplet_D0Max = 300.
782 flags.TrackInitialD0Max = 300.
783 flags.TrackZ0Max = 500.
784 flags.nClustersMin = 8
785 #pt config
786 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
787 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
788 flags.maxEta = 2.7
789 flags.doEmCaloSeed = False
790
791 return flags
792
793
794@lrtSignatureActions
795def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
796
797 flags.input_name = instanceName
798 flags.name = "fullScanLRT"
799 flags.suffix = "FSLRT"
800 flags.roi = "HLT_Roi_FS"
801 flags.etaHalfWidth = 3.
802 flags.phiHalfWidth = math.pi
803 flags.doTRT = False
804 flags.doSeedRedundancyCheck = True
805 flags.UsePixelSpacePoints = False
806 flags.Triplet_D0Max = 300.
807 flags.TrackInitialD0Max = 300.
808 flags.TrackZ0Max = 500.
809 flags.Triplet_D0_PPS_Max = 300.
810 flags.DoubletDR_Max = 200
811 flags.nClustersMin = 8
812 #pt config
813 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
814 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
815 flags.maxEta = 2.7
816 flags.doEmCaloSeed = False
817
818 return flags
819
820
821@lrtSignatureActions
822def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
823
824 flags.input_name = instanceName
825 flags.name = "DJetLRT"
826 flags.suffix = "DJLRT"
827 flags.roi = "HLT_Roi_DJ"
828 flags.etaHalfWidth = 0.4
829 flags.phiHalfWidth = 0.4
830 flags.zedHalfWidth = 225.
831 flags.doTRT = False
832 flags.doSeedRedundancyCheck = True
833 flags.UsePixelSpacePoints = False
834 flags.Triplet_D0Max = 300.
835 flags.TrackInitialD0Max = 300.
836 flags.TrackZ0Max = 500.
837 flags.Triplet_D0_PPS_Max = 300.
838 flags.DoubletDR_Max = 200
839 flags.nClustersMin = 8
840 #pt config
841 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
842 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
843 flags.maxEta = 2.7
844 flags.doEmCaloSeed = False
845
846 return flags
847
848
849@lrtSignatureActions
850def DVtxLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
851
852 flags.input_name = instanceName
853 flags.name = "DVtxLRT"
854 flags.suffix = "DVLRT"
855 flags.roi = "HLT_Roi_DV"
856 flags.etaHalfWidth = 0.35
857 flags.phiHalfWidth = 0.35
858 flags.doTRT = False
859 flags.doSeedRedundancyCheck = True
860 flags.UsePixelSpacePoints = False
861 flags.Triplet_D0Max = 300.
862 flags.TrackInitialD0Max = 300.
863 flags.TrackZ0Max = 500.
864 flags.Triplet_D0_PPS_Max = 300.
865 flags.DoubletDR_Max = 200
866 flags.nClustersMin = 8
867 #pt config
868 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
869 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
870 flags.maxEta = 2.7
871 flags.doEmCaloSeed = False
872
873 return flags
874
875
876def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
877
878 flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
879 flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
880 flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
881
882 # ToDo: shouldn't be setting flags using this if type structures, the flags should be
883 # actually set somewhere in appropriate config functions
884 flags.tracks_IDTrig = \
885 collToRecordable(flags, f"HLT_IDTrack_{flags.suffix if flags.input_name not in ['tauIso', 'tauIsoHitZ'] else "Tau"}_IDTrig")
886
887 if recoMode == "Acts":
888 flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
889 flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
890
891 if flags.isLRT: # to be moved to a separate function once LRTs differ
892 flags.minClusters = tsetter(flags.minClusters , 8)
893 flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
894 flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
895 flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
896 flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
897 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
898 flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
899 if recoMode != "Acts":
900 flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
901
902
903 if recoMode == "ITk":
904 flags.extension = flags.input_name #needed in the ITk mode?
905
906 if flags.isLRT:
907 flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
908
909
910def collToRecordable(flags,name):
911 # ToDo: should just be a flag set per signature in the per signature config
912 # and not setting parameters using tests on the signature name
913 ret = name
914 signature = flags.input_name
915 firstStage = "FTF" in name
916 record = True
917 if firstStage:
918 if signature in ["tauHitsHitZ","minBias","minBiasPixel","bjetLRT",
919 "beamSpot"]:
920 record = False
921 else:
922 if signature in ["tauHitsHitZ","tauCore","tauCoreEM","tauCoreHitZ","tauIso","tauIsoEM","tauIsoHitZ","tauIsoBDT",
923 "jet","fullScan","jetSuper","bhh",
924 "beamSpot","beamSpotFS",
925 "bjetLRT","DJetLRT","DVtxLRT"]:
926 record = False
927
928 if record:
929 ret = recordable(name)
930
931 return ret
932
933def addGlobalFlags(flags: AthConfigFlags, category : str):
934 flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
935 flags.addFlag(f'{category}.doGPU', False)
936 flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
937 flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
938 flags.addFlag(f'{category}.UseTracklets', False)
939 flags.addFlag(f'{category}.trackletPoints', 1)
940 flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
941 flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
942 flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
943 flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
944 flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
945 flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
946 flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
947 flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
948 flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
949 flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
950 flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
951 flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
952 flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
953 flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
954
955import unittest
956
957class FlagValuesTest(unittest.TestCase):
958 def setUp(self):
959 from AthenaConfiguration.AllConfigFlags import initConfigFlags
960 flags = initConfigFlags()
961 flags.Trigger.InDetTracking.electron.minPT=3.
962 flags.Trigger.ITkTracking.muonLRT.maxEta=5.
963 flags.Trigger.ITkTracking.jetSuper.minPT=[3.,2.,1.]
964 self.newflags1 = flags.cloneAndReplace('Tracking.ActiveConfig', 'Trigger.InDetTracking.electron',
965 keepOriginal = True)
966 self.newflags2 = flags.cloneAndReplace('Tracking.ActiveConfig', 'Trigger.ITkTracking.muonLRT',
967 keepOriginal = True)
968 self.newflags3 = flags.cloneAndReplace('Tracking.ActiveConfig', 'Trigger.ITkTracking.jetSuper',
969 keepOriginal = True)
970
971 def runTest(self):
972 self.assertEqual(self.newflags1.Tracking.ActiveConfig.minPT, 3., msg="Preset value lost")
973 self.assertEqual(self.newflags1.Tracking.ActiveConfig.input_name, "electron", msg="Incorrect version of flags")
974 self.assertEqual(self.newflags2.Tracking.ActiveConfig.input_name, "muonLRT", msg="Incorrect version of flags")
975 self.assertEqual(self.newflags2.Tracking.ActiveConfig.maxEta, 5., msg="Preset value lost")
976 self.assertEqual(self.newflags3.Tracking.ActiveConfig.minPT, [3.,2.,1.], msg="Preset value lost")
977
978
979if __name__ == "__main__":
980 unittest.main()
python.BuildSignatureFlags.derivedFromSignatureFlags
derivedFromSignatureFlags(AthConfigFlags flags, str recoMode)
Definition BuildSignatureFlags.py:876
python.BuildSignatureFlags.electron
AthConfigFlags electron(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:312
python.BuildSignatureFlags.DJetLRT
AthConfigFlags DJetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:822
python.BuildSignatureFlags.tauIso
AthConfigFlags tauIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:390
python.BuildSignatureFlags.tauCoreEM
AthConfigFlags tauCoreEM(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:374
python.BuildSignatureFlags.addGlobalFlags
addGlobalFlags(AthConfigFlags flags, str category)
Definition BuildSignatureFlags.py:933
python.BuildSignatureFlags.bjetLRT
AthConfigFlags bjetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:772
python.BuildSignatureFlags.defaultITkActsTrigTrackingFlags
AthConfigFlags defaultITkActsTrigTrackingFlags()
Definition BuildSignatureFlags.py:147
python.BuildSignatureFlags.tauLRT
AthConfigFlags tauLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:743
python.BuildSignatureFlags.muon
AthConfigFlags muon(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:328
python.BuildSignatureFlags.minBias
AthConfigFlags minBias(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:480
python.BuildSignatureFlags.tauCore
AthConfigFlags tauCore(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:363
python.BuildSignatureFlags.tauCoreHitZ
AthConfigFlags tauCoreHitZ(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:382
python.BuildSignatureFlags.jetSuper
AthConfigFlags jetSuper(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:455
python.BuildSignatureFlags.defaultTrigTrackingFlags
defaultTrigTrackingFlags(AthConfigFlags flags)
Definition BuildSignatureFlags.py:16
python.BuildSignatureFlags.fullScanLRT
AthConfigFlags fullScanLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:795
python.BuildSignatureFlags.defaultITkTrigTrackingFlags
AthConfigFlags defaultITkTrigTrackingFlags()
Definition BuildSignatureFlags.py:120
python.BuildSignatureFlags.bmumux
AthConfigFlags bmumux(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:659
python.BuildSignatureFlags.tauHitsHitZ
AthConfigFlags tauHitsHitZ(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:353
python.BuildSignatureFlags.diTau
AthConfigFlags diTau(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:422
python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:439
python.BuildSignatureFlags.defaultModeTrigTrackingFlags
AthConfigFlags defaultModeTrigTrackingFlags(AthConfigFlags flags)
Definition BuildSignatureFlags.py:174
python.BuildSignatureFlags.DVtxLRT
AthConfigFlags DVtxLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:850
python.BuildSignatureFlags.electronLRT
AthConfigFlags electronLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:691
python.BuildSignatureFlags.minBiasPixel
AthConfigFlags minBiasPixel(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:504
python.BuildSignatureFlags.tauIsoEM
AthConfigFlags tauIsoEM(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:407
python.BuildSignatureFlags.beamSpotFS
AthConfigFlags beamSpotFS(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:597
python.BuildSignatureFlags.actsLRTTrigTrackingFlags
None actsLRTTrigTrackingFlags(AthConfigFlags flags)
Definition BuildSignatureFlags.py:164
python.BuildSignatureFlags.muonIso
AthConfigFlags muonIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:341
python.BuildSignatureFlags.fullScan
AthConfigFlags fullScan(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:568
python.BuildSignatureFlags.bhh
AthConfigFlags bhh(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:674
python.BuildSignatureFlags.muonLRT
AthConfigFlags muonLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:715
python.BuildSignatureFlags.tauIsoHitZ
AthConfigFlags tauIsoHitZ(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:415
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:551
python.BuildSignatureFlags.defaultInDetTrigTrackingFlags
AthConfigFlags defaultInDetTrigTrackingFlags()
Definition BuildSignatureFlags.py:87
python.BuildSignatureFlags.signatureTrigTrackingFlags
AthConfigFlags signatureTrigTrackingFlags(str mode)
Definition BuildSignatureFlags.py:177
type
run
int run(int argc, char *argv[])
Definition ttree2hdf5.cxx:28
Generated on for ATLAS Offline Software by doxygen 1.17.0