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

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

◆ beamSpot()

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

Definition at line 527 of file BuildSignatureFlags.py.

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

◆ beamSpotFS()

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

Definition at line 577 of file BuildSignatureFlags.py.

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

◆ bhh()

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

Definition at line 654 of file BuildSignatureFlags.py.

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

◆ bjet()

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

Definition at line 414 of file BuildSignatureFlags.py.

414def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
415
416 flags.input_name = instanceName
417 flags.name = "bjet"
418 flags.suffix = "Bjet"
419 flags.roi = "HLT_Roi_Bjet"
420 flags.etaHalfWidth = 0.4
421 flags.phiHalfWidth = 0.4
422 flags.zedHalfWidth = 10.0
423 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
424 flags.Xi2max = tsetter(flags.Xi2max,12.)
425 return flags
426
427@signatureActions

◆ bjetLRT()

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

Definition at line 757 of file BuildSignatureFlags.py.

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

◆ bmumux()

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

Definition at line 638 of file BuildSignatureFlags.py.

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

◆ collToRecordable()

python.BuildSignatureFlags.collToRecordable ( flags,
name )

Definition at line 900 of file BuildSignatureFlags.py.

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

◆ cosmics()

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

Definition at line 597 of file BuildSignatureFlags.py.

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

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 94 of file BuildSignatureFlags.py.

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

◆ defaultITkActsTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkActsTrigTrackingFlags ( )

Definition at line 154 of file BuildSignatureFlags.py.

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

◆ defaultITkTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkTrigTrackingFlags ( )

Definition at line 127 of file BuildSignatureFlags.py.

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

