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 tauCoreHitZ (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags tauIso (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 flags.Xi2max = [25.0]
175 flags.Xi2maxNoAdd = [50.0]
176

◆ addGlobalFlags()

addGlobalFlags ( AthConfigFlags flags,
str category )

Definition at line 909 of file BuildSignatureFlags.py.

909def addGlobalFlags(flags: AthConfigFlags, category : str):
910 flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
911 flags.addFlag(f'{category}.doGPU', False)
912 flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
913 flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
914 flags.addFlag(f'{category}.UseTracklets', False)
915 flags.addFlag(f'{category}.trackletPoints', 1)
916 flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
917 flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
918 flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
919 flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
920 flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
921 flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
922 flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
923 flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
924 flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
925 flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
926 flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
927 flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
928 flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
929 flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
930

◆ beamSpot()

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

Definition at line 533 of file BuildSignatureFlags.py.

533def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
534
535 flags.input_name = instanceName
536 flags.name = "beamSpot"
537 flags.suffix = "BeamSpot"
538 flags.roi = "HLT_Roi_FS"
539 flags.doZFinder = True
540 flags.DoubletDR_Max = 200
541 flags.SeedRadBinWidth = 10
542 flags.etaHalfWidth = 3
543 flags.phiHalfWidth = math.pi
544 flags.doTRT = False
545 flags.doSeedRedundancyCheck = True
546 return flags
547
548
549@signatureActions

◆ beamSpotFS()

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

Definition at line 579 of file BuildSignatureFlags.py.

579def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
580
581 flags.input_name = instanceName
582 flags.name = "fullScan"
583 flags.suffix = "FS"
584 flags.roi = "HLT_Roi_FS"
585 flags.etaHalfWidth = 3.
586 flags.phiHalfWidth = math.pi
587 flags.doTRT = False
588 flags.DoubletDR_Max = 200
589 flags.SeedRadBinWidth = 10
590 flags.TripletDoPPS = False
591 flags.nClustersMin = 8
592 flags.UseTrigSeedML = 4
593 return flags
594
595
596@signatureActions

◆ bhh()

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

Definition at line 652 of file BuildSignatureFlags.py.

652def bhh(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
653
654 flags.input_name = instanceName
655 flags.name = "bhh"
656 flags.suffix = "Bhh"
657 flags.roi = "HLT_Roi_Bhh"
658 flags.Triplet_D0Max = 10.
659 flags.DoPhiFiltering = False
660 flags.etaHalfWidth = 2.5
661 flags.phiHalfWidth = math.pi-1.e-5
662 flags.zedHalfWidth = 30.
663 flags.minPT = processEtaDepSettings(flags.minPT,[2*Units.GeV])
664
665 flags.doSeedRedundancyCheck = True
666 return flags
667
668@lrtSignatureActions

◆ bjet()

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

Definition at line 424 of file BuildSignatureFlags.py.

424def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
425
426 flags.input_name = instanceName
427 flags.name = "bjet"
428 flags.suffix = "Bjet"
429 flags.roi = "HLT_Roi_Bjet"
430 flags.etaHalfWidth = 0.4
431 flags.phiHalfWidth = 0.4
432 flags.zedHalfWidth = 10.0
433 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
434 flags.Xi2max = tsetter(flags.Xi2max,12.)
435 return flags
436
437@signatureActions

◆ bjetLRT()

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

Definition at line 750 of file BuildSignatureFlags.py.

750def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
751
752 flags.input_name = instanceName
753 flags.name = "bjetLRT"
754 flags.suffix = "BjetLRT"
755 flags.roi = "HLT_Roi_Bjet"
756 flags.etaHalfWidth = 0.4
757 flags.phiHalfWidth = 0.4
758 flags.UsePixelSpacePoints = False
759 flags.Triplet_D0Max = 300.
760 flags.TrackInitialD0Max = 300.
761 flags.TrackZ0Max = 500.
762 flags.nClustersMin = 8
763 #pt config
764 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
765 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
766 flags.maxEta = 2.7
767 flags.doEmCaloSeed = False
768
769 return flags
770
771
772@lrtSignatureActions

◆ bmumux()

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

Definition at line 637 of file BuildSignatureFlags.py.

637def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
638
639 flags.input_name = instanceName
640 flags.name = "bphysics"
641 flags.suffix = "Bmumux"
642 flags.roi = "HLT_Roi_Bmumux"
643 flags.Triplet_D0Max = 10.
644 flags.DoPhiFiltering = False
645 flags.etaHalfWidth = 0.75
646 flags.phiHalfWidth = 0.75
647 flags.zedHalfWidth = 50.
648 flags.doSeedRedundancyCheck = True
649 return flags
650
651@signatureActions

◆ collToRecordable()

collToRecordable ( flags,
name )

Definition at line 886 of file BuildSignatureFlags.py.

886def collToRecordable(flags,name):
887 # ToDo: should just be a flag set per signature in the per signature config
888 # and not setting parameters using tests on the signature name
889 ret = name
890 signature = flags.input_name
891 firstStage = "FTF" in name
892 record = True
893 if firstStage:
894 if signature in ["tauHitsHitZ","minBias","minBiasPixel","bjetLRT",
895 "beamSpot"]:
896 record = False
897 else:
898 if signature in ["tauHitsHitZ","tauCore","tauCoreHitZ","tauIso","tauIsoHitZ","tauIsoBDT",
899 "jet","fullScan","jetSuper","bhh",
900 "beamSpot","beamSpotFS",
901 "bjetLRT","DJetLRT","DVtxLRT"]:
902 record = False
903
904 if record:
905 ret = recordable(name)
906
907 return ret
908

◆ cosmics()

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

Definition at line 597 of file BuildSignatureFlags.py.

597def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
598
599 flags.input_name = instanceName
600 flags.name = "cosmics"
601 flags.suffix = "Cosmic"
602 flags.roi = "HLT_Roi_Cosmics"
603 flags.Triplet_D0Max = 1000.0
604 flags.Triplet_D0_PPS_Max = 1000.0
605 flags.TrackInitialD0Max = 1000.
606 flags.TrackZ0Max = 1000.
607 flags.doTRT = False
608 flags.etaHalfWidth = 3
609 flags.phiHalfWidth = math.pi
610
611 flags.minPT = processEtaDepSettings(flags.minPT,[0.5*Units.GeV])
612
613 flags.nClustersMin = 4
614 flags.minSiNotShared = 3
615 flags.maxShared = 0
616 flags.nHolesMax = 3
617 flags.maxSiHoles = 3
618 flags.maxSCTHoles = 3
619 flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
620 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
621
622 flags.Xi2max = tsetter(flags.Xi2max, 60.)
623 flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
624 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
625
626 flags.nWeightedClustersMin = 8
627 flags.useSeedFilter = True
628 flags.usePrdAssociationTool= False #for backward compatibility #2023fix?
629 flags.roadWidth = 75.
630 flags.maxZImpact = tsetter(flags.maxZImpact, 10000.*Units.mm)
631 if recoMode=="InDet":
632 flags.minTRTonTrk = 20
633
634 return flags
635
636@signatureActions

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

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

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

854def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
855
856 flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
857 flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
858 flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
859 # ToDo: shouldn't be setting flags using this if type structures, the flags should be
860 # actually set somewhere in appropriate config functions
861 flags.tracks_IDTrig = \
862 collToRecordable(flags,"HLT_IDTrack_{}_IDTrig".format(flags.suffix if flags.input_name not in ['tauIso', 'tauIsoHitZ'] else "Tau"))
863
864 if recoMode == "Acts":
865 flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
866 flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
867
868 if flags.isLRT: # to be moved to a separate function once LRTs differ
869 flags.minClusters = tsetter(flags.minClusters , 8)
870 flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
871 flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
872 flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
873 flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
874 flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
875 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
876 flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
877
878
879 if recoMode == "ITk":
880 flags.extension = flags.input_name #needed in the ITk mode?
881
882 if flags.isLRT:
883 flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
884
885

◆ diTau()

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

Definition at line 407 of file BuildSignatureFlags.py.

407def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
408
409 flags.input_name = instanceName
410 flags.name = "diTau"
411 flags.suffix = "DiTau"
412 flags.roi = "HLT_Roi_DiTau"
413 flags.etaHalfWidth = 1.0
414 flags.phiHalfWidth = 1.0
415 flags.zedHalfWidth = 7.0
416 flags.adaptiveVertex = True
417 flags.addSingleTrackVertices = True
418 flags.vertex = "HLT_IDVertex_DiTau"
419 flags.electronPID = False
420 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
421 return flags
422
423@signatureActions

◆ DJetLRT()

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

Definition at line 800 of file BuildSignatureFlags.py.

800def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
801
802 flags.input_name = instanceName
803 flags.name = "DJetLRT"
804 flags.suffix = "DJLRT"
805 flags.roi = "HLT_Roi_DJ"
806 flags.etaHalfWidth = 0.4
807 flags.phiHalfWidth = 0.4
808 flags.zedHalfWidth = 225.
809 flags.doTRT = False
810 flags.doSeedRedundancyCheck = True
811 flags.UsePixelSpacePoints = False
812 flags.Triplet_D0Max = 300.
813 flags.TrackInitialD0Max = 300.
814 flags.TrackZ0Max = 500.
815 flags.Triplet_D0_PPS_Max = 300.
816 flags.DoubletDR_Max = 200
817 flags.nClustersMin = 8
818 #pt config
819 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
820 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
821 flags.maxEta = 2.7
822 flags.doEmCaloSeed = False
823
824 return flags
825
826
827@lrtSignatureActions

◆ DVtxLRT()

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

Definition at line 828 of file BuildSignatureFlags.py.

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

◆ electron()

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

Definition at line 313 of file BuildSignatureFlags.py.

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

◆ electronLRT()

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

Definition at line 669 of file BuildSignatureFlags.py.

669def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
670
671 flags.input_name = instanceName
672 flags.name = "electronLRT"
673 flags.suffix = "ElecLRT"
674 flags.roi = "HLT_Roi_Electron"
675 flags.etaHalfWidth = 0.1
676 flags.phiHalfWidth = 0.4
677 flags.UsePixelSpacePoints = False
678 flags.Triplet_D0Max = 300.
679 flags.TrackInitialD0Max = 300.
680 flags.TrackZ0Max = 500.
681 flags.zedHalfWidth = 225.
682 flags.doSeedRedundancyCheck = True
683 flags.nClustersMin = 8
684 #pt config
685 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
686 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
687 flags.maxEta = 2.7
688 flags.doEmCaloSeed = False
689 return flags
690
691
692@lrtSignatureActions

◆ fullScan()

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

Definition at line 550 of file BuildSignatureFlags.py.

550def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
551
552 flags.input_name = instanceName
553 flags.name = "fullScan"
554 flags.suffix = "FS"
555 flags.roi = "HLT_Roi_FS"
556 flags.vertex = "HLT_IDVertex_FS"
557 flags.adaptiveVertex = True
558 # these are being evaluated and may be added
559 # flags.addSingleTrackVertices = True
560 # flags.TracksMaxZinterval = 3
561 flags.vertex_jet = "HLT_IDVertex_FS"
562 flags.etaHalfWidth = 3.
563 flags.phiHalfWidth = math.pi
564 flags.doTRT = False
565 flags.DoubletDR_Max = 200
566 flags.SeedRadBinWidth = 10
567 flags.doSeedRedundancyCheck = True
568 flags.TripletDoPPS = False
569 flags.nClustersMin = 8
570 flags.UseTrigSeedML = 4
571 flags.dodEdxTrk = True
572 flags.doHitDV = True
573 flags.doDisappearingTrk = recoMode=="InDet"
574 flags.roadWidth = 5.
575 return flags
576
577
578@signatureActions

◆ fullScanLRT()

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

Definition at line 773 of file BuildSignatureFlags.py.

773def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
774
775 flags.input_name = instanceName
776 flags.name = "fullScanLRT"
777 flags.suffix = "FSLRT"
778 flags.roi = "HLT_Roi_FS"
779 flags.etaHalfWidth = 3.
780 flags.phiHalfWidth = math.pi
781 flags.doTRT = False
782 flags.doSeedRedundancyCheck = True
783 flags.UsePixelSpacePoints = False
784 flags.Triplet_D0Max = 300.
785 flags.TrackInitialD0Max = 300.
786 flags.TrackZ0Max = 500.
787 flags.Triplet_D0_PPS_Max = 300.
788 flags.DoubletDR_Max = 200
789 flags.nClustersMin = 8
790 #pt config
791 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
792 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
793 flags.maxEta = 2.7
794 flags.doEmCaloSeed = False
795
796 return flags
797
798
799@lrtSignatureActions

◆ jetSuper()

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

Definition at line 438 of file BuildSignatureFlags.py.

438def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
439
440 flags.input_name = instanceName
441 flags.name = "jetSuper"
442 flags.suffix = "JetSuper"
443 flags.vertex = "HLT_IDVertex_JetSuper"
444 flags.adaptiveVertex = True
445 flags.addSingleTrackVertices = True
446 flags.roi = "HLT_Roi_JetSuper"
447 flags.etaHalfWidth = 0.3
448 flags.phiHalfWidth = 0.3
449 flags.minPT = processEtaDepSettings(flags.minPT,[1.*Units.GeV])
450
451 #-----
452 flags.doTRT = False
453 flags.DoubletDR_Max = 200
454 flags.SeedRadBinWidth = 10
455 flags.doSeedRedundancyCheck = True
456 flags.TripletDoPPS = False
457 flags.nClustersMin = 8
458 flags.UseTrigSeedML = 4
459 flags.roadWidth = 5.
460 return flags
461
462@signatureActions

◆ lrtSignatureActions()

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

Definition at line 272 of file BuildSignatureFlags.py.

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

◆ minBias()

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

Definition at line 463 of file BuildSignatureFlags.py.

463def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
464
465 flags.input_name = instanceName
466 flags.name = "minBias"
467 flags.suffix = "MinBias"
468 flags.roi = "HLT_Roi_MinBias"
469 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
470
471 flags.doTRT = False
472 flags.etaHalfWidth = 3
473 flags.phiHalfWidth = math.pi
474 flags.doZFinder = True
475 flags.doZFinderOnly = True
476
477 flags.nClustersMin = 5
478 flags.useSeedFilter = True
479 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
480 flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
481 flags.roadWidth = 20
482 flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
483 return flags
484
485
486@signatureActions

◆ minBiasPixel()

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

Definition at line 487 of file BuildSignatureFlags.py.

487def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
488
489 flags.input_name = instanceName
490 flags.name = "minBiasPixel"
491 flags.suffix = "MinBiasPixel"
492 flags.roi = "HLT_Roi_MinBias"
493 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
494
495
496 flags.maxHoles = 0 # HI setup
497 flags.maxPixelHoles = 0 # HI setup
498 flags.maxSctHoles = 0
499 flags.maxDoubleHoles = 0
500 flags.minSiNotShared = 3
501 flags.maxShared = 0
502 flags.nHolesMax = 0
503 flags.nHolesGapMax = 0
504 if recoMode=="InDet":
505 flags.useSCT = False
506 flags.useSCTSeeding = False
507
508 flags.roadWidth = 12.0
509 flags.Xi2max = 15
510 flags.Xi2maxNoAdd = 35.0
511 flags.nWeightedClustersMin = 6
512 flags.doBremRecoverySi = False
513 flags.RunPixelPID = False # we use these tracks only for counting
514
515 flags.doTRT = False
516 flags.etaHalfWidth = 3
517 flags.phiHalfWidth = math.pi
518 flags.doZFinder = False
519 flags.doZFinderOnly = True
520
521 flags.minClusters = 3
522 flags.nClustersMin = 3
523 flags.useSeedFilter = True
524 flags.maxPrimaryImpact = 10.*Units.mm
525 flags.maxZImpact = 150.*Units.mm
526 flags.roadWidth = 20
527 flags.usePrdAssociationTool = False
528 return flags
529
530
531
532@signatureActions

◆ muon()

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

Definition at line 329 of file BuildSignatureFlags.py.

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

◆ muonIso()

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

Definition at line 342 of file BuildSignatureFlags.py.

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

◆ muonLRT()

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

Definition at line 693 of file BuildSignatureFlags.py.

693def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
694
695 flags.input_name = instanceName
696 flags.name = "muonLRT"
697 flags.suffix = "MuonLRT"
698 flags.roi = "HLT_Roi_Muon"
699 flags.UsePixelSpacePoints = False
700 flags.etaHalfWidth = 0.2
701 flags.phiHalfWidth = 0.4
702 flags.Triplet_D0Max = 300.
703 flags.TrackInitialD0Max = 300.
704 flags.TrackZ0Max = 500.
705 flags.zedHalfWidth = 225.
706 flags.doSeedRedundancyCheck = True
707 flags.nClustersMin = 8
708 flags.doResMon = True
709 flags.DoPhiFiltering = False
710 #pt config
711 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
712 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
713 flags.maxEta = 2.7
714 flags.doEmCaloSeed = False
715
716 return flags
717
718
719
720@lrtSignatureActions

◆ processEtaDepSettings()

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

Definition at line 297 of file BuildSignatureFlags.py.

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

◆ signatureActions()

signatureActions ( func) 
convenience decorator to automate config steps

Definition at line 262 of file BuildSignatureFlags.py.

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

◆ signatureTrigTrackingFlags()

AthConfigFlags signatureTrigTrackingFlags ( str mode)

Definition at line 180 of file BuildSignatureFlags.py.

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

◆ tauCore()

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

Definition at line 364 of file BuildSignatureFlags.py.

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

◆ tauCoreHitZ()

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

Definition at line 375 of file BuildSignatureFlags.py.

375def tauCoreHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
376 flags = tauCore(flags, instanceName, recoMode)
377 flags.name = "tauCoreHitZ"
378 flags.roi = "HLT_Roi_TauCoreHitZ"
379 flags.zedHalfWidth = 30.0
380 return flags
381
382@signatureActions

◆ tauHitsHitZ()

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

Definition at line 354 of file BuildSignatureFlags.py.

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

◆ tauIso()

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

Definition at line 383 of file BuildSignatureFlags.py.

383def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
384
385 flags.input_name = instanceName
386 flags.name = "tauIso"
387 flags.suffix = "TauIso"
388 flags.roi = "HLT_Roi_TauIso"
389 flags.etaHalfWidth = 0.4
390 flags.phiHalfWidth = 0.4
391 flags.zedHalfWidth = 7.0
392 flags.adaptiveVertex = True
393 flags.addSingleTrackVertices = True
394 flags.vertex = "HLT_IDVertex_Tau"
395 flags.electronPID = False
396 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
397 return flags
398
399@signatureActions

◆ tauIsoHitZ()

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

Definition at line 400 of file BuildSignatureFlags.py.

400def tauIsoHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
401 flags = tauIso(flags, instanceName, recoMode)
402 flags.name = "tauIsoHitZ"
403 flags.roi = "HLT_Roi_TauIsoHitZ"
404 return flags
405
406@signatureActions

◆ tauLRT()

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

Definition at line 721 of file BuildSignatureFlags.py.

721def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
722
723 flags.input_name = instanceName
724 flags.name = "tauLRT"
725 flags.suffix = "TauLRT"
726 flags.roi = "HLT_Roi_TauLRT"
727 flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
728 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
729
730 flags.etaHalfWidth = 0.4
731 flags.phiHalfWidth = 0.4
732 flags.zedHalfWidth = 225.
733 flags.UsePixelSpacePoints = False
734 flags.Triplet_D0Max = 300.
735 flags.TrackInitialD0Max = 300.
736 flags.TrackZ0Max = 500.
737 flags.nClustersMin = 8
738 #pt config
739 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
740 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
741 flags.maxEta = 2.7
742 flags.doEmCaloSeed = False
743 if recoMode=="InDet":
744 flags.doTRT = True
745
746 return flags
747
748
749@lrtSignatureActions

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

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

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags = flags

Definition at line 244 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun = fun

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

◆ sig

python.BuildSignatureFlags.sig = signatureInstance

Definition at line 245 of file BuildSignatureFlags.py.

Generated on for ATLAS Offline Software by doxygen 1.17.0