ATLAS Offline Software
Classes | Functions | Variables
python.BuildSignatureFlags Namespace Reference

Classes

class  FlagValuesTest
 

Functions

def defaultTrigTrackingFlags (AthConfigFlags flags)
 
AthConfigFlags defaultInDetTrigTrackingFlags ()
 
AthConfigFlags defaultITkTrigTrackingFlags ()
 
AthConfigFlags defaultModeTrigTrackingFlags (AthConfigFlags flags)
 
AthConfigFlags signatureTrigTrackingFlags (str mode)
 
def signatureActions (func)
 
def tsetter (var, value)
 
AthConfigFlags electron (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags muon (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags muonIso (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags tauCore (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags tauIso (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags bjet (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags jetSuper (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags minBias (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags beamSpot (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags fullScan (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags beamSpotFS (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags cosmics (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags bmumux (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags electronLRT (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags muonLRT (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags tauLRT (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags bjetLRT (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags fullScanLRT (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags DJetLRT (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags DVtxLRT (AthConfigFlags flags, str instanceName, str recoMode)
 
def derivedFromSignatureFlags (AthConfigFlags flags, str recoMode)
 
def collToRecordable (flags, name)
 
def addGlobalFlags (AthConfigFlags flags, str category)
 

Variables

 log
 
 flags
 
 sig
 
 fun
 
 mode
 

Function Documentation

◆ addGlobalFlags()

def python.BuildSignatureFlags.addGlobalFlags ( AthConfigFlags  flags,
str  category 
)

Definition at line 778 of file BuildSignatureFlags.py.

778 def addGlobalFlags(flags: AthConfigFlags, category : str):
779  flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
780  flags.addFlag(f'{category}.doGPU', False)
781  flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
782  flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
783  flags.addFlag(f'{category}.UseTracklets', False)
784 
785 

◆ beamSpot()

AthConfigFlags python.BuildSignatureFlags.beamSpot ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 402 of file BuildSignatureFlags.py.

402 def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
403 
404  flags.input_name = instanceName
405  flags.name = "beamSpot"
406  flags.suffix = "BeamSpot"
407  flags.roi = "HLT_Roi_FS"
408  flags.doFullScan = True
409  flags.doZFinder = True
410  flags.DoubletDR_Max = 200
411  flags.SeedRadBinWidth = 10
412  flags.etaHalfWidth = 3
413  flags.phiHalfWidth = math.pi
414  flags.doTRT = False
415  flags.doSeedRedundancyCheck = True
416  flags.doRecord = False
417  return flags
418 
419 
420 @signatureActions

◆ beamSpotFS()

AthConfigFlags python.BuildSignatureFlags.beamSpotFS ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 452 of file BuildSignatureFlags.py.

452 def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
453 
454  flags.input_name = instanceName
455  flags.name = "fullScan"
456  flags.suffix = "FS"
457  flags.roi = "HLT_Roi_FS"
458  flags.doFullScan = True
459  flags.etaHalfWidth = 3.
460  flags.phiHalfWidth = math.pi
461  flags.doTRT = False
462  flags.DoubletDR_Max = 200
463  flags.SeedRadBinWidth = 10
464  flags.TripletDoPPS = False
465  flags.nClustersMin = 8
466  flags.UseTrigSeedML = 4
467  flags.doRecord = False
468  return flags
469 
470 
471 @signatureActions

◆ bjet()

AthConfigFlags python.BuildSignatureFlags.bjet ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 335 of file BuildSignatureFlags.py.

335 def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
336 
337  flags.input_name = instanceName
338  flags.name = "bjet"
339  flags.suffix = "Bjet"
340  flags.roi = "HLT_Roi_Bjet"
341  flags.etaHalfWidth = 0.4
342  flags.phiHalfWidth = 0.4
343  flags.zedHalfWidth = 10.0
344  flags.pTmin = 0.8*Units.GeV
345  flags.minPT = tsetter(flags.minPT, flags.pTmin)
346  flags.Xi2max = tsetter(flags.Xi2max,12.)
347  return flags
348 
349 @signatureActions

◆ bjetLRT()

AthConfigFlags python.BuildSignatureFlags.bjetLRT ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 617 of file BuildSignatureFlags.py.

617 def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
618 
619  flags.input_name = instanceName
620  flags.name = "bjetLRT"
621  flags.suffix = "BjetLRT"
622  flags.roi = "HLT_Roi_Bjet"
623  flags.etaHalfWidth = 0.4
624  flags.phiHalfWidth = 0.4
625  flags.UsePixelSpacePoints = False
626  flags.Triplet_D0Max = 300.
627  flags.TrackInitialD0Max = 300.
628  flags.TrackZ0Max = 500.
629  flags.nClustersMin = 8
630  flags.isLRT = True
631  #pt config
632  flags.maxRPhiImpact = 300.
633  flags.maxRPhiImpactEM = 300.
634  flags.maxEta = 2.7
635  flags.doEmCaloSeed = False
636 
637  return flags
638 
639 
640 @signatureActions

◆ bmumux()

AthConfigFlags python.BuildSignatureFlags.bmumux ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 516 of file BuildSignatureFlags.py.

516 def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
517 
518  flags.input_name = instanceName
519  flags.name = "bphysics"
520  flags.suffix = "Bmumux"
521  flags.roi = "HLT_Roi_Bmumux"
522  flags.Triplet_D0Max = 10.
523  flags.DoPhiFiltering = False
524  flags.etaHalfWidth = 0.75
525  flags.phiHalfWidth = 0.75
526  flags.zedHalfWidth = 50.
527  flags.doSeedRedundancyCheck = True
528  flags.SuperRoI = True
529  return flags
530 
531 @signatureActions

◆ collToRecordable()

def python.BuildSignatureFlags.collToRecordable (   flags,
  name 
)

Definition at line 757 of file BuildSignatureFlags.py.

757 def collToRecordable(flags,name):
758  ret = name
759  signature = flags.input_name
760  firstStage = True if "FTF" in name else False
761  record = True
762  if firstStage:
763  if signature in ["minBias","bjetLRT",
764  "beamSpot","BeamSpot"]:
765  record = False
766  else:
767  if signature in ["tauCore","tauIso","tauIsoBDT",
768  "jet","fullScan","FS","jetSuper",
769  "beamSpot", "BeamSpot","beamSpotFS",
770  "bjetLRT","DJetLRT","DVtxLRT"]:
771  record = False
772 
773  if record:
774  ret = recordable(name)
775 
776  return ret
777 

◆ cosmics()

AthConfigFlags python.BuildSignatureFlags.cosmics ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 472 of file BuildSignatureFlags.py.

472 def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
473 
474  flags.input_name = instanceName
475  flags.name = "cosmics"
476  flags.suffix = "Cosmic"
477  flags.roi = "HLT_Roi_Cosmics"
478  flags.Triplet_D0Max = 1000.0
479  flags.Triplet_D0_PPS_Max = 1000.0
480  flags.TrackInitialD0Max = 1000.
481  flags.TrackZ0Max = 1000.
482  flags.doTRT = False #no real reason except of backward compatibility with
483  #EFIDTracking.py:makeInDetPatternRecognition
484  #2023fix
485  flags.doFullScan = True
486  flags.etaHalfWidth = 3
487  flags.phiHalfWidth = math.pi
488 
489  flags.minPT = tsetter(flags.minPT, 0.5*Units.GeV)
490 
491  flags.nClustersMin = 4
492  flags.minSiNotShared = 3
493  flags.maxShared = 0
494  flags.nHolesMax = 3
495  flags.maxSiHoles = 3
496  flags.maxSCTHoles = 3
497  flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
498  flags.maxPrimaryImpact = 1000.
499  flags.maxRPhiImpact = 1000.
500 
501  flags.Xi2max = tsetter(flags.Xi2max, 60.)
502  flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
503  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
504 
505  flags.nWeightedClustersMin= 8
506  flags.useSeedFilter = True
507  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
508  flags.roadWidth = 75.
509  flags.maxZImpact= tsetter(flags.maxZImpact, 10000.)
510  if recoMode=="InDet":
511  flags.minTRTonTrk = 20
512 
513  return flags
514 
515 @signatureActions

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 98 of file BuildSignatureFlags.py.

98 def defaultInDetTrigTrackingFlags() -> AthConfigFlags:
99 
100  flags = createTrackingPassFlags()
101  defaultTrigTrackingFlags(flags)
102 
103  flags.minPT = flags.pTmin #hack to sync pT threshold used in offline and trigger
104 
105  flags.minClusters = 7 #hardcoded to preserve trigger settings (not used for FTF config)
106  flags.minSiNotShared = 5
107  flags.maxShared = 2
108  flags.Xi2max = 9.
109  flags.Xi2maxNoAdd = 25.
110  flags.nHolesMax = 2
111  flags.nHolesGapMax = 2
112  flags.nWeightedClustersMin= 6
113  flags.roadWidth =10.
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 

◆ defaultITkTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkTrigTrackingFlags ( )

Definition at line 127 of file BuildSignatureFlags.py.

127 def defaultITkTrigTrackingFlags() -> AthConfigFlags:
128 
129  flags = createITkTrackingPassFlags()
130  defaultTrigTrackingFlags(flags)
131 
132  flags.minPT = [flags.pTmin] #ITk flags have eta dependant settings
133  flags.minClusters = [9,8,7] #offline defaults are [9,8,7]
134  flags.Xi2max = [9.]
135  flags.Xi2maxNoAdd = [25.]
136  flags.nHolesMax = [2]
137  flags.nHolesGapMax = [2]
138  flags.nWeightedClustersMin= [6]
139  flags.maxDoubleHoles = [2]
140  flags.maxPixelHoles = [5]
141  flags.maxZImpact = [250.0]
142  flags.doTRT = False
143  flags.doZFinder = False
144  flags.DoPhiFiltering = True
145  flags.UsePixelSpacePoints = True # In LRT they use only SCT SP, but for ITk we want pixel SP
146  flags.doDisappearingTrk = False # Not working yet for ITk
147  flags.doCaloSeededBremSi = False
148  flags.doCaloSeededAmbiSi = False
149  flags.DoubletDR_Max = 150.0
150 
151  return flags
152 

◆ defaultModeTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultModeTrigTrackingFlags ( AthConfigFlags  flags)

Definition at line 153 of file BuildSignatureFlags.py.

153 def defaultModeTrigTrackingFlags(flags: AthConfigFlags) -> AthConfigFlags:
154  return flags
155 

◆ defaultTrigTrackingFlags()

def python.BuildSignatureFlags.defaultTrigTrackingFlags ( AthConfigFlags  flags)

Definition at line 15 of file BuildSignatureFlags.py.

15 def defaultTrigTrackingFlags(flags : AthConfigFlags):
16 
17  flags.addFlag("input_name", "")
18  flags.addFlag("name", "")
19  flags.addFlag("suffix", "")
20 
21  flags.addFlag("pTmin", 1.*Units.GeV) #fix - consolidate pTmin and minPT
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) #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.addFlag("maxRPhiImpact", 10.)
72  flags.addFlag("maxRPhiImpactEM", 50.) # mm #fix2024 - error - only maxRPhiImpEM used
73  flags.addFlag("maxRPhiImpEM", 300.)
74  flags.maxZImpact = 250.
75  flags.maxEta = 2.7
76  flags.addFlag("minSiClusters", 7)
77  flags.addFlag("maxSiHoles", 5)
78  flags.maxPixelHoles = 5
79  flags.addFlag("maxSCTHoles", 5) #fix2024 - consolidate names maxSctHoles and others in addFlag here
80  flags.maxDoubleHoles = 2
81  flags.addFlag("doEmCaloSeed", False)
82 
83  flags.useSeedFilter = False
84  flags.doBremRecoverySi = False #fix2023 setTrue for electron once validated
85 
86  flags.addFlag("refitROT", True)
87  flags.addFlag("trtExtensionType", "xf")
88  flags.addFlag("doTruth", False)
89  flags.addFlag("perigeeExpression","BeamLine") #always use beamline regardless of Reco.EnableHI
90  flags.addFlag("SuperRoI", False) #TBD - move to bphys/menu
91 
92  flags.addFlag("trkTracks_FTF", "")
93  flags.addFlag("trkTracks_IDTrig","")
94  flags.addFlag("tracks_FTF", "")
95  flags.addFlag("tracks_IDTrig", "")
96 
97 

◆ derivedFromSignatureFlags()

def python.BuildSignatureFlags.derivedFromSignatureFlags ( AthConfigFlags  flags,
str  recoMode 
)

Definition at line 728 of file BuildSignatureFlags.py.

728 def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
729 
730  flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
731  flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
732  flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
733  flags.tracks_IDTrig = collToRecordable(flags,"HLT_IDTrack_{}_IDTrig".format(flags.suffix if flags.input_name != "tauIso" else "Tau"))
734 
735  if recoMode == "Acts":
736  flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
737  flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
738 
739  if flags.isLRT: # to be moved to a separate function once LRTs differ
740  flags.minClusters = tsetter(flags.minClusters , 8)
741  flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
742  flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
743  flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
744  flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
745  flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
746  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
747  flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
748 
749 
750  if recoMode == "ITk":
751  flags.extension = flags.input_name #needed in the ITk mode?
752 
753  if flags.isLRT:
754  flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
755 
756 

◆ DJetLRT()

AthConfigFlags python.BuildSignatureFlags.DJetLRT ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 670 of file BuildSignatureFlags.py.

670 def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
671 
672  flags.input_name = instanceName
673  flags.name = "DJetLRT"
674  flags.suffix = "DJLRT"
675  flags.roi = "HLT_Roi_DJ"
676  flags.doFullScan = False
677  flags.etaHalfWidth = 0.4
678  flags.phiHalfWidth = 0.4
679  flags.zedHalfWidth = 225.
680  flags.doTRT = False
681  flags.doSeedRedundancyCheck = True
682  flags.UsePixelSpacePoints = False
683  flags.Triplet_D0Max = 300.
684  flags.TrackInitialD0Max = 300.
685  flags.TrackZ0Max = 500.
686  flags.Triplet_D0_PPS_Max = 300.
687  flags.DoubletDR_Max = 200
688  flags.nClustersMin = 8
689  flags.isLRT = True
690  #pt config
691  flags.maxRPhiImpact = 300.
692  flags.maxRPhiImpactEM = 300.
693  flags.maxEta = 2.7
694  flags.doEmCaloSeed = False
695 
696  return flags
697 
698 
699 @signatureActions

◆ DVtxLRT()

AthConfigFlags python.BuildSignatureFlags.DVtxLRT ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 700 of file BuildSignatureFlags.py.

700 def DVtxLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
701 
702  flags.input_name = instanceName
703  flags.name = "DVtxLRT"
704  flags.suffix = "DVLRT"
705  flags.roi = "HLT_Roi_DV"
706  flags.doFullScan = False
707  flags.etaHalfWidth = 0.35
708  flags.phiHalfWidth = 0.35
709  flags.doTRT = False
710  flags.doSeedRedundancyCheck = True
711  flags.UsePixelSpacePoints = False
712  flags.Triplet_D0Max = 300.
713  flags.TrackInitialD0Max = 300.
714  flags.TrackZ0Max = 500.
715  flags.Triplet_D0_PPS_Max = 300.
716  flags.DoubletDR_Max = 200
717  flags.nClustersMin = 8
718  flags.isLRT = True
719  #pt config
720  flags.maxRPhiImpact = 300.
721  flags.maxRPhiImpactEM = 300.
722  flags.maxEta = 2.7
723  flags.doEmCaloSeed = False
724 
725  return flags
726 
727 

◆ electron()

AthConfigFlags python.BuildSignatureFlags.electron ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 261 of file BuildSignatureFlags.py.

261 def electron(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
262 
263  flags.input_name = instanceName
264  flags.name = "electron"
265  flags.suffix = "Electron"
266  flags.roi = "HLT_Roi_Electron"
267  flags.etaHalfWidth = 0.05 # this size should be increased to 0.1
268  flags.phiHalfWidth = 0.1
269  flags.doCloneRemoval = True
270  flags.doSeedRedundancyCheck = True
271  if recoMode=="InDet":
272  flags.doTRT = True
273  flags.keepTrackParameters = True
274  flags.electronPID = True
275  return flags
276 
277 @signatureActions

◆ electronLRT()

AthConfigFlags python.BuildSignatureFlags.electronLRT ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 532 of file BuildSignatureFlags.py.

532 def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
533 
534  flags.input_name = instanceName
535  flags.name = "electronLRT"
536  flags.suffix = "ElecLRT"
537  flags.roi = "HLT_Roi_Electron"
538  flags.etaHalfWidth = 0.1
539  flags.phiHalfWidth = 0.4
540  flags.UsePixelSpacePoints = False
541  flags.Triplet_D0Max = 300.
542  flags.TrackInitialD0Max = 300.
543  flags.TrackZ0Max = 500.
544  flags.zedHalfWidth = 225.
545  flags.keepTrackParameters = True
546  flags.doSeedRedundancyCheck = True
547  flags.nClustersMin = 8
548  flags.isLRT = True
549  #pt config
550  flags.maxRPhiImpact = 300.
551  flags.maxRPhiImpactEM = 300.
552  flags.maxEta = 2.7
553  flags.doEmCaloSeed = False
554  return flags
555 
556 
557 @signatureActions

◆ fullScan()

AthConfigFlags python.BuildSignatureFlags.fullScan ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 421 of file BuildSignatureFlags.py.

421 def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
422 
423  flags.input_name = instanceName
424  flags.name = "fullScan"
425  flags.suffix = "FS"
426  flags.roi = "HLT_Roi_FS"
427  flags.vertex = "HLT_IDVertex_FS"
428  flags.adaptiveVertex = True
429  # these are being evaluated and may be added
430  # flags.addSingleTrackVertices = True
431  # flags.TracksMaxZinterval = 3
432  flags.vertex_jet = "HLT_IDVertex_FS"
433  flags.adaptiveVertex_jet = True
434  flags.doFullScan = True
435  flags.etaHalfWidth = 3.
436  flags.phiHalfWidth = math.pi
437  flags.doTRT = False
438  flags.DoubletDR_Max = 200
439  flags.SeedRadBinWidth = 10
440  flags.doSeedRedundancyCheck = True
441  flags.TripletDoPPS = False
442  flags.nClustersMin = 8
443  flags.UseTrigSeedML = 4
444  flags.dodEdxTrk = True
445  flags.doHitDV = True
446  flags.doDisappearingTrk = True if recoMode=="InDet" else False
447  flags.roadWidth = 5.
448  return flags
449 
450 
451 @signatureActions

◆ fullScanLRT()

AthConfigFlags python.BuildSignatureFlags.fullScanLRT ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 641 of file BuildSignatureFlags.py.

641 def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
642 
643  flags.input_name = instanceName
644  flags.name = "fullScanLRT"
645  flags.suffix = "FSLRT"
646  flags.roi = "HLT_Roi_FS"
647  flags.doFullScan = True
648  flags.etaHalfWidth = 3.
649  flags.phiHalfWidth = math.pi
650  flags.doTRT = False
651  flags.doSeedRedundancyCheck = True
652  flags.UsePixelSpacePoints = False
653  flags.Triplet_D0Max = 300.
654  flags.TrackInitialD0Max = 300.
655  flags.TrackZ0Max = 500.
656  flags.Triplet_D0_PPS_Max = 300.
657  flags.DoubletDR_Max = 200
658  flags.nClustersMin = 8
659  flags.isLRT = True
660  #pt config
661  flags.maxRPhiImpact = 300.
662  flags.maxRPhiImpactEM = 300.
663  flags.maxEta = 2.7
664  flags.doEmCaloSeed = False
665 
666  return flags
667 
668 
669 @signatureActions

◆ jetSuper()

AthConfigFlags python.BuildSignatureFlags.jetSuper ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 350 of file BuildSignatureFlags.py.

350 def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
351 
352  flags.input_name = instanceName
353  flags.name = "jetSuper"
354  flags.suffix = "JetSuper"
355  flags.vertex = "HLT_IDVertex_JetSuper"
356  flags.adaptiveVertex = True
357  flags.addSingleTrackVertices = True
358  flags.roi = "HLT_Roi_JetSuper"
359  flags.etaHalfWidth = 0.3
360  flags.phiHalfWidth = 0.3
361  flags.doFullScan = True
362  flags.pTmin = 1*Units.GeV
363  flags.minPT = tsetter(flags.minPT, flags.pTmin)
364  #-----
365  flags.doTRT = False
366  flags.DoubletDR_Max = 200
367  flags.SeedRadBinWidth = 10
368  flags.doSeedRedundancyCheck = True
369  flags.TripletDoPPS = False
370  flags.nClustersMin = 8
371  flags.UseTrigSeedML = 4
372  flags.roadWidth = 5.
373  return flags
374 
375 @signatureActions

◆ minBias()

AthConfigFlags python.BuildSignatureFlags.minBias ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 376 of file BuildSignatureFlags.py.

376 def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
377 
378  flags.input_name = instanceName
379  flags.name = "minBias"
380  flags.suffix = "MinBias"
381  flags.roi = "HLT_Roi_MinBias"
382  flags.doFullScan = True
383  flags.pTmin = 0.1*Units.GeV # TODO: double check
384  flags.minPT = tsetter(flags.minPT, flags.pTmin)
385 
386  flags.doTRT = False #backward compatibility with EFIDTracking.py:makeInDetPatternRecognition
387  flags.etaHalfWidth = 3
388  flags.phiHalfWidth = math.pi
389  flags.doZFinder = True
390  flags.doZFinderOnly = True
391 
392  flags.nClustersMin = 5
393  flags.useSeedFilter = True
394  flags.maxPrimaryImpact = 10.*Units.mm
395  flags.maxRPhiImpact = 10.*Units.mm
396  flags.maxZImpact = 150.*Units.mm
397  flags.roadWidth = 20
398  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
399  return flags
400 
401 @signatureActions

◆ muon()

AthConfigFlags python.BuildSignatureFlags.muon ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 278 of file BuildSignatureFlags.py.

278 def muon(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
279 
280  flags.input_name = instanceName
281  flags.name = "muon"
282  flags.suffix = "Muon"
283  flags.roi = "HLT_Roi_L2SAMuon"
284  flags.Triplet_D0Max = 10.0
285  flags.doResMon = True
286  flags.DoPhiFiltering = False
287  flags.doSeedRedundancyCheck = True
288  flags.monPtMin = 12*Units.GeV
289  return flags
290 
291 @signatureActions

◆ muonIso()

AthConfigFlags python.BuildSignatureFlags.muonIso ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 292 of file BuildSignatureFlags.py.

292 def muonIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
293 
294  flags.input_name = instanceName
295  flags.name = "muonIso"
296  flags.suffix = "MuonIso"
297  flags.roi = "HLT_Roi_MuonIso"
298  flags.etaHalfWidth = 0.35
299  flags.phiHalfWidth = 0.35
300  flags.zedHalfWidth = 10.0
301  return flags
302 
303 @signatureActions

◆ muonLRT()

AthConfigFlags python.BuildSignatureFlags.muonLRT ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 558 of file BuildSignatureFlags.py.

558 def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
559 
560  flags.input_name = instanceName
561  flags.name = "muonLRT"
562  flags.suffix = "MuonLRT"
563  flags.roi = "HLT_Roi_Muon"
564  flags.UsePixelSpacePoints = False
565  flags.etaHalfWidth = 0.2
566  flags.phiHalfWidth = 0.4
567  flags.Triplet_D0Max = 300.
568  flags.TrackInitialD0Max = 300.
569  flags.TrackZ0Max = 500.
570  flags.zedHalfWidth = 225.
571  flags.doSeedRedundancyCheck = True
572  flags.nClustersMin = 8
573  flags.isLRT = True
574  flags.doResMon = True
575  flags.DoPhiFiltering = False
576  #pt config
577  flags.maxRPhiImpact = 300.
578  flags.maxRPhiImpEM = 300.
579  flags.maxEta = 2.7
580  flags.doEmCaloSeed = False
581 
582  return flags
583 
584 
585 
586 @signatureActions

◆ signatureActions()

def python.BuildSignatureFlags.signatureActions (   func) 
convenience decorator to automate config steps

Definition at line 232 of file BuildSignatureFlags.py.

232 def signatureActions(func):
233  """ convenience decorator to automate config steps """
234  def invokeSteps(*args, **kwargs):
235  flagsSig = func(*args, **kwargs) #invoke signature specific code
236  recoMode = args[2]
237  derivedFromSignatureFlags(flagsSig,recoMode) #invoke code dependant on signature flags
238  return flagsSig
239  return invokeSteps
240 
241 

◆ signatureTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.signatureTrigTrackingFlags ( str  mode)

Definition at line 156 of file BuildSignatureFlags.py.

156 def signatureTrigTrackingFlags(mode : str) -> AthConfigFlags:
157 
158  signatureSet = {
159  "electron" : electron,
160  "photon" : electron,
161 
162  "muon" : muon,
163  "muonIso" : muonIso,
164  "muonIsoMS" : muonIso,
165  "muonCore" : muon,
166  "muonFS" : muon,
167  "muonLate" : muon,
168 
169  "tauCore" : tauCore,
170  "tauIso" : tauIso,
171 
172  "bjet" : bjet,
173 
174  "fullScan" : fullScan,
175  "FS" : fullScan,
176  "jetSuper" : jetSuper,
177 
178  "beamSpot" : beamSpot,
179  "BeamSpot" : beamSpot,
180  "beamSpotFS" : beamSpotFS,
181 
182  "cosmics" : cosmics,
183  "bmumux" : bmumux,
184  "minBias" : minBias,
185 
186  "electronLRT" : electronLRT,
187  "muonLRT" : muonLRT,
188  "tauLRT" : tauLRT,
189  "bjetLRT" : bjetLRT,
190  "fullScanLRT" : fullScanLRT,
191  "DJetLRT" : DJetLRT,
192  "DVtxLRT" : DVtxLRT,
193  }
194 
195  flags = AthConfigFlags()
196 
197  if mode == "InDet":
198  category = 'Trigger.InDetTracking'
199  defaults = defaultInDetTrigTrackingFlags
200  elif mode == "ITk":
201  category = 'Trigger.ITkTracking'
202  defaults = defaultITkTrigTrackingFlags
203  elif mode == "Acts":
204  category = "Trigger.ActsTracking"
205  defaults = defaultITkTrigTrackingFlags
206  else:
207  log.error("Acts not supported yet")
208 
209 
210  class categoryGeneratorWrapper():
211  """ wrap function which can be consumed by addFlagsCategory and provide its args """
212  def __init__(self, fun : Callable[[AthConfigFlags, str, str], AthConfigFlags],
213  flags : AthConfigFlags, signatureInstance : str, recoMode : str):
214  self.flags = flags
215  self.sig = signatureInstance
216  self.fun = fun
217  self.mode= recoMode
218  def run(self):
219  return self.fun(self.flags,self.sig,self.mode)
220 
221  for i in signatureSet.keys():
222  trackingflags = deepcopy(defaults())
223  a = categoryGeneratorWrapper(signatureSet[i],trackingflags,i,mode)
224  signatureCategory = "{}.{}".format(category,i)
225  flags.addFlagsCategory(signatureCategory,a.run,prefix=True)
226 
227  addGlobalFlags(flags, category) # they should not be needed / backward compatibility
228 
229  return flags
230 
231 

◆ tauCore()

AthConfigFlags python.BuildSignatureFlags.tauCore ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 304 of file BuildSignatureFlags.py.

304 def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
305 
306  flags.input_name = instanceName
307  flags.name = "tauCore"
308  flags.suffix = "TauCore"
309  flags.roi = "HLT_Roi_TauCore"
310  flags.pTmin = 0.8*Units.GeV
311  flags.minPT = tsetter(flags.minPT, flags.pTmin)
312 
313  flags.holeSearch_FTF = True
314  return flags
315 
316 @signatureActions

◆ tauIso()

AthConfigFlags python.BuildSignatureFlags.tauIso ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 317 of file BuildSignatureFlags.py.

317 def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
318 
319  flags.input_name = instanceName
320  flags.name = "tauIso"
321  flags.suffix = "TauIso"
322  flags.roi = "HLT_Roi_TauIso"
323  flags.etaHalfWidth = 0.4
324  flags.phiHalfWidth = 0.4
325  flags.zedHalfWidth = 7.0
326  flags.adaptiveVertex = True
327  flags.addSingleTrackVertices = True
328  flags.vertex = "HLT_IDVertex_Tau"
329  flags.electronPID = False
330  flags.pTmin = 0.8*Units.GeV
331  flags.minPT = tsetter(flags.minPT, flags.pTmin)
332  return flags
333 
334 @signatureActions

◆ tauLRT()

AthConfigFlags python.BuildSignatureFlags.tauLRT ( AthConfigFlags  flags,
str  instanceName,
str  recoMode 
)

Definition at line 587 of file BuildSignatureFlags.py.

587 def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
588 
589  flags.input_name = instanceName
590  flags.name = "tauLRT"
591  flags.suffix = "TauLRT"
592  flags.roi = "HLT_Roi_TauLRT"
593  flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
594  flags.pTmin = 0.8*Units.GeV
595  flags.minPT = tsetter(flags.minPT, flags.pTmin)
596  flags.etaHalfWidth = 0.4
597  flags.phiHalfWidth = 0.4
598  flags.zedHalfWidth = 225.
599  flags.UsePixelSpacePoints = False
600  flags.Triplet_D0Max = 300.
601  flags.TrackInitialD0Max = 300.
602  flags.TrackZ0Max = 500.
603  flags.nClustersMin = 8
604  flags.isLRT = True
605  #pt config
606  flags.maxRPhiImpact = 300.
607  flags.maxRPhiImpEM = 300.
608  flags.maxEta = 2.7
609  flags.doEmCaloSeed = False
610  if recoMode=="InDet":
611  flags.doTRT = True
612 
613  return flags
614 
615 
616 @signatureActions

◆ tsetter()

def python.BuildSignatureFlags.tsetter (   var,
  value 
) 
use previous type of the var and convert value to it
    for the moment just makes list of a value if needed

Definition at line 242 of file BuildSignatureFlags.py.

242 def tsetter(var, value):
243  """ use previous type of the var and convert value to it
244  for the moment just makes list of a value if needed
245  """
246  type2set = type(var)
247  typeOfValue = type(value)
248  if type2set == typeOfValue:
249  var = value
250  else:
251  basic = (bool, str, int, float, type(None))
252  if isinstance(var,basic):
253  var = value
254  else:
255  var = [value]
256 
257  return var
258 
259 
260 @signatureActions

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags

Definition at line 214 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun

Definition at line 216 of file BuildSignatureFlags.py.

◆ log

python.BuildSignatureFlags.log

Definition at line 13 of file BuildSignatureFlags.py.

◆ mode

python.BuildSignatureFlags.mode

Definition at line 217 of file BuildSignatureFlags.py.

◆ sig

python.BuildSignatureFlags.sig

Definition at line 215 of file BuildSignatureFlags.py.

python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:335
python.BuildSignatureFlags.tauIso
AthConfigFlags tauIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:317
vtune_athena.format
format
Definition: vtune_athena.py:14
python.BuildSignatureFlags.muonLRT
AthConfigFlags muonLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:558
python.BuildSignatureFlags.tauLRT
AthConfigFlags tauLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:587
python.BuildSignatureFlags.electron
AthConfigFlags electron(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:261
python.BuildSignatureFlags.addGlobalFlags
def addGlobalFlags(AthConfigFlags flags, str category)
Definition: BuildSignatureFlags.py:778
python.BuildSignatureFlags.muon
AthConfigFlags muon(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:278
run
int run(int argc, char *argv[])
Definition: ttree2hdf5.cxx:28
python.BuildSignatureFlags.defaultITkTrigTrackingFlags
AthConfigFlags defaultITkTrigTrackingFlags()
Definition: BuildSignatureFlags.py:127
python.TrackingPassFlags.createTrackingPassFlags
def createTrackingPassFlags()
create set of tracking cut flags
Definition: TrackingPassFlags.py:117
python.BuildSignatureFlags.defaultModeTrigTrackingFlags
AthConfigFlags defaultModeTrigTrackingFlags(AthConfigFlags flags)
Definition: BuildSignatureFlags.py:153
python.BuildSignatureFlags.fullScanLRT
AthConfigFlags fullScanLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:641
python.BuildSignatureFlags.signatureTrigTrackingFlags
AthConfigFlags signatureTrigTrackingFlags(str mode)
Definition: BuildSignatureFlags.py:156
python.BuildSignatureFlags.collToRecordable
def collToRecordable(flags, name)
Definition: BuildSignatureFlags.py:757
python.BuildSignatureFlags.tauCore
AthConfigFlags tauCore(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:304
python.BuildSignatureFlags.defaultInDetTrigTrackingFlags
AthConfigFlags defaultInDetTrigTrackingFlags()
Definition: BuildSignatureFlags.py:98
python.BuildSignatureFlags.bmumux
AthConfigFlags bmumux(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:516
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:472
python.BuildSignatureFlags.muonIso
AthConfigFlags muonIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:292
python.BuildSignatureFlags.defaultTrigTrackingFlags
def defaultTrigTrackingFlags(AthConfigFlags flags)
Definition: BuildSignatureFlags.py:15
python.BuildSignatureFlags.minBias
AthConfigFlags minBias(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:376
Base_Fragment.defaults
dictionary defaults
This includes now the top quark, the leptons and the bosons.
Definition: GeneratorFilters/share/common/Base_Fragment.py:79
python.processes.powheg.ZZ.ZZ.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZ.py:18
python.BuildSignatureFlags.beamSpotFS
AthConfigFlags beamSpotFS(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:452
python.BuildSignatureFlags.electronLRT
AthConfigFlags electronLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:532
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
python.BuildSignatureFlags.tsetter
def tsetter(var, value)
Definition: BuildSignatureFlags.py:242
python.TriggerEDM.recordable
def recordable(arg, runVersion=3)
Definition: TriggerEDM.py:30
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:402
python.BuildSignatureFlags.DJetLRT
AthConfigFlags DJetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:670
python.BuildSignatureFlags.DVtxLRT
AthConfigFlags DVtxLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:700
python.BuildSignatureFlags.jetSuper
AthConfigFlags jetSuper(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:350
python.BuildSignatureFlags.signatureActions
def signatureActions(func)
Definition: BuildSignatureFlags.py:232
python.BuildSignatureFlags.derivedFromSignatureFlags
def derivedFromSignatureFlags(AthConfigFlags flags, str recoMode)
Definition: BuildSignatureFlags.py:728
python.BuildSignatureFlags.fullScan
AthConfigFlags fullScan(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:421
python.TrackingPassFlags.createITkTrackingPassFlags
def createITkTrackingPassFlags()
ITk mode ####################.
Definition: TrackingPassFlags.py:215
python.BuildSignatureFlags.bjetLRT
AthConfigFlags bjetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:617
Generated on Fri May 17 2024 22:24:00 for ATLAS Offline Software by   doxygen 1.8.18