◆ 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("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("doFullScan", False)
39 flags.addFlag("monPS", 1)
40 flags.addFlag("monPtMin", 1*Units.GeV)
41 flags.addFlag("doTRT", True)
42 flags.addFlag("keepTrackParameters", False) # Keep track parameters in conversion to TrackParticles
43 flags.addFlag("UsePixelSpacePoints", True)
44 flags.addFlag("TrackInitialD0Max", 20.0)
45 flags.addFlag("TrackZ0Max", 300.0)
46 flags.addFlag("isLRT", False)
47 flags.addFlag("UseTrigSeedML", 0)
48 flags.addFlag("nClustersMin", 7)
49 flags.addFlag("roi", "")
50 flags.addFlag("LRT_D0Min", 2.0)
51 flags.addFlag("LRT_HardPtMin", 1.0*Units.GeV)
52 flags.addFlag("doRecord", True)
53 flags.addFlag("vertex", "")
54 flags.addFlag("adaptiveVertex", False)
55 flags.addFlag("addSingleTrackVertices", False)
56 flags.addFlag("TracksMaxZinterval", 1*Units.mm)
57 flags.addFlag("minNSiHits_vtx", 10) #from vtxCuts
58 flags.addFlag("vertex_jet", "")
59 flags.addFlag("adaptiveVertex_jet", False)
60 flags.addFlag("dodEdxTrk", False)
61 flags.addFlag("doHitDV", False)
62 flags.addFlag("doDisappearingTrk", False)
63 flags.addFlag("useDynamicRoiZWidth", False)
64
65
66 #precision tracking configuration values
67 #__provisional change__:
68 #the following settings are incorrect but this is what is being used in the production running
69 #at the moment. Setting them explicitly here will prevent trigger count differences in
70 #https://gitlab.cern.ch/atlas/athena/-/merge_requests/56607
71 flags.maxEta = 2.7
72 flags.addFlag("minSiClusters", 7)
73 flags.addFlag("maxSiHoles", 5)
74 flags.maxPixelHoles = 5
75 flags.addFlag("maxSCTHoles", 5) #fix2024 - consolidate names maxSctHoles and others in addFlag here
76 flags.maxDoubleHoles = 2
77 flags.addFlag("doEmCaloSeed", False)
78
79 flags.useSeedFilter = False
80 flags.doBremRecoverySi = False #fix2023 setTrue for electron once validated
81
82 flags.addFlag("refitROT", True)
83 flags.addFlag("trtExtensionType", "xf")
84 flags.addFlag("doTruth", False)
85 flags.addFlag("perigeeExpression","BeamLine") #always use beamline regardless of Reco.EnableHI
86 flags.addFlag("SuperRoI", False) #TBD - move to bphys/menu
87
88 flags.addFlag("trkTracks_FTF", "")
89 flags.addFlag("trkTracks_IDTrig","")
90 flags.addFlag("tracks_FTF", "")
91 flags.addFlag("tracks_IDTrig", "")
92 flags.addFlag("useGBTSeedingTool", False)
93

◆ derivedFromSignatureFlags()

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

Definition at line 868 of file BuildSignatureFlags.py.

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

◆ diTau()

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

Definition at line 397 of file BuildSignatureFlags.py.

397def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
398
399 flags.input_name = instanceName
400 flags.name = "diTau"
401 flags.suffix = "DiTau"
402 flags.roi = "HLT_Roi_DiTau"
403 flags.etaHalfWidth = 1.0
404 flags.phiHalfWidth = 1.0
405 flags.zedHalfWidth = 7.0
406 flags.adaptiveVertex = True
407 flags.addSingleTrackVertices = True
408 flags.vertex = "HLT_IDVertex_DiTau"
409 flags.electronPID = False
410 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
411 return flags
412
413@signatureActions

◆ DJetLRT()

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

Definition at line 810 of file BuildSignatureFlags.py.

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

◆ DVtxLRT()

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

Definition at line 840 of file BuildSignatureFlags.py.

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

◆ electron()

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

Definition at line 301 of file BuildSignatureFlags.py.

301def electron(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
302
303 flags.input_name = instanceName
304 flags.name = "electron"
305 flags.suffix = "Electron"
306 flags.roi = "HLT_Roi_Electron"
307 flags.etaHalfWidth = 0.05 # this size should be increased to 0.1
308 flags.phiHalfWidth = 0.1
309 flags.doCloneRemoval = True
310 flags.doSeedRedundancyCheck = True
311 if recoMode=="InDet":
312 flags.doTRT = True
313 flags.keepTrackParameters = True
314 flags.electronPID = True
315 return flags
316
317@signatureActions

◆ electronLRT()

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

Definition at line 672 of file BuildSignatureFlags.py.

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

◆ fullScan()

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

Definition at line 546 of file BuildSignatureFlags.py.

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

◆ fullScanLRT()

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

Definition at line 781 of file BuildSignatureFlags.py.

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

◆ jetSuper()

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

Definition at line 428 of file BuildSignatureFlags.py.

428def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
429
430 flags.input_name = instanceName
431 flags.name = "jetSuper"
432 flags.suffix = "JetSuper"
433 flags.vertex = "HLT_IDVertex_JetSuper"
434 flags.adaptiveVertex = True
435 flags.addSingleTrackVertices = True
436 flags.roi = "HLT_Roi_JetSuper"
437 flags.etaHalfWidth = 0.3
438 flags.phiHalfWidth = 0.3
439 flags.doFullScan = True
440 flags.minPT = processEtaDepSettings(flags.minPT,[1.*Units.GeV])
441
442 #-----
443 flags.doTRT = False
444 flags.DoubletDR_Max = 200
445 flags.SeedRadBinWidth = 10
446 flags.doSeedRedundancyCheck = True
447 flags.TripletDoPPS = False
448 flags.nClustersMin = 8
449 flags.UseTrigSeedML = 4
450 flags.roadWidth = 5.
451 return flags
452
453@signatureActions

◆ minBias()

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

Definition at line 454 of file BuildSignatureFlags.py.

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

◆ minBiasPixel()

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

Definition at line 479 of file BuildSignatureFlags.py.

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

◆ muon()

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

Definition at line 318 of file BuildSignatureFlags.py.

318def muon(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
319
320 flags.input_name = instanceName
321 flags.name = "muon"
322 flags.suffix = "Muon"
323 flags.roi = "HLT_Roi_L2SAMuon"
324 flags.Triplet_D0Max = 10.0
325 flags.doResMon = True
326 flags.DoPhiFiltering = False
327 flags.doSeedRedundancyCheck = True
328 flags.monPtMin = 12*Units.GeV
329 return flags
330
331@signatureActions

◆ muonIso()

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

Definition at line 332 of file BuildSignatureFlags.py.

332def muonIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
333
334 flags.input_name = instanceName
335 flags.name = "muonIso"
336 flags.suffix = "MuonIso"
337 flags.roi = "HLT_Roi_MuonIso"
338 flags.etaHalfWidth = 0.35
339 flags.phiHalfWidth = 0.35
340 flags.zedHalfWidth = 10.0
341 return flags
342
343@signatureActions

◆ muonLRT()

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

Definition at line 698 of file BuildSignatureFlags.py.

698def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
699
700 flags.input_name = instanceName
701 flags.name = "muonLRT"
702 flags.suffix = "MuonLRT"
703 flags.roi = "HLT_Roi_Muon"
704 flags.UsePixelSpacePoints = False
705 flags.etaHalfWidth = 0.2
706 flags.phiHalfWidth = 0.4
707 flags.Triplet_D0Max = 300.
708 flags.TrackInitialD0Max = 300.
709 flags.TrackZ0Max = 500.
710 flags.zedHalfWidth = 225.
711 flags.doSeedRedundancyCheck = True
712 flags.nClustersMin = 8
713 flags.isLRT = True
714 flags.doResMon = True
715 flags.DoPhiFiltering = False
716 #pt config
717 flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
718 flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
719 flags.maxEta = 2.7
720 flags.doEmCaloSeed = False
721
722 return flags
723
724
725
726@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 285 of file BuildSignatureFlags.py.

285def processEtaDepSettings(var, settings):
286 """ depending on the destination flag type either keep list of values or flatten to a single value
287 """
288 type2set = type(var)
289 typeOfValue = type(settings)
290 if type2set == typeOfValue:
291 var = settings
292 else:
293 if isinstance(settings, list):
294 var = settings[0] if settings else None
295 else:
296 var = settings
297
298 return var
299
300@signatureActions
type

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

354def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
355
356 flags.input_name = instanceName
357 flags.name = "tauCore"
358 flags.suffix = "TauCore"
359 flags.roi = "HLT_Roi_TauCore"
360 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
361 flags.holeSearch_FTF = True
362 return flags
363
364@signatureActions

◆ tauCoreHitZ()

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

Definition at line 365 of file BuildSignatureFlags.py.

365def tauCoreHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
366 flags = tauCore(flags, instanceName, recoMode)
367 flags.name = "tauCoreHitZ"
368 flags.roi = "HLT_Roi_TauCoreHitZ"
369 flags.zedHalfWidth = 30.0
370 return flags
371
372@signatureActions

◆ tauHitsHitZ()

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

Definition at line 344 of file BuildSignatureFlags.py.

344def tauHitsHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
345 # RoI used only for SP-formation (no tracking)
346
347 flags.input_name = instanceName
348 flags.name = "tauHitsHitZ"
349 flags.suffix = "TauHits"
350 flags.roi = "HLT_Roi_TauHitsHitZ"
351 return flags
352
353@signatureActions

◆ tauIso()

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

Definition at line 373 of file BuildSignatureFlags.py.

373def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
374
375 flags.input_name = instanceName
376 flags.name = "tauIso"
377 flags.suffix = "TauIso"
378 flags.roi = "HLT_Roi_TauIso"
379 flags.etaHalfWidth = 0.4
380 flags.phiHalfWidth = 0.4
381 flags.zedHalfWidth = 7.0
382 flags.adaptiveVertex = True
383 flags.addSingleTrackVertices = True
384 flags.vertex = "HLT_IDVertex_Tau"
385 flags.electronPID = False
386 flags.minPT = processEtaDepSettings(flags.minPT,[0.8*Units.GeV])
387 return flags
388
389@signatureActions

◆ tauIsoHitZ()

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

Definition at line 390 of file BuildSignatureFlags.py.

390def tauIsoHitZ(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
391 flags = tauIso(flags, instanceName, recoMode)
392 flags.name = "tauIsoHitZ"
393 flags.roi = "HLT_Roi_TauIsoHitZ"
394 return flags
395
396@signatureActions

◆ tauLRT()

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

Definition at line 727 of file BuildSignatureFlags.py.

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

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.16.1