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

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

◆ beamSpot()

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

Definition at line 520 of file BuildSignatureFlags.py.

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

◆ beamSpotFS()

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

Definition at line 570 of file BuildSignatureFlags.py.

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

◆ bhh()

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

Definition at line 647 of file BuildSignatureFlags.py.

647def bhh(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
648
649 flags.input_name = instanceName
650 flags.name = "bhh"
651 flags.suffix = "Bhh"
652 flags.roi = "HLT_Roi_Bhh"
653 flags.Triplet_D0Max = 10.
654 flags.DoPhiFiltering = False
655 flags.etaHalfWidth = 2.5
656 flags.phiHalfWidth = math.pi-1.e-5
657 flags.zedHalfWidth = 30.
658 flags.pTmin = 2*Units.GeV
659 flags.minPT = tsetter(flags.minPT, flags.pTmin)
660 flags.doSeedRedundancyCheck = True
661 flags.SuperRoI = True
662 return flags
663
664@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.pTmin = 0.8*Units.GeV
414 flags.minPT = tsetter(flags.minPT, flags.pTmin)
415 flags.Xi2max = tsetter(flags.Xi2max,12.)
416 return flags
417
418@signatureActions

◆ bjetLRT()

AthConfigFlags python.BuildSignatureFlags.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 flags.isLRT = True
764 #pt config
765 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
766 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
767 flags.maxEta = 2.7
768 flags.doEmCaloSeed = False
769
770 return flags
771
772
773@signatureActions

◆ bmumux()

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

Definition at line 631 of file BuildSignatureFlags.py.

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

◆ collToRecordable()

python.BuildSignatureFlags.collToRecordable ( flags,
name )

Definition at line 893 of file BuildSignatureFlags.py.

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

◆ cosmics()

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

Definition at line 590 of file BuildSignatureFlags.py.

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

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 95 of file BuildSignatureFlags.py.

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

◆ defaultITkActsTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkActsTrigTrackingFlags ( )

Definition at line 155 of file BuildSignatureFlags.py.

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

◆ defaultITkTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkTrigTrackingFlags ( )

Definition at line 129 of file BuildSignatureFlags.py.

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

◆ defaultModeTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultModeTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 171 of file BuildSignatureFlags.py.

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

◆ defaultTrigTrackingFlags()

python.BuildSignatureFlags.defaultTrigTrackingFlags ( AthConfigFlags flags)

Definition at line 16 of file BuildSignatureFlags.py.

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

◆ derivedFromSignatureFlags()

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

Definition at line 861 of file BuildSignatureFlags.py.

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

◆ diTau()

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

Definition at line 386 of file BuildSignatureFlags.py.

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

◆ DJetLRT()

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

Definition at line 803 of file BuildSignatureFlags.py.

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

◆ DVtxLRT()

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

Definition at line 833 of file BuildSignatureFlags.py.

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

◆ electron()

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

Definition at line 287 of file BuildSignatureFlags.py.

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

◆ electronLRT()

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

Definition at line 665 of file BuildSignatureFlags.py.

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

◆ fullScan()

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

Definition at line 539 of file BuildSignatureFlags.py.

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

◆ fullScanLRT()

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

Definition at line 774 of file BuildSignatureFlags.py.

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

◆ jetSuper()

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

Definition at line 419 of file BuildSignatureFlags.py.

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

◆ minBias()

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

Definition at line 445 of file BuildSignatureFlags.py.

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

◆ minBiasPixel()

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

Definition at line 471 of file BuildSignatureFlags.py.

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

◆ muon()

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

Definition at line 304 of file BuildSignatureFlags.py.

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

◆ muonIso()

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

Definition at line 318 of file BuildSignatureFlags.py.

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

◆ muonLRT()

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

Definition at line 691 of file BuildSignatureFlags.py.

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

◆ signatureActions()

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

Definition at line 258 of file BuildSignatureFlags.py.

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

◆ signatureTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.signatureTrigTrackingFlags ( str mode)

Definition at line 174 of file BuildSignatureFlags.py.

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

340def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
341
342 flags.input_name = instanceName
343 flags.name = "tauCore"
344 flags.suffix = "TauCore"
345 flags.roi = "HLT_Roi_TauCore"
346 flags.pTmin = 0.8*Units.GeV
347 flags.minPT = tsetter(flags.minPT, flags.pTmin)
348
349 flags.holeSearch_FTF = True
350 return flags
351
352@signatureActions

◆ tauCoreHitZ()

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

Definition at line 353 of file BuildSignatureFlags.py.

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

◆ tauHitsHitZ()

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

Definition at line 330 of file BuildSignatureFlags.py.

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

◆ tauIso()

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

Definition at line 361 of file BuildSignatureFlags.py.

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

◆ tauIsoHitZ()

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

Definition at line 379 of file BuildSignatureFlags.py.

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

◆ tauLRT()

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

Definition at line 720 of file BuildSignatureFlags.py.

720def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
721
722 flags.input_name = instanceName
723 flags.name = "tauLRT"
724 flags.suffix = "TauLRT"
725 flags.roi = "HLT_Roi_TauLRT"
726 flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
727 flags.pTmin = 0.8*Units.GeV
728 flags.minPT = tsetter(flags.minPT, flags.pTmin)
729 flags.etaHalfWidth = 0.4
730 flags.phiHalfWidth = 0.4
731 flags.zedHalfWidth = 225.
732 flags.UsePixelSpacePoints = False
733 flags.Triplet_D0Max = 300.
734 flags.TrackInitialD0Max = 300.
735 flags.TrackZ0Max = 500.
736 flags.nClustersMin = 8
737 flags.isLRT = True
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@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 268 of file BuildSignatureFlags.py.

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

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags = flags

Definition at line 240 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun = fun

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

◆ sig

python.BuildSignatureFlags.sig = signatureInstance

Definition at line 241 of file BuildSignatureFlags.py.

Generated on for ATLAS Offline Software by doxygen 1.14.0