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

Classes

class  FlagValuesTest

Functions

 defaultTrigTrackingFlags (AthConfigFlags flags)
AthConfigFlags defaultInDetTrigTrackingFlags ()
AthConfigFlags defaultITkTrigTrackingFlags ()
AthConfigFlags defaultITkActsTrigTrackingFlags ()
AthConfigFlags defaultModeTrigTrackingFlags (AthConfigFlags flags)
AthConfigFlags signatureTrigTrackingFlags (str mode)
 signatureActions (func)
 tsetter (var, value)
AthConfigFlags electron (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags muon (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags muonIso (AthConfigFlags flags, str instanceName, str recoMode)
AthConfigFlags 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 918 of file BuildSignatureFlags.py.

918def addGlobalFlags(flags: AthConfigFlags, category : str):
919 flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
920 flags.addFlag(f'{category}.doGPU', False)
921 flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
922 flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
923 flags.addFlag(f'{category}.UseTracklets', False)
924 flags.addFlag(f'{category}.trackletPoints', 1)
925 flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
926 flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
927 flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
928 flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
929 flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
930 flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
931 flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
932 flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
933 flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
934 flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
935 flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
936 flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
937 flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
938 flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
939

◆ beamSpot()

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

Definition at line 522 of file BuildSignatureFlags.py.

522def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
523
524 flags.input_name = instanceName
525 flags.name = "beamSpot"
526 flags.suffix = "BeamSpot"
527 flags.roi = "HLT_Roi_FS"
528 flags.doFullScan = True
529 flags.doZFinder = True
530 flags.DoubletDR_Max = 200
531 flags.SeedRadBinWidth = 10
532 flags.etaHalfWidth = 3
533 flags.phiHalfWidth = math.pi
534 flags.doTRT = False
535 flags.doSeedRedundancyCheck = True
536 flags.doRecord = False
537 return flags
538
539
540@signatureActions

◆ beamSpotFS()

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

Definition at line 572 of file BuildSignatureFlags.py.

572def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
573
574 flags.input_name = instanceName
575 flags.name = "fullScan"
576 flags.suffix = "FS"
577 flags.roi = "HLT_Roi_FS"
578 flags.doFullScan = True
579 flags.etaHalfWidth = 3.
580 flags.phiHalfWidth = math.pi
581 flags.doTRT = False
582 flags.DoubletDR_Max = 200
583 flags.SeedRadBinWidth = 10
584 flags.TripletDoPPS = False
585 flags.nClustersMin = 8
586 flags.UseTrigSeedML = 4
587 flags.doRecord = False
588 return flags
589
590
591@signatureActions

◆ bhh()

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

Definition at line 649 of file BuildSignatureFlags.py.

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

◆ bjet()

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

Definition at line 406 of file BuildSignatureFlags.py.

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

◆ bjetLRT()

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

Definition at line 752 of file BuildSignatureFlags.py.

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

◆ bmumux()

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

Definition at line 633 of file BuildSignatureFlags.py.

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

◆ collToRecordable()

python.BuildSignatureFlags.collToRecordable ( flags,
name )

Definition at line 895 of file BuildSignatureFlags.py.

895def collToRecordable(flags,name):
896 # ToDo: should just be a flag set per signature in the per signature config
897 # and not setting parameters using tests on the signature name
898 ret = name
899 signature = flags.input_name
900 firstStage = True if "FTF" in name else False
901 record = True
902 if firstStage:
903 if signature in ["tauHitsHitZ","minBias","minBiasPixel","bjetLRT",
904 "beamSpot","BeamSpot"]:
905 record = False
906 else:
907 if signature in ["tauHitsHitZ","tauCore","tauCoreHitZ","tauIso","tauIsoHitZ","tauIsoBDT",
908 "jet","fullScan","FS","jetSuper","bhh",
909 "beamSpot", "BeamSpot","beamSpotFS",
910 "bjetLRT","DJetLRT","DVtxLRT"]:
911 record = False
912
913 if record:
914 ret = recordable(name)
915
916 return ret
917

◆ cosmics()

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

Definition at line 592 of file BuildSignatureFlags.py.

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

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 95 of file BuildSignatureFlags.py.

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

◆ defaultITkActsTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkActsTrigTrackingFlags ( )

Definition at line 156 of file BuildSignatureFlags.py.

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

◆ defaultITkTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkTrigTrackingFlags ( )

Definition at line 129 of file BuildSignatureFlags.py.

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

◆ defaultModeTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultModeTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 173 of file BuildSignatureFlags.py.

173def defaultModeTrigTrackingFlags(flags: AthConfigFlags) -> AthConfigFlags:
174 return flags
175

◆ defaultTrigTrackingFlags()

python.BuildSignatureFlags.defaultTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 16 of file BuildSignatureFlags.py.

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

◆ derivedFromSignatureFlags()

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

Definition at line 863 of file BuildSignatureFlags.py.

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

◆ diTau()

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

Definition at line 388 of file BuildSignatureFlags.py.

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

◆ DJetLRT()

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

Definition at line 805 of file BuildSignatureFlags.py.

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

◆ DVtxLRT()

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

Definition at line 835 of file BuildSignatureFlags.py.

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

◆ electron()

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

Definition at line 289 of file BuildSignatureFlags.py.

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

◆ electronLRT()

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

Definition at line 667 of file BuildSignatureFlags.py.

667def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
668
669 flags.input_name = instanceName
670 flags.name = "electronLRT"
671 flags.suffix = "ElecLRT"
672 flags.roi = "HLT_Roi_Electron"
673 flags.etaHalfWidth = 0.1
674 flags.phiHalfWidth = 0.4
675 flags.UsePixelSpacePoints = False
676 flags.Triplet_D0Max = 300.
677 flags.TrackInitialD0Max = 300.
678 flags.TrackZ0Max = 500.
679 flags.zedHalfWidth = 225.
680 flags.keepTrackParameters = True
681 flags.doSeedRedundancyCheck = True
682 flags.nClustersMin = 8
683 flags.isLRT = True
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@signatureActions

◆ fullScan()

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

Definition at line 541 of file BuildSignatureFlags.py.

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

◆ fullScanLRT()

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

Definition at line 776 of file BuildSignatureFlags.py.

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

◆ jetSuper()

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

Definition at line 421 of file BuildSignatureFlags.py.

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

◆ minBias()

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

Definition at line 447 of file BuildSignatureFlags.py.

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

◆ minBiasPixel()

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

Definition at line 473 of file BuildSignatureFlags.py.

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

◆ muon()

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

Definition at line 306 of file BuildSignatureFlags.py.

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

◆ muonIso()

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

Definition at line 320 of file BuildSignatureFlags.py.

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

◆ muonLRT()

AthConfigFlags python.BuildSignatureFlags.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.isLRT = True
709 flags.doResMon = True
710 flags.DoPhiFiltering = False
711 #pt config
712 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
713 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
714 flags.maxEta = 2.7
715 flags.doEmCaloSeed = False
716
717 return flags
718
719
720
721@signatureActions

◆ signatureActions()

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

Definition at line 260 of file BuildSignatureFlags.py.

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

◆ signatureTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.signatureTrigTrackingFlags ( str mode)

Definition at line 176 of file BuildSignatureFlags.py.

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

342def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
343
344 flags.input_name = instanceName
345 flags.name = "tauCore"
346 flags.suffix = "TauCore"
347 flags.roi = "HLT_Roi_TauCore"
348 flags.pTmin = 0.8*Units.GeV
349 flags.minPT = tsetter(flags.minPT, flags.pTmin)
350
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 332 of file BuildSignatureFlags.py.

332def tauHitsHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
333 # RoI used only for SP-formation (no tracking)
334
335 flags.input_name = instanceName
336 flags.name = "tauHitsHitZ"
337 flags.suffix = "TauHits"
338 flags.roi = "HLT_Roi_TauHitsHitZ"
339 return flags
340
341@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.pTmin = 0.8*Units.GeV
377 flags.minPT = tsetter(flags.minPT, flags.pTmin)
378 return flags
379
380@signatureActions

◆ tauIsoHitZ()

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

Definition at line 381 of file BuildSignatureFlags.py.

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

◆ tauLRT()

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

Definition at line 722 of file BuildSignatureFlags.py.

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

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

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags = flags

Definition at line 242 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun = fun

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

◆ sig

python.BuildSignatureFlags.sig = signatureInstance

Definition at line 243 of file BuildSignatureFlags.py.

Generated on for ATLAS Offline Software by doxygen 1.16.1