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 ()
None actsLRTTrigTrackingFlags (AthConfigFlags flags)
AthConfigFlags defaultModeTrigTrackingFlags (AthConfigFlags flags)
AthConfigFlags signatureTrigTrackingFlags (str mode)
 signatureActions (func)
 lrtSignatureActions (func)
 tsetter (var, value)
 processEtaDepSettings (var, settings)
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 tauHitsHitZ (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags tauCore (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags tauCoreEM (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags tauCoreHitZ (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags tauIso (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags tauIsoEM (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags tauIsoHitZ (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

◆ actsLRTTrigTrackingFlags()

None actsLRTTrigTrackingFlags ( AthConfigFlags flags) 
Apply the Acts-specific steering and cuts needed by trigger LRT.

Definition at line 164 of file BuildSignatureFlags.py.

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 # chi2 cuts 25 / 50 for 1D measurements, in sigma of a 1D Gaussian
175 flags.Xi2maxSigma = [5.0]
176 flags.Xi2maxNoAddSigma = [math.sqrt(50.0)]
177

◆ addGlobalFlags()

addGlobalFlags ( AthConfigFlags flags,
str category )

Definition at line 934 of file BuildSignatureFlags.py.

934def addGlobalFlags(flags: AthConfigFlags, category : str):
935 flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
936 flags.addFlag(f'{category}.doGPU', False)
937 flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
938 flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
939 flags.addFlag(f'{category}.UseTracklets', False)
940 flags.addFlag(f'{category}.trackletPoints', 1)
941 flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
942 flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
943 flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
944 flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
945 flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
946 flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
947 flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
948 flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
949 flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
950 flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
951 flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
952 flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
953 flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
954 flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
955

◆ beamSpot()

AthConfigFlags beamSpot ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 554 of file BuildSignatureFlags.py.

554def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
555
556 flags.input_name = instanceName
557 flags.name = "beamSpot"
558 flags.suffix = "BeamSpot"
559 flags.roi = "HLT_Roi_FS"
560 flags.doZFinder = True
561 flags.DoubletDR_Max = 200
562 flags.SeedRadBinWidth = 10
563 flags.etaHalfWidth = 3
564 flags.phiHalfWidth = math.pi
565 flags.doTRT = False
566 flags.doSeedRedundancyCheck = True
567 return flags
568
569
570@signatureActions

◆ beamSpotFS()

AthConfigFlags beamSpotFS ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 600 of file BuildSignatureFlags.py.

600def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
601
602 flags.input_name = instanceName
603 flags.name = "fullScan"
604 flags.suffix = "FS"
605 flags.roi = "HLT_Roi_FS"
606 flags.etaHalfWidth = 3.
607 flags.phiHalfWidth = math.pi
608 flags.doTRT = False
609 flags.DoubletDR_Max = 200
610 flags.SeedRadBinWidth = 10
611 flags.TripletDoPPS = False
612 flags.nClustersMin = 8
613 flags.UseTrigSeedML = 4
614 return flags
615
616
617@signatureActions

◆ bhh()

AthConfigFlags bhh ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 676 of file BuildSignatureFlags.py.

676def bhh(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
677
678 flags.input_name = instanceName
679 flags.name = "bhh"
680 flags.suffix = "Bhh"
681 flags.roi = "HLT_Roi_Bhh"
682 flags.Triplet_D0Max = 10.
683 flags.DoPhiFiltering = False
684 flags.etaHalfWidth = 2.5
685 flags.phiHalfWidth = math.pi-1.e-5
686 flags.zedHalfWidth = 30.
687 flags.minPT = processEtaDepSettings(flags.minPT,[2*Units.GeV])
688
689 flags.doSeedRedundancyCheck = True
690 return flags
691
692@lrtSignatureActions

◆ bjet()

AthConfigFlags bjet ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 443 of file BuildSignatureFlags.py.

443def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
444
445 flags.input_name = instanceName
446 flags.name = "bjet"
447 flags.suffix = "Bjet"
448 flags.roi = "HLT_Roi_Bjet"
449 flags.etaHalfWidth = 0.4
450 flags.phiHalfWidth = 0.4
451 flags.zedHalfWidth = 10.0
452 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
453 flags.Xi2max = tsetter(flags.Xi2max,12.)
454 if recoMode == "Acts":
455 flags.Xi2maxSigma = [math.sqrt(12.)]
456 return flags
457
458@signatureActions

◆ bjetLRT()

AthConfigFlags bjetLRT ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 774 of file BuildSignatureFlags.py.

774def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
775
776 flags.input_name = instanceName
777 flags.name = "bjetLRT"
778 flags.suffix = "BjetLRT"
779 flags.roi = "HLT_Roi_Bjet"
780 flags.etaHalfWidth = 0.4
781 flags.phiHalfWidth = 0.4
782 flags.UsePixelSpacePoints = False
783 flags.Triplet_D0Max = 300.
784 flags.TrackInitialD0Max = 300.
785 flags.TrackZ0Max = 500.
786 flags.nClustersMin = 8
787 #pt config
788 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
789 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
790 flags.maxEta = 2.7
791 flags.doEmCaloSeed = False
792
793 return flags
794
795
796@lrtSignatureActions

◆ bmumux()

AthConfigFlags bmumux ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 661 of file BuildSignatureFlags.py.

661def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
662
663 flags.input_name = instanceName
664 flags.name = "bphysics"
665 flags.suffix = "Bmumux"
666 flags.roi = "HLT_Roi_Bmumux"
667 flags.Triplet_D0Max = 10.
668 flags.DoPhiFiltering = False
669 flags.etaHalfWidth = 0.75
670 flags.phiHalfWidth = 0.75
671 flags.zedHalfWidth = 50.
672 flags.doSeedRedundancyCheck = True
673 return flags
674
675@signatureActions

◆ collToRecordable()

collToRecordable ( flags,
name )

Definition at line 911 of file BuildSignatureFlags.py.

911def collToRecordable(flags,name):
912 # ToDo: should just be a flag set per signature in the per signature config
913 # and not setting parameters using tests on the signature name
914 ret = name
915 signature = flags.input_name
916 firstStage = "FTF" in name
917 record = True
918 if firstStage:
919 if signature in ["tauHitsHitZ","minBias","minBiasPixel","bjetLRT",
920 "beamSpot"]:
921 record = False
922 else:
923 if signature in ["tauHitsHitZ","tauCore","tauCoreEM","tauCoreHitZ","tauIso","tauIsoEM","tauIsoHitZ","tauIsoBDT",
924 "jet","fullScan","jetSuper","bhh",
925 "beamSpot","beamSpotFS",
926 "bjetLRT","DJetLRT","DVtxLRT"]:
927 record = False
928
929 if record:
930 ret = recordable(name)
931
932 return ret
933

◆ cosmics()

AthConfigFlags cosmics ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 618 of file BuildSignatureFlags.py.

618def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
619
620 flags.input_name = instanceName
621 flags.name = "cosmics"
622 flags.suffix = "Cosmic"
623 flags.roi = "HLT_Roi_Cosmics"
624 flags.Triplet_D0Max = 1000.0
625 flags.Triplet_D0_PPS_Max = 1000.0
626 flags.TrackInitialD0Max = 1000.
627 flags.TrackZ0Max = 1000.
628 flags.doTRT = False
629 flags.etaHalfWidth = 3
630 flags.phiHalfWidth = math.pi
631
632 flags.minPT = processEtaDepSettings(flags.minPT,[0.5*Units.GeV])
633
634 flags.nClustersMin = 4
635 flags.minSiNotShared = 3
636 flags.maxShared = 0
637 flags.nHolesMax = 3
638 flags.maxSiHoles = 3
639 flags.maxSCTHoles = 3
640 flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
641 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
642
643 flags.Xi2max = tsetter(flags.Xi2max, 60.)
644 flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
645 if recoMode == "Acts":
646 flags.Xi2maxSigma = [math.sqrt(60.)]
647 flags.Xi2maxNoAddSigma = [10.]
648 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
649
650 flags.nWeightedClustersMin = 8
651 flags.useSeedFilter = True
652 flags.usePrdAssociationTool= False #for backward compatibility #2023fix?
653 flags.roadWidth = 75.
654 flags.maxZImpact = tsetter(flags.maxZImpact, 10000.*Units.mm)
655 if recoMode=="InDet":
656 flags.minTRTonTrk = 20
657
658 return flags
659
660@signatureActions

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags defaultInDetTrigTrackingFlags ( )

Definition at line 87 of file BuildSignatureFlags.py.

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

◆ defaultITkActsTrigTrackingFlags()

AthConfigFlags defaultITkActsTrigTrackingFlags ( )

Definition at line 147 of file BuildSignatureFlags.py.

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

◆ defaultITkTrigTrackingFlags()

AthConfigFlags defaultITkTrigTrackingFlags ( )

Definition at line 120 of file BuildSignatureFlags.py.

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

◆ defaultModeTrigTrackingFlags()

AthConfigFlags defaultModeTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 178 of file BuildSignatureFlags.py.

178def defaultModeTrigTrackingFlags(flags: AthConfigFlags) -> AthConfigFlags:
179 return flags
180

◆ defaultTrigTrackingFlags()

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("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

◆ derivedFromSignatureFlags()

derivedFromSignatureFlags ( AthConfigFlags flags,
str recoMode )

Definition at line 878 of file BuildSignatureFlags.py.

878def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
879
880 flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
881 flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
882 flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
883
884 # ToDo: shouldn't be setting flags using this if type structures, the flags should be
885 # actually set somewhere in appropriate config functions
886 flags.tracks_IDTrig = \
887 collToRecordable(flags, f"HLT_IDTrack_{flags.suffix if flags.input_name not in ['tauIso', 'tauIsoHitZ'] else "Tau"}_IDTrig")
888
889 if recoMode == "Acts":
890 flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
891 flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
892
893 if flags.isLRT: # to be moved to a separate function once LRTs differ
894 flags.minClusters = tsetter(flags.minClusters , 8)
895 flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
896 flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
897 flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
898 flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
899 flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
900 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
901 flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
902
903
904 if recoMode == "ITk":
905 flags.extension = flags.input_name #needed in the ITk mode?
906
907 if flags.isLRT:
908 flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
909
910

◆ diTau()

AthConfigFlags diTau ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 426 of file BuildSignatureFlags.py.

426def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
427
428 flags.input_name = instanceName
429 flags.name = "diTau"
430 flags.suffix = "DiTau"
431 flags.roi = "HLT_Roi_DiTau"
432 flags.etaHalfWidth = 1.0
433 flags.phiHalfWidth = 1.0
434 flags.zedHalfWidth = 7.0
435 flags.adaptiveVertex = True
436 flags.addSingleTrackVertices = True
437 flags.vertex = "HLT_IDVertex_DiTau"
438 flags.electronPID = False
439 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
440 return flags
441
442@signatureActions

◆ DJetLRT()

AthConfigFlags DJetLRT ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 824 of file BuildSignatureFlags.py.

824def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
825
826 flags.input_name = instanceName
827 flags.name = "DJetLRT"
828 flags.suffix = "DJLRT"
829 flags.roi = "HLT_Roi_DJ"
830 flags.etaHalfWidth = 0.4
831 flags.phiHalfWidth = 0.4
832 flags.zedHalfWidth = 225.
833 flags.doTRT = False
834 flags.doSeedRedundancyCheck = True
835 flags.UsePixelSpacePoints = False
836 flags.Triplet_D0Max = 300.
837 flags.TrackInitialD0Max = 300.
838 flags.TrackZ0Max = 500.
839 flags.Triplet_D0_PPS_Max = 300.
840 flags.DoubletDR_Max = 200
841 flags.nClustersMin = 8
842 #pt config
843 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
844 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
845 flags.maxEta = 2.7
846 flags.doEmCaloSeed = False
847
848 return flags
849
850
851@lrtSignatureActions

◆ DVtxLRT()

AthConfigFlags DVtxLRT ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 852 of file BuildSignatureFlags.py.

852def DVtxLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
853
854 flags.input_name = instanceName
855 flags.name = "DVtxLRT"
856 flags.suffix = "DVLRT"
857 flags.roi = "HLT_Roi_DV"
858 flags.etaHalfWidth = 0.35
859 flags.phiHalfWidth = 0.35
860 flags.doTRT = False
861 flags.doSeedRedundancyCheck = True
862 flags.UsePixelSpacePoints = False
863 flags.Triplet_D0Max = 300.
864 flags.TrackInitialD0Max = 300.
865 flags.TrackZ0Max = 500.
866 flags.Triplet_D0_PPS_Max = 300.
867 flags.DoubletDR_Max = 200
868 flags.nClustersMin = 8
869 #pt config
870 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
871 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
872 flags.maxEta = 2.7
873 flags.doEmCaloSeed = False
874
875 return flags
876
877

◆ electron()

AthConfigFlags electron ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 316 of file BuildSignatureFlags.py.

316def electron(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
317
318 flags.input_name = instanceName
319 flags.name = "electron"
320 flags.suffix = "Electron"
321 flags.roi = "HLT_Roi_Electron"
322 flags.etaHalfWidth = 0.05 # this size should be increased to 0.1
323 flags.phiHalfWidth = 0.1
324 flags.doCloneRemoval = True
325 flags.doSeedRedundancyCheck = True
326 if recoMode=="InDet":
327 flags.doTRT = True
328 flags.electronPID = True
329 return flags
330
331@signatureActions

◆ electronLRT()

AthConfigFlags electronLRT ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 693 of file BuildSignatureFlags.py.

693def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
694
695 flags.input_name = instanceName
696 flags.name = "electronLRT"
697 flags.suffix = "ElecLRT"
698 flags.roi = "HLT_Roi_Electron"
699 flags.etaHalfWidth = 0.1
700 flags.phiHalfWidth = 0.4
701 flags.UsePixelSpacePoints = False
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 #pt config
709 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
710 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
711 flags.maxEta = 2.7
712 flags.doEmCaloSeed = False
713 return flags
714
715
716@lrtSignatureActions

◆ fullScan()

AthConfigFlags fullScan ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 571 of file BuildSignatureFlags.py.

571def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
572
573 flags.input_name = instanceName
574 flags.name = "fullScan"
575 flags.suffix = "FS"
576 flags.roi = "HLT_Roi_FS"
577 flags.vertex = "HLT_IDVertex_FS"
578 flags.adaptiveVertex = True
579 # these are being evaluated and may be added
580 # flags.addSingleTrackVertices = True
581 # flags.TracksMaxZinterval = 3
582 flags.vertex_jet = "HLT_IDVertex_FS"
583 flags.etaHalfWidth = 3.
584 flags.phiHalfWidth = math.pi
585 flags.doTRT = False
586 flags.DoubletDR_Max = 200
587 flags.SeedRadBinWidth = 10
588 flags.doSeedRedundancyCheck = True
589 flags.TripletDoPPS = False
590 flags.nClustersMin = 8
591 flags.UseTrigSeedML = 4
592 flags.dodEdxTrk = True
593 flags.doHitDV = True
594 flags.doDisappearingTrk = recoMode=="InDet"
595 flags.roadWidth = 5.
596 return flags
597
598
599@signatureActions

◆ fullScanLRT()

AthConfigFlags fullScanLRT ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 797 of file BuildSignatureFlags.py.

797def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
798
799 flags.input_name = instanceName
800 flags.name = "fullScanLRT"
801 flags.suffix = "FSLRT"
802 flags.roi = "HLT_Roi_FS"
803 flags.etaHalfWidth = 3.
804 flags.phiHalfWidth = math.pi
805 flags.doTRT = False
806 flags.doSeedRedundancyCheck = True
807 flags.UsePixelSpacePoints = False
808 flags.Triplet_D0Max = 300.
809 flags.TrackInitialD0Max = 300.
810 flags.TrackZ0Max = 500.
811 flags.Triplet_D0_PPS_Max = 300.
812 flags.DoubletDR_Max = 200
813 flags.nClustersMin = 8
814 #pt config
815 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
816 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
817 flags.maxEta = 2.7
818 flags.doEmCaloSeed = False
819
820 return flags
821
822
823@lrtSignatureActions

◆ jetSuper()

AthConfigFlags jetSuper ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 459 of file BuildSignatureFlags.py.

459def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
460
461 flags.input_name = instanceName
462 flags.name = "jetSuper"
463 flags.suffix = "JetSuper"
464 flags.vertex = "HLT_IDVertex_JetSuper"
465 flags.adaptiveVertex = True
466 flags.addSingleTrackVertices = True
467 flags.roi = "HLT_Roi_JetSuper"
468 flags.etaHalfWidth = 0.3
469 flags.phiHalfWidth = 0.3
470 flags.minPT = processEtaDepSettings(flags.minPT,[1.*Units.GeV])
471
472 #-----
473 flags.doTRT = False
474 flags.DoubletDR_Max = 200
475 flags.SeedRadBinWidth = 10
476 flags.doSeedRedundancyCheck = True
477 flags.TripletDoPPS = False
478 flags.nClustersMin = 8
479 flags.UseTrigSeedML = 4
480 flags.roadWidth = 5.
481 return flags
482
483@signatureActions

◆ lrtSignatureActions()

lrtSignatureActions ( func) 
Set common LRT flags before applying per-signature overrides.

Definition at line 275 of file BuildSignatureFlags.py.

275def lrtSignatureActions(func):
276 """Set common LRT flags before applying per-signature overrides."""
277 @signatureActions
278 def invokeSteps(flags: AthConfigFlags, instanceName: str, recoMode: str):
279 flags.isLRT = True
280 if recoMode == "Acts":
281 actsLRTTrigTrackingFlags(flags)
282 return func(flags, instanceName, recoMode)
283 return invokeSteps
284
285

◆ minBias()

AthConfigFlags minBias ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 484 of file BuildSignatureFlags.py.

484def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
485
486 flags.input_name = instanceName
487 flags.name = "minBias"
488 flags.suffix = "MinBias"
489 flags.roi = "HLT_Roi_MinBias"
490 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
491
492 flags.doTRT = False
493 flags.etaHalfWidth = 3
494 flags.phiHalfWidth = math.pi
495 flags.doZFinder = True
496 flags.doZFinderOnly = True
497
498 flags.nClustersMin = 5
499 flags.useSeedFilter = True
500 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
501 flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
502 flags.roadWidth = 20
503 flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
504 return flags
505
506
507@signatureActions

◆ minBiasPixel()

AthConfigFlags minBiasPixel ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 508 of file BuildSignatureFlags.py.

508def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
509
510 flags.input_name = instanceName
511 flags.name = "minBiasPixel"
512 flags.suffix = "MinBiasPixel"
513 flags.roi = "HLT_Roi_MinBias"
514 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
515
516
517 flags.maxHoles = 0 # HI setup
518 flags.maxPixelHoles = 0 # HI setup
519 flags.maxSctHoles = 0
520 flags.maxDoubleHoles = 0
521 flags.minSiNotShared = 3
522 flags.maxShared = 0
523 flags.nHolesMax = 0
524 flags.nHolesGapMax = 0
525 if recoMode=="InDet":
526 flags.useSCT = False
527 flags.useSCTSeeding = False
528
529 flags.roadWidth = 12.0
530 flags.Xi2max = 15
531 flags.Xi2maxNoAdd = 35.0
532 flags.nWeightedClustersMin = 6
533 flags.doBremRecoverySi = False
534 flags.RunPixelPID = False # we use these tracks only for counting
535
536 flags.doTRT = False
537 flags.etaHalfWidth = 3
538 flags.phiHalfWidth = math.pi
539 flags.doZFinder = False
540 flags.doZFinderOnly = True
541
542 flags.minClusters = 3
543 flags.nClustersMin = 3
544 flags.useSeedFilter = True
545 flags.maxPrimaryImpact = 10.*Units.mm
546 flags.maxZImpact = 150.*Units.mm
547 flags.roadWidth = 20
548 flags.usePrdAssociationTool = False
549 return flags
550
551
552
553@signatureActions

◆ muon()

AthConfigFlags muon ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 332 of file BuildSignatureFlags.py.

332def muon(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
333
334 flags.input_name = instanceName
335 flags.name = "muon"
336 flags.suffix = "Muon"
337 flags.roi = "HLT_Roi_L2SAMuon"
338 flags.Triplet_D0Max = 10.0
339 flags.doResMon = True
340 flags.DoPhiFiltering = False
341 flags.doSeedRedundancyCheck = True
342 return flags
343
344@signatureActions

◆ muonIso()

AthConfigFlags muonIso ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 345 of file BuildSignatureFlags.py.

345def muonIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
346
347 flags.input_name = instanceName
348 flags.name = "muonIso"
349 flags.suffix = "MuonIso"
350 flags.roi = "HLT_Roi_MuonIso"
351 flags.etaHalfWidth = 0.35
352 flags.phiHalfWidth = 0.35
353 flags.zedHalfWidth = 10.0
354 return flags
355
356@signatureActions

◆ muonLRT()

AthConfigFlags muonLRT ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 717 of file BuildSignatureFlags.py.

717def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
718
719 flags.input_name = instanceName
720 flags.name = "muonLRT"
721 flags.suffix = "MuonLRT"
722 flags.roi = "HLT_Roi_Muon"
723 flags.UsePixelSpacePoints = False
724 flags.etaHalfWidth = 0.2
725 flags.phiHalfWidth = 0.4
726 flags.Triplet_D0Max = 300.
727 flags.TrackInitialD0Max = 300.
728 flags.TrackZ0Max = 500.
729 flags.zedHalfWidth = 225.
730 flags.doSeedRedundancyCheck = True
731 flags.nClustersMin = 8
732 flags.doResMon = True
733 flags.DoPhiFiltering = False
734 #pt config
735 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
736 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
737 flags.maxEta = 2.7
738 flags.doEmCaloSeed = False
739
740 return flags
741
742
743
744@lrtSignatureActions

◆ processEtaDepSettings()

processEtaDepSettings ( var,
settings ) 
 depending on the destination flag type either keep list of values or flatten to a single value

Definition at line 300 of file BuildSignatureFlags.py.

300def processEtaDepSettings(var, settings):
301 """ depending on the destination flag type either keep list of values or flatten to a single value
302 """
303 type2set = type(var)
304 typeOfValue = type(settings)
305 if type2set == typeOfValue:
306 var = settings
307 else:
308 if isinstance(settings, list):
309 var = settings[0] if settings else None
310 else:
311 var = settings
312
313 return var
314
315@signatureActions
type

◆ signatureActions()

signatureActions ( func) 
convenience decorator to automate config steps

Definition at line 265 of file BuildSignatureFlags.py.

265def signatureActions(func):
266 """ convenience decorator to automate config steps """
267 def invokeSteps(*args, **kwargs):
268 flagsSig = func(*args, **kwargs) #invoke signature specific code
269 recoMode = args[2]
270 derivedFromSignatureFlags(flagsSig,recoMode) #invoke code dependant on signature flags
271 return flagsSig
272 return invokeSteps
273
274

◆ signatureTrigTrackingFlags()

AthConfigFlags signatureTrigTrackingFlags ( str mode)

Definition at line 181 of file BuildSignatureFlags.py.

181def signatureTrigTrackingFlags(mode : str) -> AthConfigFlags:
182
183 signatureSet = {
184 "electron" : electron,
185 "photon" : electron,
186
187 "muon" : muon,
188 "muonIso" : muonIso,
189 "muonIsoMS" : muonIso,
190 "muonCore" : muon,
191 "muonFS" : muon,
192 "muonLate" : muon,
193
194 "tauCore" : tauCore,
195 "tauCoreEM" : tauCoreEM,
196 "tauIso" : tauIso,
197 "tauIsoEM" : tauIsoEM,
198 "tauHitsHitZ" : tauHitsHitZ,
199 "tauCoreHitZ" : tauCoreHitZ,
200 "tauIsoHitZ" : tauIsoHitZ,
201
202 "diTau" : diTau,
203
204 "bjet" : bjet,
205
206 "fullScan" : fullScan,
207 "jetSuper" : jetSuper,
208
209 "beamSpot" : beamSpot,
210 "beamSpotFS" : beamSpotFS,
211
212 "cosmics" : cosmics,
213 "bmumux" : bmumux,
214 "bhh" : bhh,
215
216 "minBias" : minBias,
217 "minBiasPixel" : minBiasPixel,
218
219 "electronLRT" : electronLRT,
220 "muonLRT" : muonLRT,
221 "tauLRT" : tauLRT,
222 "bjetLRT" : bjetLRT,
223 "fullScanLRT" : fullScanLRT,
224 "DJetLRT" : DJetLRT,
225 "DVtxLRT" : DVtxLRT,
226 }
227
228 flags = AthConfigFlags()
229
230 if mode == "InDet":
231 category = 'Trigger.InDetTracking'
232 defaults = defaultInDetTrigTrackingFlags
233 elif mode == "ITk":
234 category = 'Trigger.ITkTracking'
235 defaults = defaultITkTrigTrackingFlags
236 elif mode == "Acts":
237 category = "Trigger.ActsTracking"
238 defaults = defaultITkActsTrigTrackingFlags
239 else:
240 log.error("Unsupported reconstruction mode %s", mode)
241
242
243 class categoryGeneratorWrapper():
244 """ wrap function which can be consumed by addFlagsCategory and provide its args """
245 def __init__(self, fun : Callable[[AthConfigFlags, str, str], AthConfigFlags],
246 flags : AthConfigFlags, signatureInstance : str, recoMode : str):
247 self.flags = flags
248 self.sig = signatureInstance
249 self.fun = fun
250 self.mode= recoMode
251 def run(self):
252 return self.fun(self.flags,self.sig,self.mode)
253
254 for i in signatureSet:
255 trackingflags = deepcopy(defaults())
256 a = categoryGeneratorWrapper(signatureSet[i],trackingflags,i,mode)
257 signatureCategory = "{}.{}".format(category,i)
258 flags.addFlagsCategory(signatureCategory,a.run,prefix=True)
259
260 addGlobalFlags(flags, category) # they should not be needed / backward compatibility
261
262 return flags
263
264
run
int run(int argc, char *argv[])
Definition ttree2hdf5.cxx:28

◆ tauCore()

AthConfigFlags tauCore ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 367 of file BuildSignatureFlags.py.

367def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
368
369 flags.input_name = instanceName
370 flags.name = "tauCore"
371 flags.suffix = "TauCore"
372 flags.roi = "HLT_Roi_TauCore"
373 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
374 flags.holeSearch_FTF = True
375 return flags
376
377@signatureActions

◆ tauCoreEM()

AthConfigFlags tauCoreEM ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 378 of file BuildSignatureFlags.py.

378def tauCoreEM(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
379 flags = tauCore(flags, instanceName, recoMode)
380 flags.name = "tauCoreEM"
381 flags.suffix = "TauCoreEM"
382 flags.roi = "HLT_Roi_TauCoreEM"
383 return flags
384
385@signatureActions

◆ tauCoreHitZ()

AthConfigFlags tauCoreHitZ ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 386 of file BuildSignatureFlags.py.

386def tauCoreHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
387 flags = tauCore(flags, instanceName, recoMode)
388 flags.name = "tauCoreHitZ"
389 flags.roi = "HLT_Roi_TauCoreHitZ"
390 flags.zedHalfWidth = 30.0
391 return flags
392
393@signatureActions

◆ tauHitsHitZ()

AthConfigFlags tauHitsHitZ ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 357 of file BuildSignatureFlags.py.

357def tauHitsHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
358 # RoI used only for SP-formation (no tracking)
359
360 flags.input_name = instanceName
361 flags.name = "tauHitsHitZ"
362 flags.suffix = "TauHits"
363 flags.roi = "HLT_Roi_TauHitsHitZ"
364 return flags
365
366@signatureActions

◆ tauIso()

AthConfigFlags tauIso ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 394 of file BuildSignatureFlags.py.

394def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
395
396 flags.input_name = instanceName
397 flags.name = "tauIso"
398 flags.suffix = "TauIso"
399 flags.roi = "HLT_Roi_TauIso"
400 flags.etaHalfWidth = 0.4
401 flags.phiHalfWidth = 0.4
402 flags.zedHalfWidth = 7.0
403 flags.adaptiveVertex = True
404 flags.addSingleTrackVertices = True
405 flags.vertex = "HLT_IDVertex_Tau"
406 flags.electronPID = False
407 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
408 return flags
409
410@signatureActions

◆ tauIsoEM()

AthConfigFlags tauIsoEM ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 411 of file BuildSignatureFlags.py.

411def tauIsoEM(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
412 flags = tauIso(flags, instanceName, recoMode)
413 flags.name = "tauIsoEM"
414 flags.suffix = "TauIsoEM"
415 flags.roi = "HLT_Roi_TauIsoEM"
416 return flags
417
418@signatureActions

◆ tauIsoHitZ()

AthConfigFlags tauIsoHitZ ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 419 of file BuildSignatureFlags.py.

419def tauIsoHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
420 flags = tauIso(flags, instanceName, recoMode)
421 flags.name = "tauIsoHitZ"
422 flags.roi = "HLT_Roi_TauIsoHitZ"
423 return flags
424
425@signatureActions

◆ tauLRT()

AthConfigFlags tauLRT ( AthConfigFlags flags,
str instanceName,
str recoMode )

Definition at line 745 of file BuildSignatureFlags.py.

745def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
746
747 flags.input_name = instanceName
748 flags.name = "tauLRT"
749 flags.suffix = "TauLRT"
750 flags.roi = "HLT_Roi_TauLRT"
751 flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
752 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
753
754 flags.etaHalfWidth = 0.4
755 flags.phiHalfWidth = 0.4
756 flags.zedHalfWidth = 225.
757 flags.UsePixelSpacePoints = False
758 flags.Triplet_D0Max = 300.
759 flags.TrackInitialD0Max = 300.
760 flags.TrackZ0Max = 500.
761 flags.nClustersMin = 8
762 #pt config
763 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
764 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
765 flags.maxEta = 2.7
766 flags.doEmCaloSeed = False
767 if recoMode=="InDet":
768 flags.doTRT = True
769
770 return flags
771
772
773@lrtSignatureActions

◆ tsetter()

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

286def tsetter(var, value):
287 """ use previous type of the var and convert value to it
288 for the moment just makes list of a value if needed
289 """
290 type2set = type(var)
291 typeOfValue = type(value)
292 if type2set == typeOfValue:
293 var = value
294 else:
295 basic = (bool, str, int, float, type(None))
296 var = value if isinstance(var, basic) else [value]
297
298 return var
299

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags = flags

Definition at line 247 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun = fun

Definition at line 249 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 250 of file BuildSignatureFlags.py.

◆ sig

python.BuildSignatureFlags.sig = signatureInstance

Definition at line 248 of file BuildSignatureFlags.py.

Generated on for ATLAS Offline Software by doxygen 1.17.0