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)
 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

◆ addGlobalFlags()

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

Definition at line 898 of file BuildSignatureFlags.py.

898def addGlobalFlags(flags: AthConfigFlags, category : str):
899 flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
900 flags.addFlag(f'{category}.doGPU', False)
901 flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
902 flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
903 flags.addFlag(f'{category}.UseTracklets', False)
904 flags.addFlag(f'{category}.trackletPoints', 1)
905 flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
906 flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
907 flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
908 flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
909 flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
910 flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
911 flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
912 flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
913 flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
914 flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
915 flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
916 flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
917 flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
918 flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
919

◆ beamSpot()

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

Definition at line 513 of file BuildSignatureFlags.py.

513def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
514
515 flags.input_name = instanceName
516 flags.name = "beamSpot"
517 flags.suffix = "BeamSpot"
518 flags.roi = "HLT_Roi_FS"
519 flags.doZFinder = True
520 flags.DoubletDR_Max = 200
521 flags.SeedRadBinWidth = 10
522 flags.etaHalfWidth = 3
523 flags.phiHalfWidth = math.pi
524 flags.doTRT = False
525 flags.doSeedRedundancyCheck = True
526 return flags
527
528
529@signatureActions

◆ beamSpotFS()

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

Definition at line 559 of file BuildSignatureFlags.py.

559def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
560
561 flags.input_name = instanceName
562 flags.name = "fullScan"
563 flags.suffix = "FS"
564 flags.roi = "HLT_Roi_FS"
565 flags.etaHalfWidth = 3.
566 flags.phiHalfWidth = math.pi
567 flags.doTRT = False
568 flags.DoubletDR_Max = 200
569 flags.SeedRadBinWidth = 10
570 flags.TripletDoPPS = False
571 flags.nClustersMin = 8
572 flags.UseTrigSeedML = 4
573 return flags
574
575
576@signatureActions

◆ bhh()

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

Definition at line 633 of file BuildSignatureFlags.py.

