ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Functions | Variables
python.BuildSignatureFlags Namespace Reference

Classes

class  FlagValuesTest

Functions

 defaultTrigTrackingFlags (AthConfigFlags flags)
AthConfigFlags defaultInDetTrigTrackingFlags ()
AthConfigFlags defaultITkTrigTrackingFlags ()
AthConfigFlags defaultITkActsTrigTrackingFlags ()
AthConfigFlags defaultModeTrigTrackingFlags (AthConfigFlags flags)
AthConfigFlags signatureTrigTrackingFlags (str mode)
 signatureActions (func)
 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 diTau (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 minBiasPixel (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 bhh (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)
 derivedFromSignatureFlags (AthConfigFlags flags, str recoMode)
 collToRecordable (flags, name)
 addGlobalFlags (AthConfigFlags flags, str category)

Variables

 log = logging.getLogger("__name__")
 flags = flags
 sig = signatureInstance
 fun = fun
 mode = recoMode

Function Documentation

◆ addGlobalFlags()

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

Definition at line 887 of file BuildSignatureFlags.py.

887def addGlobalFlags(flags: AthConfigFlags, category : str):
888 flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
889 flags.addFlag(f'{category}.doGPU', False)
890 flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
891 flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
892 flags.addFlag(f'{category}.UseTracklets', False)
893 flags.addFlag(f'{category}.trackletPoints', 1)
894 flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
895 flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
896 flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
897 flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
898 flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
899 flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
900 flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
901 flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
902 flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
903 flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
904 flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
905 flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
906 flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
907 flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
908

◆ beamSpot()

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

Definition at line 492 of file BuildSignatureFlags.py.

492def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
493
494 flags.input_name = instanceName
495 flags.name = "beamSpot"
496 flags.suffix = "BeamSpot"
497 flags.roi = "HLT_Roi_FS"
498 flags.doFullScan = True
499 flags.doZFinder = True
500 flags.DoubletDR_Max = 200
501 flags.SeedRadBinWidth = 10
502 flags.etaHalfWidth = 3
503 flags.phiHalfWidth = math.pi
504 flags.doTRT = False
505 flags.doSeedRedundancyCheck = True
506 flags.doRecord = False
507 return flags
508
509
510@signatureActions

◆ beamSpotFS()

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

Definition at line 542 of file BuildSignatureFlags.py.

542def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
543
544 flags.input_name = instanceName
545 flags.name = "fullScan"
546 flags.suffix = "FS"
547 flags.roi = "HLT_Roi_FS"
548 flags.doFullScan = True
549 flags.etaHalfWidth = 3.
550 flags.phiHalfWidth = math.pi
551 flags.doTRT = False
552 flags.DoubletDR_Max = 200
553 flags.SeedRadBinWidth = 10
554 flags.TripletDoPPS = False
555 flags.nClustersMin = 8
556 flags.UseTrigSeedML = 4
557 flags.doRecord = False
558 return flags
559
560
561@signatureActions

◆ bhh()

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

Definition at line 619 of file BuildSignatureFlags.py.

619def bhh(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
620
621 flags.input_name = instanceName
622 flags.name = "bhh"
623 flags.suffix = "Bhh"
624 flags.roi = "HLT_Roi_Bhh"
625 flags.Triplet_D0Max = 10.
626 flags.DoPhiFiltering = False
627 flags.etaHalfWidth = 2.5
628 flags.phiHalfWidth = math.pi-1.e-5
629 flags.zedHalfWidth = 30.
630 flags.pTmin = 2*Units.GeV
631 flags.minPT = tsetter(flags.minPT, flags.pTmin)
632 flags.doSeedRedundancyCheck = True
633 flags.SuperRoI = True
634 return flags
635
636@signatureActions

◆ bjet()

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

Definition at line 376 of file BuildSignatureFlags.py.

376def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
377
378 flags.input_name = instanceName
379 flags.name = "bjet"
380 flags.suffix = "Bjet"
381 flags.roi = "HLT_Roi_Bjet"
382 flags.etaHalfWidth = 0.4
383 flags.phiHalfWidth = 0.4
384 flags.zedHalfWidth = 10.0
385 flags.pTmin = 0.8*Units.GeV
386 flags.minPT = tsetter(flags.minPT, flags.pTmin)
387 flags.Xi2max = tsetter(flags.Xi2max,12.)
388 return flags
389
390@signatureActions

◆ bjetLRT()

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

Definition at line 722 of file BuildSignatureFlags.py.

722def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
723
724 flags.input_name = instanceName
725 flags.name = "bjetLRT"
726 flags.suffix = "BjetLRT"
727 flags.roi = "HLT_Roi_Bjet"
728 flags.etaHalfWidth = 0.4
729 flags.phiHalfWidth = 0.4
730 flags.UsePixelSpacePoints = False
731 flags.Triplet_D0Max = 300.
732 flags.TrackInitialD0Max = 300.
733 flags.TrackZ0Max = 500.
734 flags.nClustersMin = 8
735 flags.isLRT = True
736 #pt config
737 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
738 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
739 flags.maxEta = 2.7
740 flags.doEmCaloSeed = False
741
742 return flags
743
744
745@signatureActions

◆ bmumux()

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

Definition at line 603 of file BuildSignatureFlags.py.

603def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
604
605 flags.input_name = instanceName
606 flags.name = "bphysics"
607 flags.suffix = "Bmumux"
608 flags.roi = "HLT_Roi_Bmumux"
609 flags.Triplet_D0Max = 10.
610 flags.DoPhiFiltering = False
611 flags.etaHalfWidth = 0.75
612 flags.phiHalfWidth = 0.75
613 flags.zedHalfWidth = 50.
614 flags.doSeedRedundancyCheck = True
615 flags.SuperRoI = True
616 return flags
617
618@signatureActions

◆ collToRecordable()

python.BuildSignatureFlags.collToRecordable ( flags,
name )

Definition at line 864 of file BuildSignatureFlags.py.

864def collToRecordable(flags,name):
865 # ToDo: should just be a flag set per signature in the per signature config
866 # and not setting parameters using tests on the signature name
867 ret = name
868 signature = flags.input_name
869 firstStage = True if "FTF" in name else False
870 record = True
871 if firstStage:
872 if signature in ["minBias","minBiasPixel","bjetLRT",
873 "beamSpot","BeamSpot"]:
874 record = False
875 else:
876 if signature in ["tauCore","tauIso","tauIsoBDT",
877 "jet","fullScan","FS","jetSuper","bhh",
878 "beamSpot", "BeamSpot","beamSpotFS",
879 "bjetLRT","DJetLRT","DVtxLRT"]:
880 record = False
881
882 if record:
883 ret = recordable(name)
884
885 return ret
886

◆ cosmics()

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

Definition at line 562 of file BuildSignatureFlags.py.

562def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
563
564 flags.input_name = instanceName
565 flags.name = "cosmics"
566 flags.suffix = "Cosmic"
567 flags.roi = "HLT_Roi_Cosmics"
568 flags.Triplet_D0Max = 1000.0
569 flags.Triplet_D0_PPS_Max = 1000.0
570 flags.TrackInitialD0Max = 1000.
571 flags.TrackZ0Max = 1000.
572 flags.doTRT = False
573 flags.doFullScan = True
574 flags.etaHalfWidth = 3
575 flags.phiHalfWidth = math.pi
576
577 flags.minPT = tsetter(flags.minPT, 0.5*Units.GeV)
578
579 flags.nClustersMin = 4
580 flags.minSiNotShared = 3
581 flags.maxShared = 0
582 flags.nHolesMax = 3
583 flags.maxSiHoles = 3
584 flags.maxSCTHoles = 3
585 flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
586 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
587
588 flags.Xi2max = tsetter(flags.Xi2max, 60.)
589 flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
590 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
591
592 flags.nWeightedClustersMin= 8
593 flags.useSeedFilter = True
594 flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
595 flags.roadWidth = 75.
596 flags.maxZImpact= tsetter(flags.maxZImpact, 10000.*Units.mm)
597 if recoMode=="InDet":
598 flags.minTRTonTrk = 20
599
600 return flags
601
602@signatureActions

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 95 of file BuildSignatureFlags.py.

95def defaultInDetTrigTrackingFlags() -> AthConfigFlags:
96
97 flags = createTrackingPassFlags()
98 defaultTrigTrackingFlags(flags)
99
100 flags.minPT = flags.pTmin #hack to sync pT threshold used in offline and trigger
101
102 flags.minClusters = 7 #hardcoded to preserve trigger settings (not used for FTF config)
103 flags.minSiNotShared = 5
104 flags.maxShared = 2
105 flags.Xi2max = 9.
106 flags.Xi2maxNoAdd = 25.
107 flags.nHolesMax = 2
108 flags.nHolesGapMax = 2
109 flags.nWeightedClustersMin= 6
110 flags.roadWidth =10.
111
112
113 flags.maxPrimaryImpact = 10.
114 flags.maxEMImpact = 50.
115 flags.maxZImpact = 250.
116
117 flags.minTRTonTrk =9
118
119 #TODO - simple ambiguitues
120 flags.useTIDE_Ambi = False
121
122 #2023fix - it should read 2
123 flags.maxSiHoles = 5
124 flags.maxSCTHoles = 5
125 #end
126
127 return flags
128

◆ defaultITkActsTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkActsTrigTrackingFlags ( )

Definition at line 155 of file BuildSignatureFlags.py.

155def defaultITkActsTrigTrackingFlags() -> AthConfigFlags:
156 flags = createActsTrackingPassFlags()
157 defaultTrigTrackingFlags(flags)
158
159 flags.minPT = [0.9*Units.GeV, 0.4*Units.GeV, 0.4*Units.GeV]
160 flags.minClusters = [9, 8, 7]
161 flags.doTRT = False
162 flags.maxEta = 4.0
163 flags.maxShared = [2]
164 flags.maxHoles = [1]
165 flags.maxPixelHoles = [2]
166 flags.maxSctHoles = [2]
167 flags.maxShared = [2]
168 flags.maxDoubleHoles = [1]
169 return flags
170

◆ defaultITkTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkTrigTrackingFlags ( )

Definition at line 129 of file BuildSignatureFlags.py.

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

◆ defaultModeTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultModeTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 171 of file BuildSignatureFlags.py.

171def defaultModeTrigTrackingFlags(flags: AthConfigFlags) -> AthConfigFlags:
172 return flags
173

◆ defaultTrigTrackingFlags()

python.BuildSignatureFlags.defaultTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 16 of file BuildSignatureFlags.py.

16def defaultTrigTrackingFlags(flags : AthConfigFlags):
17
18 flags.addFlag("input_name", "")
19 flags.addFlag("name", "")
20 flags.addFlag("suffix", "")
21
22 flags.addFlag("pTmin", 1.*Units.GeV) #fix - consolidate pTmin and minPT
23 flags.addFlag("TripletDoPPS", True)
24 flags.addFlag("Triplet_D0Max", 4.0)
25 flags.addFlag("Triplet_D0_PPS_Max", 1.7)
26 flags.addFlag("DoPhiFiltering", True)
27 flags.addFlag("doZFinder", False)
28 flags.addFlag("doZFinderOnly", False)
29 flags.addFlag("doResMon", False)
30 flags.addFlag("doCloneRemoval", True)
31 flags.addFlag("doSeedRedundancyCheck",False)
32 flags.addFlag("DoubletDR_Max", 270)
33 flags.addFlag("SeedRadBinWidth", 2)
34 flags.addFlag("holeSearch_FTF", False)
35 flags.addFlag("electronPID", False)
36 flags.addFlag("etaHalfWidth", 0.1)
37 flags.addFlag("phiHalfWidth", 0.1)
38 flags.addFlag("zedHalfWidth", -999) # don't set this parameter unless it is >= 0)
39 flags.addFlag("doFullScan", False)
40 flags.addFlag("monPS", 1)
41 flags.addFlag("monPtMin", 1*Units.GeV)
42 flags.addFlag("doTRT", True)
43 flags.addFlag("keepTrackParameters", False) # Keep track parameters in conversion to TrackParticles
44 flags.addFlag("UsePixelSpacePoints", True)
45 flags.addFlag("TrackInitialD0Max", 20.0)
46 flags.addFlag("TrackZ0Max", 300.0)
47 flags.addFlag("isLRT", False)
48 flags.addFlag("UseTrigSeedML", 0)
49 flags.addFlag("nClustersMin", 7)
50 flags.addFlag("roi", "")
51 flags.addFlag("LRT_D0Min", 2.0)
52 flags.addFlag("LRT_HardPtMin", 1.0*Units.GeV)
53 flags.addFlag("doRecord", True)
54 flags.addFlag("vertex", "")
55 flags.addFlag("adaptiveVertex", False)
56 flags.addFlag("addSingleTrackVertices", False)
57 flags.addFlag("TracksMaxZinterval", 1) #mm
58 flags.addFlag("minNSiHits_vtx", 10) #from vtxCuts
59 flags.addFlag("vertex_jet", "")
60 flags.addFlag("adaptiveVertex_jet", False)
61 flags.addFlag("dodEdxTrk", False)
62 flags.addFlag("doHitDV", False)
63 flags.addFlag("doDisappearingTrk", False)
64 flags.addFlag("useDynamicRoiZWidth", False)
65
66
67 #precision tracking configuration values
68 #__provisional change__:
69 #the following settings are incorrect but this is what is being used in the production running
70 #at the moment. Setting them explicitly here will prevent trigger count differences in
71 #https://gitlab.cern.ch/atlas/athena/-/merge_requests/56607
72 flags.maxEta = 2.7
73 flags.addFlag("minSiClusters", 7)
74 flags.addFlag("maxSiHoles", 5)
75 flags.maxPixelHoles = 5
76 flags.addFlag("maxSCTHoles", 5) #fix2024 - consolidate names maxSctHoles and others in addFlag here
77 flags.maxDoubleHoles = 2
78 flags.addFlag("doEmCaloSeed", False)
79
80 flags.useSeedFilter = False
81 flags.doBremRecoverySi = False #fix2023 setTrue for electron once validated
82
83 flags.addFlag("refitROT", True)
84 flags.addFlag("trtExtensionType", "xf")
85 flags.addFlag("doTruth", False)
86 flags.addFlag("perigeeExpression","BeamLine") #always use beamline regardless of Reco.EnableHI
87 flags.addFlag("SuperRoI", False) #TBD - move to bphys/menu
88
89 flags.addFlag("trkTracks_FTF", "")
90 flags.addFlag("trkTracks_IDTrig","")
91 flags.addFlag("tracks_FTF", "")
92 flags.addFlag("tracks_IDTrig", "")
93 flags.addFlag("useGBTSeedingTool", False)
94

◆ derivedFromSignatureFlags()

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

Definition at line 833 of file BuildSignatureFlags.py.

833def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
834
835 flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
836 flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
837 flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
838 # ToDo: shouldn't be setting flags using this if type structures, the flags should be
839 # actually set somewhere in appropriate config functions
840 flags.tracks_IDTrig = collToRecordable(flags,"HLT_IDTrack_{}_IDTrig".format(flags.suffix if flags.input_name != "tauIso" else "Tau"))
841
842 if recoMode == "Acts":
843 flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
844 flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
845
846 if flags.isLRT: # to be moved to a separate function once LRTs differ
847 flags.minClusters = tsetter(flags.minClusters , 8)
848 flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
849 flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
850 flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
851 flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
852 flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
853 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
854 flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
855
856
857 if recoMode == "ITk":
858 flags.extension = flags.input_name #needed in the ITk mode?
859
860 if flags.isLRT:
861 flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
862
863

◆ diTau()

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

Definition at line 358 of file BuildSignatureFlags.py.

358def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
359
360 flags.input_name = instanceName
361 flags.name = "diTau"
362 flags.suffix = "DiTau"
363 flags.roi = "HLT_Roi_DiTau"
364 flags.etaHalfWidth = 1.0
365 flags.phiHalfWidth = 1.0
366 flags.zedHalfWidth = 7.0
367 flags.adaptiveVertex = True
368 flags.addSingleTrackVertices = True
369 flags.vertex = "HLT_IDVertex_DiTau"
370 flags.electronPID = False
371 flags.pTmin = 0.8*Units.GeV
372 flags.minPT = tsetter(flags.minPT, flags.pTmin)
373 return flags
374
375@signatureActions

◆ DJetLRT()

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

Definition at line 775 of file BuildSignatureFlags.py.

775def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
776
777 flags.input_name = instanceName
778 flags.name = "DJetLRT"
779 flags.suffix = "DJLRT"
780 flags.roi = "HLT_Roi_DJ"
781 flags.doFullScan = False
782 flags.etaHalfWidth = 0.4
783 flags.phiHalfWidth = 0.4
784 flags.zedHalfWidth = 225.
785 flags.doTRT = False
786 flags.doSeedRedundancyCheck = True
787 flags.UsePixelSpacePoints = False
788 flags.Triplet_D0Max = 300.
789 flags.TrackInitialD0Max = 300.
790 flags.TrackZ0Max = 500.
791 flags.Triplet_D0_PPS_Max = 300.
792 flags.DoubletDR_Max = 200
793 flags.nClustersMin = 8
794 flags.isLRT = True
795 #pt config
796 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
797 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
798 flags.maxEta = 2.7
799 flags.doEmCaloSeed = False
800
801 return flags
802
803
804@signatureActions

◆ DVtxLRT()

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

Definition at line 805 of file BuildSignatureFlags.py.

805def DVtxLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
806
807 flags.input_name = instanceName
808 flags.name = "DVtxLRT"
809 flags.suffix = "DVLRT"
810 flags.roi = "HLT_Roi_DV"
811 flags.doFullScan = False
812 flags.etaHalfWidth = 0.35
813 flags.phiHalfWidth = 0.35
814 flags.doTRT = False
815 flags.doSeedRedundancyCheck = True
816 flags.UsePixelSpacePoints = False
817 flags.Triplet_D0Max = 300.
818 flags.TrackInitialD0Max = 300.
819 flags.TrackZ0Max = 500.
820 flags.Triplet_D0_PPS_Max = 300.
821 flags.DoubletDR_Max = 200
822 flags.nClustersMin = 8
823 flags.isLRT = True
824 #pt config
825 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
826 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
827 flags.maxEta = 2.7
828 flags.doEmCaloSeed = False
829
830 return flags
831
832

◆ electron()

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

Definition at line 284 of file BuildSignatureFlags.py.

284def electron(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
285
286 flags.input_name = instanceName
287 flags.name = "electron"
288 flags.suffix = "Electron"
289 flags.roi = "HLT_Roi_Electron"
290 flags.etaHalfWidth = 0.05 # this size should be increased to 0.1
291 flags.phiHalfWidth = 0.1
292 flags.doCloneRemoval = True
293 flags.doSeedRedundancyCheck = True
294 if recoMode=="InDet":
295 flags.doTRT = True
296 flags.keepTrackParameters = True
297 flags.electronPID = True
298 return flags
299
300@signatureActions

◆ electronLRT()

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

Definition at line 637 of file BuildSignatureFlags.py.

637def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
638
639 flags.input_name = instanceName
640 flags.name = "electronLRT"
641 flags.suffix = "ElecLRT"
642 flags.roi = "HLT_Roi_Electron"
643 flags.etaHalfWidth = 0.1
644 flags.phiHalfWidth = 0.4
645 flags.UsePixelSpacePoints = False
646 flags.Triplet_D0Max = 300.
647 flags.TrackInitialD0Max = 300.
648 flags.TrackZ0Max = 500.
649 flags.zedHalfWidth = 225.
650 flags.keepTrackParameters = True
651 flags.doSeedRedundancyCheck = True
652 flags.nClustersMin = 8
653 flags.isLRT = True
654 #pt config
655 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
656 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
657 flags.maxEta = 2.7
658 flags.doEmCaloSeed = False
659 return flags
660
661
662@signatureActions

◆ fullScan()

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

Definition at line 511 of file BuildSignatureFlags.py.

511def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
512
513 flags.input_name = instanceName
514 flags.name = "fullScan"
515 flags.suffix = "FS"
516 flags.roi = "HLT_Roi_FS"
517 flags.vertex = "HLT_IDVertex_FS"
518 flags.adaptiveVertex = True
519 # these are being evaluated and may be added
520 # flags.addSingleTrackVertices = True
521 # flags.TracksMaxZinterval = 3
522 flags.vertex_jet = "HLT_IDVertex_FS"
523 flags.adaptiveVertex_jet = True
524 flags.doFullScan = True
525 flags.etaHalfWidth = 3.
526 flags.phiHalfWidth = math.pi
527 flags.doTRT = False
528 flags.DoubletDR_Max = 200
529 flags.SeedRadBinWidth = 10
530 flags.doSeedRedundancyCheck = True
531 flags.TripletDoPPS = False
532 flags.nClustersMin = 8
533 flags.UseTrigSeedML = 4
534 flags.dodEdxTrk = True
535 flags.doHitDV = True
536 flags.doDisappearingTrk = True if recoMode=="InDet" else False
537 flags.roadWidth = 5.
538 return flags
539
540
541@signatureActions

◆ fullScanLRT()

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

Definition at line 746 of file BuildSignatureFlags.py.

746def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
747
748 flags.input_name = instanceName
749 flags.name = "fullScanLRT"
750 flags.suffix = "FSLRT"
751 flags.roi = "HLT_Roi_FS"
752 flags.doFullScan = True
753 flags.etaHalfWidth = 3.
754 flags.phiHalfWidth = math.pi
755 flags.doTRT = False
756 flags.doSeedRedundancyCheck = True
757 flags.UsePixelSpacePoints = False
758 flags.Triplet_D0Max = 300.
759 flags.TrackInitialD0Max = 300.
760 flags.TrackZ0Max = 500.
761 flags.Triplet_D0_PPS_Max = 300.
762 flags.DoubletDR_Max = 200
763 flags.nClustersMin = 8
764 flags.isLRT = True
765 #pt config
766 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
767 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
768 flags.maxEta = 2.7
769 flags.doEmCaloSeed = False
770
771 return flags
772
773
774@signatureActions

◆ jetSuper()

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

Definition at line 391 of file BuildSignatureFlags.py.

391def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
392
393 flags.input_name = instanceName
394 flags.name = "jetSuper"
395 flags.suffix = "JetSuper"
396 flags.vertex = "HLT_IDVertex_JetSuper"
397 flags.adaptiveVertex = True
398 flags.addSingleTrackVertices = True
399 flags.roi = "HLT_Roi_JetSuper"
400 flags.etaHalfWidth = 0.3
401 flags.phiHalfWidth = 0.3
402 flags.doFullScan = True
403 flags.pTmin = 1*Units.GeV
404 flags.minPT = tsetter(flags.minPT, flags.pTmin)
405 #-----
406 flags.doTRT = False
407 flags.DoubletDR_Max = 200
408 flags.SeedRadBinWidth = 10
409 flags.doSeedRedundancyCheck = True
410 flags.TripletDoPPS = False
411 flags.nClustersMin = 8
412 flags.UseTrigSeedML = 4
413 flags.roadWidth = 5.
414 return flags
415
416@signatureActions

◆ minBias()

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

Definition at line 417 of file BuildSignatureFlags.py.

417def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
418
419 flags.input_name = instanceName
420 flags.name = "minBias"
421 flags.suffix = "MinBias"
422 flags.roi = "HLT_Roi_MinBias"
423 flags.doFullScan = True
424 flags.pTmin = 0.1*Units.GeV # TODO: double check
425 flags.minPT = tsetter(flags.minPT, flags.pTmin)
426
427 flags.doTRT = False
428 flags.etaHalfWidth = 3
429 flags.phiHalfWidth = math.pi
430 flags.doZFinder = True
431 flags.doZFinderOnly = True
432
433 flags.nClustersMin = 5
434 flags.useSeedFilter = True
435 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
436 flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
437 flags.roadWidth = 20
438 flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
439 return flags
440
441
442@signatureActions

◆ minBiasPixel()

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

Definition at line 443 of file BuildSignatureFlags.py.

443def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
444
445 flags.input_name = instanceName
446 flags.name = "minBiasPixel"
447 flags.suffix = "MinBiasPixel"
448 flags.roi = "HLT_Roi_MinBias"
449 flags.doFullScan = True
450 flags.pTmin = 0.1*Units.GeV # this is good for HI which is the client of this setup
451 flags.minPT = tsetter(flags.minPT, flags.pTmin)
452
453
454 flags.maxHoles = 0 # HI setup
455 flags.maxPixelHoles = 0 # HI setup
456 flags.maxSctHoles = 0
457 flags.maxDoubleHoles = 0
458 flags.minSiNotShared = 3
459 flags.maxShared = 0
460 flags.nHolesMax = 0
461 flags.nHolesGapMax = 0
462 if recoMode=="InDet":
463 flags.useSCT = False
464 flags.useSCTSeeding = False
465 flags.useTRT = False
466
467 flags.roadWidth = 12.0
468 flags.Xi2max = 15
469 flags.Xi2maxNoAdd = 35.0
470 flags.nWeightedClustersMin = 6
471 flags.doBremRecoverySi = False
472 flags.RunPixelPID = False # we use these tracks only for counting
473
474 flags.doTRT = False
475 flags.etaHalfWidth = 3
476 flags.phiHalfWidth = math.pi
477 flags.doZFinder = False
478 flags.doZFinderOnly = True
479
480 flags.minClusters = 3
481 flags.nClustersMin = 3
482 flags.useSeedFilter = True
483 flags.maxPrimaryImpact = 10.*Units.mm
484 flags.maxZImpact = 150.*Units.mm
485 flags.roadWidth = 20
486 flags.usePrdAssociationTool = False
487 return flags
488
489
490
491@signatureActions

◆ muon()

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

Definition at line 301 of file BuildSignatureFlags.py.

301def muon(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
302
303 flags.input_name = instanceName
304 flags.name = "muon"
305 flags.suffix = "Muon"
306 flags.roi = "HLT_Roi_L2SAMuon"
307 flags.Triplet_D0Max = 10.0
308 flags.doResMon = True
309 flags.DoPhiFiltering = False
310 flags.doSeedRedundancyCheck = True
311 flags.monPtMin = 12*Units.GeV
312 return flags
313
314@signatureActions

◆ muonIso()

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

Definition at line 315 of file BuildSignatureFlags.py.

315def muonIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
316
317 flags.input_name = instanceName
318 flags.name = "muonIso"
319 flags.suffix = "MuonIso"
320 flags.roi = "HLT_Roi_MuonIso"
321 flags.etaHalfWidth = 0.35
322 flags.phiHalfWidth = 0.35
323 flags.zedHalfWidth = 10.0
324 return flags
325
326@signatureActions

◆ muonLRT()

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

Definition at line 663 of file BuildSignatureFlags.py.

663def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
664
665 flags.input_name = instanceName
666 flags.name = "muonLRT"
667 flags.suffix = "MuonLRT"
668 flags.roi = "HLT_Roi_Muon"
669 flags.UsePixelSpacePoints = False
670 flags.etaHalfWidth = 0.2
671 flags.phiHalfWidth = 0.4
672 flags.Triplet_D0Max = 300.
673 flags.TrackInitialD0Max = 300.
674 flags.TrackZ0Max = 500.
675 flags.zedHalfWidth = 225.
676 flags.doSeedRedundancyCheck = True
677 flags.nClustersMin = 8
678 flags.isLRT = True
679 flags.doResMon = True
680 flags.DoPhiFiltering = False
681 #pt config
682 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
683 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
684 flags.maxEta = 2.7
685 flags.doEmCaloSeed = False
686
687 return flags
688
689
690
691@signatureActions

◆ signatureActions()

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

Definition at line 255 of file BuildSignatureFlags.py.

255def signatureActions(func):
256 """ convenience decorator to automate config steps """
257 def invokeSteps(*args, **kwargs):
258 flagsSig = func(*args, **kwargs) #invoke signature specific code
259 recoMode = args[2]
260 derivedFromSignatureFlags(flagsSig,recoMode) #invoke code dependant on signature flags
261 return flagsSig
262 return invokeSteps
263
264

◆ signatureTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.signatureTrigTrackingFlags ( str mode)

Definition at line 174 of file BuildSignatureFlags.py.

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
190 "diTau" : diTau,
191
192 "bjet" : bjet,
193
194 "fullScan" : fullScan,
195 "FS" : fullScan,
196 "jetSuper" : jetSuper,
197
198 "beamSpot" : beamSpot,
199 "BeamSpot" : beamSpot,
200 "beamSpotFS" : beamSpotFS,
201
202 "cosmics" : cosmics,
203 "bmumux" : bmumux,
204 "bhh" : bhh,
205
206 "minBias" : minBias,
207 "minBiasPixel" : minBiasPixel,
208
209 "electronLRT" : electronLRT,
210 "muonLRT" : muonLRT,
211 "tauLRT" : tauLRT,
212 "bjetLRT" : bjetLRT,
213 "fullScanLRT" : fullScanLRT,
214 "DJetLRT" : DJetLRT,
215 "DVtxLRT" : DVtxLRT,
216 }
217
218 flags = AthConfigFlags()
219
220 if mode == "InDet":
221 category = 'Trigger.InDetTracking'
222 defaults = defaultInDetTrigTrackingFlags
223 elif mode == "ITk":
224 category = 'Trigger.ITkTracking'
225 defaults = defaultITkTrigTrackingFlags
226 elif mode == "Acts":
227 category = "Trigger.ActsTracking"
228 defaults = defaultITkActsTrigTrackingFlags
229 else:
230 log.error("Unsupported reconstruction mode %s", mode)
231
232
233 class categoryGeneratorWrapper():
234 """ wrap function which can be consumed by addFlagsCategory and provide its args """
235 def __init__(self, fun : Callable[[AthConfigFlags, str, str], AthConfigFlags],
236 flags : AthConfigFlags, signatureInstance : str, recoMode : str):
237 self.flags = flags
238 self.sig = signatureInstance
239 self.fun = fun
240 self.mode= recoMode
241 def run(self):
242 return self.fun(self.flags,self.sig,self.mode)
243
244 for i in signatureSet.keys():
245 trackingflags = deepcopy(defaults())
246 a = categoryGeneratorWrapper(signatureSet[i],trackingflags,i,mode)
247 signatureCategory = "{}.{}".format(category,i)
248 flags.addFlagsCategory(signatureCategory,a.run,prefix=True)
249
250 addGlobalFlags(flags, category) # they should not be needed / backward compatibility
251
252 return flags
253
254
run
int run(int argc, char *argv[])
Definition ttree2hdf5.cxx:28

◆ tauCore()

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

Definition at line 327 of file BuildSignatureFlags.py.

327def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
328
329 flags.input_name = instanceName
330 flags.name = "tauCore"
331 flags.suffix = "TauCore"
332 flags.roi = "HLT_Roi_TauCore"
333 flags.pTmin = 0.8*Units.GeV
334 flags.minPT = tsetter(flags.minPT, flags.pTmin)
335
336 flags.holeSearch_FTF = True
337 return flags
338
339@signatureActions

◆ tauIso()

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

Definition at line 340 of file BuildSignatureFlags.py.

340def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
341
342 flags.input_name = instanceName
343 flags.name = "tauIso"
344 flags.suffix = "TauIso"
345 flags.roi = "HLT_Roi_TauIso"
346 flags.etaHalfWidth = 0.4
347 flags.phiHalfWidth = 0.4
348 flags.zedHalfWidth = 7.0
349 flags.adaptiveVertex = True
350 flags.addSingleTrackVertices = True
351 flags.vertex = "HLT_IDVertex_Tau"
352 flags.electronPID = False
353 flags.pTmin = 0.8*Units.GeV
354 flags.minPT = tsetter(flags.minPT, flags.pTmin)
355 return flags
356
357@signatureActions

◆ tauLRT()

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

Definition at line 692 of file BuildSignatureFlags.py.

692def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
693
694 flags.input_name = instanceName
695 flags.name = "tauLRT"
696 flags.suffix = "TauLRT"
697 flags.roi = "HLT_Roi_TauLRT"
698 flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
699 flags.pTmin = 0.8*Units.GeV
700 flags.minPT = tsetter(flags.minPT, flags.pTmin)
701 flags.etaHalfWidth = 0.4
702 flags.phiHalfWidth = 0.4
703 flags.zedHalfWidth = 225.
704 flags.UsePixelSpacePoints = False
705 flags.Triplet_D0Max = 300.
706 flags.TrackInitialD0Max = 300.
707 flags.TrackZ0Max = 500.
708 flags.nClustersMin = 8
709 flags.isLRT = True
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 if recoMode=="InDet":
716 flags.doTRT = True
717
718 return flags
719
720
721@signatureActions

◆ tsetter()

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 265 of file BuildSignatureFlags.py.

265def tsetter(var, value):
266 """ use previous type of the var and convert value to it
267 for the moment just makes list of a value if needed
268 """
269 type2set = type(var)
270 typeOfValue = type(value)
271 if type2set == typeOfValue:
272 var = value
273 else:
274 basic = (bool, str, int, float, type(None))
275 if isinstance(var,basic):
276 var = value
277 else:
278 var = [value]
279
280 return var
281
282
283@signatureActions
type

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags = flags

Definition at line 237 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun = fun

Definition at line 239 of file BuildSignatureFlags.py.

◆ log

python.BuildSignatureFlags.log = logging.getLogger("__name__")

Definition at line 14 of file BuildSignatureFlags.py.

◆ mode

python.BuildSignatureFlags.mode = recoMode

Definition at line 240 of file BuildSignatureFlags.py.

◆ sig

python.BuildSignatureFlags.sig = signatureInstance

Definition at line 238 of file BuildSignatureFlags.py.

Generated on for ATLAS Offline Software by doxygen 1.14.0