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