633def bhh(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
634
635 flags.input_name = instanceName
636 flags.name = "bhh"
637 flags.suffix = "Bhh"
638 flags.roi = "HLT_Roi_Bhh"
639 flags.Triplet_D0Max = 10.
640 flags.DoPhiFiltering = False
641 flags.etaHalfWidth = 2.5
642 flags.phiHalfWidth = math.pi-1.e-5
643 flags.zedHalfWidth = 30.
644 flags.minPT = processEtaDepSettings(flags.minPT,[2*Units.GeV])
645
646 flags.doSeedRedundancyCheck = True
647 flags.SuperRoI = True
648 return flags
649
650@signatureActions

◆ bjet()

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

Definition at line 404 of file BuildSignatureFlags.py.

404def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
405
406 flags.input_name = instanceName
407 flags.name = "bjet"
408 flags.suffix = "Bjet"
409 flags.roi = "HLT_Roi_Bjet"
410 flags.etaHalfWidth = 0.4
411 flags.phiHalfWidth = 0.4
412 flags.zedHalfWidth = 10.0
413 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
414 flags.Xi2max = tsetter(flags.Xi2max,12.)
415 return flags
416
417@signatureActions

◆ bjetLRT()

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

Definition at line 735 of file BuildSignatureFlags.py.

735def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
736
737 flags.input_name = instanceName
738 flags.name = "bjetLRT"
739 flags.suffix = "BjetLRT"
740 flags.roi = "HLT_Roi_Bjet"
741 flags.etaHalfWidth = 0.4
742 flags.phiHalfWidth = 0.4
743 flags.UsePixelSpacePoints = False
744 flags.Triplet_D0Max = 300.
745 flags.TrackInitialD0Max = 300.
746 flags.TrackZ0Max = 500.
747 flags.nClustersMin = 8
748 flags.isLRT = True
749 #pt config
750 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
751 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
752 flags.maxEta = 2.7
753 flags.doEmCaloSeed = False
754
755 return flags
756
757
758@signatureActions

◆ bmumux()

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

Definition at line 617 of file BuildSignatureFlags.py.

617def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
618
619 flags.input_name = instanceName
620 flags.name = "bphysics"
621 flags.suffix = "Bmumux"
622 flags.roi = "HLT_Roi_Bmumux"
623 flags.Triplet_D0Max = 10.
624 flags.DoPhiFiltering = False
625 flags.etaHalfWidth = 0.75
626 flags.phiHalfWidth = 0.75
627 flags.zedHalfWidth = 50.
628 flags.doSeedRedundancyCheck = True
629 flags.SuperRoI = True
630 return flags
631
632@signatureActions

◆ collToRecordable()

python.BuildSignatureFlags.collToRecordable ( flags,
name )

Definition at line 875 of file BuildSignatureFlags.py.

875def collToRecordable(flags,name):
876 # ToDo: should just be a flag set per signature in the per signature config
877 # and not setting parameters using tests on the signature name
878 ret = name
879 signature = flags.input_name
880 firstStage = True if "FTF" in name else False
881 record = True
882 if firstStage:
883 if signature in ["tauHitsHitZ","minBias","minBiasPixel","bjetLRT",
884 "beamSpot"]:
885 record = False
886 else:
887 if signature in ["tauHitsHitZ","tauCore","tauCoreHitZ","tauIso","tauIsoHitZ","tauIsoBDT",
888 "jet","fullScan","jetSuper","bhh",
889 "beamSpot","beamSpotFS",
890 "bjetLRT","DJetLRT","DVtxLRT"]:
891 record = False
892
893 if record:
894 ret = recordable(name)
895
896 return ret
897

◆ cosmics()

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

Definition at line 577 of file BuildSignatureFlags.py.

577def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
578
579 flags.input_name = instanceName
580 flags.name = "cosmics"
581 flags.suffix = "Cosmic"
582 flags.roi = "HLT_Roi_Cosmics"
583 flags.Triplet_D0Max = 1000.0
584 flags.Triplet_D0_PPS_Max = 1000.0
585 flags.TrackInitialD0Max = 1000.
586 flags.TrackZ0Max = 1000.
587 flags.doTRT = False
588 flags.etaHalfWidth = 3
589 flags.phiHalfWidth = math.pi
590
591 flags.minPT = processEtaDepSettings(flags.minPT,[0.5*Units.GeV])
592
593 flags.nClustersMin = 4
594 flags.minSiNotShared = 3
595 flags.maxShared = 0
596 flags.nHolesMax = 3
597 flags.maxSiHoles = 3
598 flags.maxSCTHoles = 3
599 flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
600 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
601
602 flags.Xi2max = tsetter(flags.Xi2max, 60.)
603 flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
604 flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
605
606 flags.nWeightedClustersMin = 8
607 flags.useSeedFilter = True
608 flags.usePrdAssociationTool= False #for backward compatibility #2023fix?
609 flags.roadWidth = 75.
610 flags.maxZImpact = tsetter(flags.maxZImpact, 10000.*Units.mm)
611 if recoMode=="InDet":
612 flags.minTRTonTrk = 20
613
614 return flags
615
616@signatureActions

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 88 of file BuildSignatureFlags.py.

88def defaultInDetTrigTrackingFlags() -> AthConfigFlags:
89
90 flags = createTrackingPassFlags()
91 defaultTrigTrackingFlags(flags)
92
93 flags.minPT = 1.0*Units.GeV
94 flags.minClusters = 7 #hardcoded to preserve trigger settings (not used for FTF config)
95 flags.minSiNotShared = 5
96 flags.maxShared = 2
97 flags.Xi2max = 9.
98 flags.Xi2maxNoAdd = 25.
99 flags.nHolesMax = 2
100 flags.nHolesGapMax = 2
101 flags.nWeightedClustersMin= 6
102 flags.roadWidth =10.
103
104
105 flags.maxPrimaryImpact = 10.
106 flags.maxEMImpact = 50.
107 flags.maxZImpact = 250.
108
109 flags.minTRTonTrk =9
110
111 #TODO - simple ambiguitues
112 flags.useTIDE_Ambi = False
113
114 #2023fix - it should read 2
115 flags.maxSiHoles = 5
116 flags.maxSCTHoles = 5
117 #end
118
119 return flags
120

◆ defaultITkActsTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkActsTrigTrackingFlags ( )

Definition at line 148 of file BuildSignatureFlags.py.

148def defaultITkActsTrigTrackingFlags() -> AthConfigFlags:
149 flags = createActsTrackingPassFlags()
150 defaultTrigTrackingFlags(flags)
151
152 flags.minPT = [0.9*Units.GeV, 0.4*Units.GeV, 0.4*Units.GeV]
153 flags.minClusters = [9, 8, 7]
154 flags.doTRT = False
155 flags.maxEta = 4.0
156 flags.maxShared = [2]
157 flags.maxHoles = [1]
158 flags.maxPixelHoles = [2]
159 flags.maxSctHoles = [2]
160 flags.maxShared = [2]
161 flags.maxDoubleHoles = [1]
162
163 return flags
164

◆ defaultITkTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkTrigTrackingFlags ( )

Definition at line 121 of file BuildSignatureFlags.py.

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

◆ defaultModeTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultModeTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 165 of file BuildSignatureFlags.py.

165def defaultModeTrigTrackingFlags(flags: AthConfigFlags) -> AthConfigFlags:
166 return flags
167

◆ 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("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 flags.addFlag("SuperRoI", False) #TBD - move to bphys/menu
81
82 flags.addFlag("trkTracks_FTF", "")
83 flags.addFlag("trkTracks_IDTrig","")
84 flags.addFlag("tracks_FTF", "")
85 flags.addFlag("tracks_IDTrig", "")
86 flags.addFlag("useGBTSeedingTool", False)
87

◆ derivedFromSignatureFlags()

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

Definition at line 843 of file BuildSignatureFlags.py.

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

◆ diTau()

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

Definition at line 387 of file BuildSignatureFlags.py.

387def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
388
389 flags.input_name = instanceName
390 flags.name = "diTau"
391 flags.suffix = "DiTau"
392 flags.roi = "HLT_Roi_DiTau"
393 flags.etaHalfWidth = 1.0
394 flags.phiHalfWidth = 1.0
395 flags.zedHalfWidth = 7.0
396 flags.adaptiveVertex = True
397 flags.addSingleTrackVertices = True
398 flags.vertex = "HLT_IDVertex_DiTau"
399 flags.electronPID = False
400 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
401 return flags
402
403@signatureActions

◆ DJetLRT()

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

Definition at line 787 of file BuildSignatureFlags.py.

787def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
788
789 flags.input_name = instanceName
790 flags.name = "DJetLRT"
791 flags.suffix = "DJLRT"
792 flags.roi = "HLT_Roi_DJ"
793 flags.etaHalfWidth = 0.4
794 flags.phiHalfWidth = 0.4
795 flags.zedHalfWidth = 225.
796 flags.doTRT = False
797 flags.doSeedRedundancyCheck = True
798 flags.UsePixelSpacePoints = False
799 flags.Triplet_D0Max = 300.
800 flags.TrackInitialD0Max = 300.
801 flags.TrackZ0Max = 500.
802 flags.Triplet_D0_PPS_Max = 300.
803 flags.DoubletDR_Max = 200
804 flags.nClustersMin = 8
805 flags.isLRT = True
806 #pt config
807 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
808 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
809 flags.maxEta = 2.7
810 flags.doEmCaloSeed = False
811
812 return flags
813
814
815@signatureActions

◆ DVtxLRT()

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

Definition at line 816 of file BuildSignatureFlags.py.

816def DVtxLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
817
818 flags.input_name = instanceName
819 flags.name = "DVtxLRT"
820 flags.suffix = "DVLRT"
821 flags.roi = "HLT_Roi_DV"
822 flags.etaHalfWidth = 0.35
823 flags.phiHalfWidth = 0.35
824 flags.doTRT = False
825 flags.doSeedRedundancyCheck = True
826 flags.UsePixelSpacePoints = False
827 flags.Triplet_D0Max = 300.
828 flags.TrackInitialD0Max = 300.
829 flags.TrackZ0Max = 500.
830 flags.Triplet_D0_PPS_Max = 300.
831 flags.DoubletDR_Max = 200
832 flags.nClustersMin = 8
833 flags.isLRT = True
834 #pt config
835 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
836 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
837 flags.maxEta = 2.7
838 flags.doEmCaloSeed = False
839
840 return flags
841
842

◆ electron()

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

Definition at line 293 of file BuildSignatureFlags.py.

293def electron(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
294
295 flags.input_name = instanceName
296 flags.name = "electron"
297 flags.suffix = "Electron"
298 flags.roi = "HLT_Roi_Electron"
299 flags.etaHalfWidth = 0.05 # this size should be increased to 0.1
300 flags.phiHalfWidth = 0.1
301 flags.doCloneRemoval = True
302 flags.doSeedRedundancyCheck = True
303 if recoMode=="InDet":
304 flags.doTRT = True
305 flags.electronPID = True
306 return flags
307
308@signatureActions

◆ electronLRT()

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

Definition at line 651 of file BuildSignatureFlags.py.

651def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
652
653 flags.input_name = instanceName
654 flags.name = "electronLRT"
655 flags.suffix = "ElecLRT"
656 flags.roi = "HLT_Roi_Electron"
657 flags.etaHalfWidth = 0.1
658 flags.phiHalfWidth = 0.4
659 flags.UsePixelSpacePoints = False
660 flags.Triplet_D0Max = 300.
661 flags.TrackInitialD0Max = 300.
662 flags.TrackZ0Max = 500.
663 flags.zedHalfWidth = 225.
664 flags.doSeedRedundancyCheck = True
665 flags.nClustersMin = 8
666 flags.isLRT = True
667 #pt config
668 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
669 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
670 flags.maxEta = 2.7
671 flags.doEmCaloSeed = False
672 return flags
673
674
675@signatureActions

◆ fullScan()

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

Definition at line 530 of file BuildSignatureFlags.py.

530def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
531
532 flags.input_name = instanceName
533 flags.name = "fullScan"
534 flags.suffix = "FS"
535 flags.roi = "HLT_Roi_FS"
536 flags.vertex = "HLT_IDVertex_FS"
537 flags.adaptiveVertex = True
538 # these are being evaluated and may be added
539 # flags.addSingleTrackVertices = True
540 # flags.TracksMaxZinterval = 3
541 flags.vertex_jet = "HLT_IDVertex_FS"
542 flags.etaHalfWidth = 3.
543 flags.phiHalfWidth = math.pi
544 flags.doTRT = False
545 flags.DoubletDR_Max = 200
546 flags.SeedRadBinWidth = 10
547 flags.doSeedRedundancyCheck = True
548 flags.TripletDoPPS = False
549 flags.nClustersMin = 8
550 flags.UseTrigSeedML = 4
551 flags.dodEdxTrk = True
552 flags.doHitDV = True
553 flags.doDisappearingTrk = True if recoMode=="InDet" else False
554 flags.roadWidth = 5.
555 return flags
556
557
558@signatureActions

◆ fullScanLRT()

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

Definition at line 759 of file BuildSignatureFlags.py.

759def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
760
761 flags.input_name = instanceName
762 flags.name = "fullScanLRT"
763 flags.suffix = "FSLRT"
764 flags.roi = "HLT_Roi_FS"
765 flags.etaHalfWidth = 3.
766 flags.phiHalfWidth = math.pi
767 flags.doTRT = False
768 flags.doSeedRedundancyCheck = True
769 flags.UsePixelSpacePoints = False
770 flags.Triplet_D0Max = 300.
771 flags.TrackInitialD0Max = 300.
772 flags.TrackZ0Max = 500.
773 flags.Triplet_D0_PPS_Max = 300.
774 flags.DoubletDR_Max = 200
775 flags.nClustersMin = 8
776 flags.isLRT = True
777 #pt config
778 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
779 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
780 flags.maxEta = 2.7
781 flags.doEmCaloSeed = False
782
783 return flags
784
785
786@signatureActions

◆ jetSuper()

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

Definition at line 418 of file BuildSignatureFlags.py.

418def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
419
420 flags.input_name = instanceName
421 flags.name = "jetSuper"
422 flags.suffix = "JetSuper"
423 flags.vertex = "HLT_IDVertex_JetSuper"
424 flags.adaptiveVertex = True
425 flags.addSingleTrackVertices = True
426 flags.roi = "HLT_Roi_JetSuper"
427 flags.etaHalfWidth = 0.3
428 flags.phiHalfWidth = 0.3
429 flags.minPT = processEtaDepSettings(flags.minPT,[1.*Units.GeV])
430
431 #-----
432 flags.doTRT = False
433 flags.DoubletDR_Max = 200
434 flags.SeedRadBinWidth = 10
435 flags.doSeedRedundancyCheck = True
436 flags.TripletDoPPS = False
437 flags.nClustersMin = 8
438 flags.UseTrigSeedML = 4
439 flags.roadWidth = 5.
440 return flags
441
442@signatureActions

◆ minBias()

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

Definition at line 443 of file BuildSignatureFlags.py.

443def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
444
445 flags.input_name = instanceName
446 flags.name = "minBias"
447 flags.suffix = "MinBias"
448 flags.roi = "HLT_Roi_MinBias"
449 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
450
451 flags.doTRT = False
452 flags.etaHalfWidth = 3
453 flags.phiHalfWidth = math.pi
454 flags.doZFinder = True
455 flags.doZFinderOnly = True
456
457 flags.nClustersMin = 5
458 flags.useSeedFilter = True
459 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
460 flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
461 flags.roadWidth = 20
462 flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
463 return flags
464
465
466@signatureActions

◆ minBiasPixel()

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

Definition at line 467 of file BuildSignatureFlags.py.

467def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
468
469 flags.input_name = instanceName
470 flags.name = "minBiasPixel"
471 flags.suffix = "MinBiasPixel"
472 flags.roi = "HLT_Roi_MinBias"
473 flags.minPT = processEtaDepSettings(flags.minPT,[0.1*Units.GeV])
474
475
476 flags.maxHoles = 0 # HI setup
477 flags.maxPixelHoles = 0 # HI setup
478 flags.maxSctHoles = 0
479 flags.maxDoubleHoles = 0
480 flags.minSiNotShared = 3
481 flags.maxShared = 0
482 flags.nHolesMax = 0
483 flags.nHolesGapMax = 0
484 if recoMode=="InDet":
485 flags.useSCT = False
486 flags.useSCTSeeding = False
487
488 flags.roadWidth = 12.0
489 flags.Xi2max = 15
490 flags.Xi2maxNoAdd = 35.0
491 flags.nWeightedClustersMin = 6
492 flags.doBremRecoverySi = False
493 flags.RunPixelPID = False # we use these tracks only for counting
494
495 flags.doTRT = False
496 flags.etaHalfWidth = 3
497 flags.phiHalfWidth = math.pi
498 flags.doZFinder = False
499 flags.doZFinderOnly = True
500
501 flags.minClusters = 3
502 flags.nClustersMin = 3
503 flags.useSeedFilter = True
504 flags.maxPrimaryImpact = 10.*Units.mm
505 flags.maxZImpact = 150.*Units.mm
506 flags.roadWidth = 20
507 flags.usePrdAssociationTool = False
508 return flags
509
510
511
512@signatureActions

◆ muon()

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

Definition at line 309 of file BuildSignatureFlags.py.

309def muon(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
310
311 flags.input_name = instanceName
312 flags.name = "muon"
313 flags.suffix = "Muon"
314 flags.roi = "HLT_Roi_L2SAMuon"
315 flags.Triplet_D0Max = 10.0
316 flags.doResMon = True
317 flags.DoPhiFiltering = False
318 flags.doSeedRedundancyCheck = True
319 return flags
320
321@signatureActions

◆ muonIso()

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

Definition at line 322 of file BuildSignatureFlags.py.

322def muonIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
323
324 flags.input_name = instanceName
325 flags.name = "muonIso"
326 flags.suffix = "MuonIso"
327 flags.roi = "HLT_Roi_MuonIso"
328 flags.etaHalfWidth = 0.35
329 flags.phiHalfWidth = 0.35
330 flags.zedHalfWidth = 10.0
331 return flags
332
333@signatureActions

◆ muonLRT()

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

Definition at line 676 of file BuildSignatureFlags.py.

676def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
677
678 flags.input_name = instanceName
679 flags.name = "muonLRT"
680 flags.suffix = "MuonLRT"
681 flags.roi = "HLT_Roi_Muon"
682 flags.UsePixelSpacePoints = False
683 flags.etaHalfWidth = 0.2
684 flags.phiHalfWidth = 0.4
685 flags.Triplet_D0Max = 300.
686 flags.TrackInitialD0Max = 300.
687 flags.TrackZ0Max = 500.
688 flags.zedHalfWidth = 225.
689 flags.doSeedRedundancyCheck = True
690 flags.nClustersMin = 8
691 flags.isLRT = True
692 flags.doResMon = True
693 flags.DoPhiFiltering = False
694 #pt config
695 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
696 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
697 flags.maxEta = 2.7
698 flags.doEmCaloSeed = False
699
700 return flags
701
702
703
704@signatureActions

◆ processEtaDepSettings()

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

Definition at line 277 of file BuildSignatureFlags.py.

277def processEtaDepSettings(var, settings):
278 """ depending on the destination flag type either keep list of values or flatten to a single value
279 """
280 type2set = type(var)
281 typeOfValue = type(settings)
282 if type2set == typeOfValue:
283 var = settings
284 else:
285 if isinstance(settings, list):
286 var = settings[0] if settings else None
287 else:
288 var = settings
289
290 return var
291
292@signatureActions
type

◆ signatureActions()

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

Definition at line 250 of file BuildSignatureFlags.py.

250def signatureActions(func):
251 """ convenience decorator to automate config steps """
252 def invokeSteps(*args, **kwargs):
253 flagsSig = func(*args, **kwargs) #invoke signature specific code
254 recoMode = args[2]
255 derivedFromSignatureFlags(flagsSig,recoMode) #invoke code dependant on signature flags
256 return flagsSig
257 return invokeSteps
258
259

◆ signatureTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.signatureTrigTrackingFlags ( str mode)

Definition at line 168 of file BuildSignatureFlags.py.

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

344def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
345
346 flags.input_name = instanceName
347 flags.name = "tauCore"
348 flags.suffix = "TauCore"
349 flags.roi = "HLT_Roi_TauCore"
350 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
351 flags.holeSearch_FTF = True
352 return flags
353
354@signatureActions

◆ tauCoreHitZ()

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

Definition at line 355 of file BuildSignatureFlags.py.

355def tauCoreHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
356 flags = tauCore(flags, instanceName, recoMode)
357 flags.name = "tauCoreHitZ"
358 flags.roi = "HLT_Roi_TauCoreHitZ"
359 flags.zedHalfWidth = 30.0
360 return flags
361
362@signatureActions

◆ tauHitsHitZ()

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

Definition at line 334 of file BuildSignatureFlags.py.

334def tauHitsHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
335 # RoI used only for SP-formation (no tracking)
336
337 flags.input_name = instanceName
338 flags.name = "tauHitsHitZ"
339 flags.suffix = "TauHits"
340 flags.roi = "HLT_Roi_TauHitsHitZ"
341 return flags
342
343@signatureActions

◆ tauIso()

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

Definition at line 363 of file BuildSignatureFlags.py.

363def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
364
365 flags.input_name = instanceName
366 flags.name = "tauIso"
367 flags.suffix = "TauIso"
368 flags.roi = "HLT_Roi_TauIso"
369 flags.etaHalfWidth = 0.4
370 flags.phiHalfWidth = 0.4
371 flags.zedHalfWidth = 7.0
372 flags.adaptiveVertex = True
373 flags.addSingleTrackVertices = True
374 flags.vertex = "HLT_IDVertex_Tau"
375 flags.electronPID = False
376 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
377 return flags
378
379@signatureActions

◆ tauIsoHitZ()

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

Definition at line 380 of file BuildSignatureFlags.py.

380def tauIsoHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
381 flags = tauIso(flags, instanceName, recoMode)
382 flags.name = "tauIsoHitZ"
383 flags.roi = "HLT_Roi_TauIsoHitZ"
384 return flags
385
386@signatureActions

◆ tauLRT()

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

Definition at line 705 of file BuildSignatureFlags.py.

705def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
706
707 flags.input_name = instanceName
708 flags.name = "tauLRT"
709 flags.suffix = "TauLRT"
710 flags.roi = "HLT_Roi_TauLRT"
711 flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
712 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
713
714 flags.etaHalfWidth = 0.4
715 flags.phiHalfWidth = 0.4
716 flags.zedHalfWidth = 225.
717 flags.UsePixelSpacePoints = False
718 flags.Triplet_D0Max = 300.
719 flags.TrackInitialD0Max = 300.
720 flags.TrackZ0Max = 500.
721 flags.nClustersMin = 8
722 flags.isLRT = True
723 #pt config
724 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
725 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
726 flags.maxEta = 2.7
727 flags.doEmCaloSeed = False
728 if recoMode=="InDet":
729 flags.doTRT = True
730
731 return flags
732
733
734@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 260 of file BuildSignatureFlags.py.

260def tsetter(var, value):
261 """ use previous type of the var and convert value to it
262 for the moment just makes list of a value if needed
263 """
264 type2set = type(var)
265 typeOfValue = type(value)
266 if type2set == typeOfValue:
267 var = value
268 else:
269 basic = (bool, str, int, float, type(None))
270 if isinstance(var,basic):
271 var = value
272 else:
273 var = [value]
274
275 return var
276

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags = flags

Definition at line 232 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun = fun

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

◆ sig

python.BuildSignatureFlags.sig = signatureInstance

Definition at line 233 of file BuildSignatureFlags.py.

Generated on for ATLAS Offline Software by doxygen 1.16.1