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