ATLAS Offline Software
Classes | Functions | Variables
python.BuildSignatureFlags Namespace Reference

Classes

class  FlagValuesTest
 

Functions

def defaultTrigTrackingFlags (AthConfigFlags flags)
 
AthConfigFlags defaultInDetTrigTrackingFlags ()
 
AthConfigFlags defaultITkTrigTrackingFlags ()
 
AthConfigFlags defaultModeTrigTrackingFlags (AthConfigFlags flags)
 
AthConfigFlags signatureTrigTrackingFlags (str mode)
 
def signatureActions (func)
 
def 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 tauCore (AthConfigFlags flags, str instanceName, str recoMode)
 
AthConfigFlags tauIso (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 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)
 
def derivedFromSignatureFlags (AthConfigFlags flags, str recoMode)
 
def collToRecordable (flags, name)
 
def addGlobalFlags (AthConfigFlags flags, str category)
 

Variables

 log
 
 flags
 
 sig
 
 fun
 
 mode
 

Function Documentation

◆ addGlobalFlags()

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

Definition at line 852 of file BuildSignatureFlags.py.

852 def addGlobalFlags(flags: AthConfigFlags, category : str):
853  flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
854  flags.addFlag(f'{category}.doGPU', False)
855  flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
856  flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
857  flags.addFlag(f'{category}.UseTracklets', False)
858  flags.addFlag(f'{category}.trackletPoints', 1)
859  flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
860  flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
861  flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
862  flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
863  flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
864  flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
865  flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
866  flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
867  flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
868  flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
869  flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
870  flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
871  flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
872  flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
873 

◆ beamSpot()

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

Definition at line 475 of file BuildSignatureFlags.py.

475 def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
476 
477  flags.input_name = instanceName
478  flags.name = "beamSpot"
479  flags.suffix = "BeamSpot"
480  flags.roi = "HLT_Roi_FS"
481  flags.doFullScan = True
482  flags.doZFinder = True
483  flags.DoubletDR_Max = 200
484  flags.SeedRadBinWidth = 10
485  flags.etaHalfWidth = 3
486  flags.phiHalfWidth = math.pi
487  flags.doTRT = False
488  flags.doSeedRedundancyCheck = True
489  flags.doRecord = False
490  return flags
491 
492 
493 @signatureActions

◆ beamSpotFS()

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

Definition at line 525 of file BuildSignatureFlags.py.

525 def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
526 
527  flags.input_name = instanceName
528  flags.name = "fullScan"
529  flags.suffix = "FS"
530  flags.roi = "HLT_Roi_FS"
531  flags.doFullScan = True
532  flags.etaHalfWidth = 3.
533  flags.phiHalfWidth = math.pi
534  flags.doTRT = False
535  flags.DoubletDR_Max = 200
536  flags.SeedRadBinWidth = 10
537  flags.TripletDoPPS = False
538  flags.nClustersMin = 8
539  flags.UseTrigSeedML = 4
540  flags.doRecord = False
541  return flags
542 
543 
544 @signatureActions

◆ bjet()

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

Definition at line 359 of file BuildSignatureFlags.py.

359 def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
360 
361  flags.input_name = instanceName
362  flags.name = "bjet"
363  flags.suffix = "Bjet"
364  flags.roi = "HLT_Roi_Bjet"
365  flags.etaHalfWidth = 0.4
366  flags.phiHalfWidth = 0.4
367  flags.zedHalfWidth = 10.0
368  flags.pTmin = 0.8*Units.GeV
369  flags.minPT = tsetter(flags.minPT, flags.pTmin)
370  flags.Xi2max = tsetter(flags.Xi2max,12.)
371  return flags
372 
373 @signatureActions

◆ bjetLRT()

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

Definition at line 687 of file BuildSignatureFlags.py.

687 def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
688 
689  flags.input_name = instanceName
690  flags.name = "bjetLRT"
691  flags.suffix = "BjetLRT"
692  flags.roi = "HLT_Roi_Bjet"
693  flags.etaHalfWidth = 0.4
694  flags.phiHalfWidth = 0.4
695  flags.UsePixelSpacePoints = False
696  flags.Triplet_D0Max = 300.
697  flags.TrackInitialD0Max = 300.
698  flags.TrackZ0Max = 500.
699  flags.nClustersMin = 8
700  flags.isLRT = True
701  #pt config
702  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
703  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
704  flags.maxEta = 2.7
705  flags.doEmCaloSeed = False
706 
707  return flags
708 
709 
710 @signatureActions

◆ bmumux()

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

Definition at line 586 of file BuildSignatureFlags.py.

586 def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
587 
588  flags.input_name = instanceName
589  flags.name = "bphysics"
590  flags.suffix = "Bmumux"
591  flags.roi = "HLT_Roi_Bmumux"
592  flags.Triplet_D0Max = 10.
593  flags.DoPhiFiltering = False
594  flags.etaHalfWidth = 0.75
595  flags.phiHalfWidth = 0.75
596  flags.zedHalfWidth = 50.
597  flags.doSeedRedundancyCheck = True
598  flags.SuperRoI = True
599  return flags
600 
601 @signatureActions

◆ collToRecordable()

def python.BuildSignatureFlags.collToRecordable (   flags,
  name 
)

Definition at line 829 of file BuildSignatureFlags.py.

829 def collToRecordable(flags,name):
830  # ToDo: should just be a flag set per signature in the per signature config
831  # and not setting parameters using tests on the signature name
832  ret = name
833  signature = flags.input_name
834  firstStage = True if "FTF" in name else False
835  record = True
836  if firstStage:
837  if signature in ["minBias","minBiasPixel","bjetLRT",
838  "beamSpot","BeamSpot"]:
839  record = False
840  else:
841  if signature in ["tauCore","tauIso","tauIsoBDT",
842  "jet","fullScan","FS","jetSuper",
843  "beamSpot", "BeamSpot","beamSpotFS",
844  "bjetLRT","DJetLRT","DVtxLRT"]:
845  record = False
846 
847  if record:
848  ret = recordable(name)
849 
850  return ret
851 

◆ cosmics()

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

Definition at line 545 of file BuildSignatureFlags.py.

545 def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
546 
547  flags.input_name = instanceName
548  flags.name = "cosmics"
549  flags.suffix = "Cosmic"
550  flags.roi = "HLT_Roi_Cosmics"
551  flags.Triplet_D0Max = 1000.0
552  flags.Triplet_D0_PPS_Max = 1000.0
553  flags.TrackInitialD0Max = 1000.
554  flags.TrackZ0Max = 1000.
555  flags.doTRT = False
556  flags.doFullScan = True
557  flags.etaHalfWidth = 3
558  flags.phiHalfWidth = math.pi
559 
560  flags.minPT = tsetter(flags.minPT, 0.5*Units.GeV)
561 
562  flags.nClustersMin = 4
563  flags.minSiNotShared = 3
564  flags.maxShared = 0
565  flags.nHolesMax = 3
566  flags.maxSiHoles = 3
567  flags.maxSCTHoles = 3
568  flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
569  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
570 
571  flags.Xi2max = tsetter(flags.Xi2max, 60.)
572  flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
573  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
574 
575  flags.nWeightedClustersMin= 8
576  flags.useSeedFilter = True
577  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
578  flags.roadWidth = 75.
579  flags.maxZImpact= tsetter(flags.maxZImpact, 10000.*Units.mm)
580  if recoMode=="InDet":
581  flags.minTRTonTrk = 20
582 
583  return flags
584 
585 @signatureActions

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 94 of file BuildSignatureFlags.py.

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

◆ defaultITkTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultITkTrigTrackingFlags ( )

Definition at line 128 of file BuildSignatureFlags.py.

128 def defaultITkTrigTrackingFlags() -> AthConfigFlags:
129 
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 
153  return flags
154 

◆ defaultModeTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultModeTrigTrackingFlags ( AthConfigFlags  flags)

Definition at line 155 of file BuildSignatureFlags.py.

155 def defaultModeTrigTrackingFlags(flags: AthConfigFlags) -> AthConfigFlags:
156  return flags
157 

◆ defaultTrigTrackingFlags()

def python.BuildSignatureFlags.defaultTrigTrackingFlags ( AthConfigFlags  flags)

Definition at line 15 of file BuildSignatureFlags.py.

15 def defaultTrigTrackingFlags(flags : AthConfigFlags):
16 
17  flags.addFlag("input_name", "")
18  flags.addFlag("name", "")
19  flags.addFlag("suffix", "")
20 
21  flags.addFlag("pTmin", 1.*Units.GeV) #fix - consolidate pTmin and minPT
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) #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 
93 

◆ derivedFromSignatureFlags()

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

Definition at line 798 of file BuildSignatureFlags.py.

798 def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
799 
800  flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
801  flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
802  flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
803  # ToDo: shouldn't be setting flags using this if type structures, the flags should be
804  # actually set somewhere in appropriate config functions
805  flags.tracks_IDTrig = collToRecordable(flags,"HLT_IDTrack_{}_IDTrig".format(flags.suffix if flags.input_name != "tauIso" else "Tau"))
806 
807  if recoMode == "Acts":
808  flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
809  flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
810 
811  if flags.isLRT: # to be moved to a separate function once LRTs differ
812  flags.minClusters = tsetter(flags.minClusters , 8)
813  flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
814  flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
815  flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
816  flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
817  flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
818  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
819  flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
820 
821 
822  if recoMode == "ITk":
823  flags.extension = flags.input_name #needed in the ITk mode?
824 
825  if flags.isLRT:
826  flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
827 
828 

◆ diTau()

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

Definition at line 341 of file BuildSignatureFlags.py.

341 def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
342 
343  flags.input_name = instanceName
344  flags.name = "diTau"
345  flags.suffix = "DiTau"
346  flags.roi = "HLT_Roi_DiTau"
347  flags.etaHalfWidth = 1.0
348  flags.phiHalfWidth = 1.0
349  flags.zedHalfWidth = 7.0
350  flags.adaptiveVertex = True
351  flags.addSingleTrackVertices = True
352  flags.vertex = "HLT_IDVertex_DiTau"
353  flags.electronPID = False
354  flags.pTmin = 0.8*Units.GeV
355  flags.minPT = tsetter(flags.minPT, flags.pTmin)
356  return flags
357 
358 @signatureActions

◆ DJetLRT()

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

Definition at line 740 of file BuildSignatureFlags.py.

740 def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
741 
742  flags.input_name = instanceName
743  flags.name = "DJetLRT"
744  flags.suffix = "DJLRT"
745  flags.roi = "HLT_Roi_DJ"
746  flags.doFullScan = False
747  flags.etaHalfWidth = 0.4
748  flags.phiHalfWidth = 0.4
749  flags.zedHalfWidth = 225.
750  flags.doTRT = False
751  flags.doSeedRedundancyCheck = True
752  flags.UsePixelSpacePoints = False
753  flags.Triplet_D0Max = 300.
754  flags.TrackInitialD0Max = 300.
755  flags.TrackZ0Max = 500.
756  flags.Triplet_D0_PPS_Max = 300.
757  flags.DoubletDR_Max = 200
758  flags.nClustersMin = 8
759  flags.isLRT = True
760  #pt config
761  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
762  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
763  flags.maxEta = 2.7
764  flags.doEmCaloSeed = False
765 
766  return flags
767 
768 
769 @signatureActions

◆ DVtxLRT()

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

Definition at line 770 of file BuildSignatureFlags.py.

770 def DVtxLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
771 
772  flags.input_name = instanceName
773  flags.name = "DVtxLRT"
774  flags.suffix = "DVLRT"
775  flags.roi = "HLT_Roi_DV"
776  flags.doFullScan = False
777  flags.etaHalfWidth = 0.35
778  flags.phiHalfWidth = 0.35
779  flags.doTRT = False
780  flags.doSeedRedundancyCheck = True
781  flags.UsePixelSpacePoints = False
782  flags.Triplet_D0Max = 300.
783  flags.TrackInitialD0Max = 300.
784  flags.TrackZ0Max = 500.
785  flags.Triplet_D0_PPS_Max = 300.
786  flags.DoubletDR_Max = 200
787  flags.nClustersMin = 8
788  flags.isLRT = True
789  #pt config
790  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
791  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
792  flags.maxEta = 2.7
793  flags.doEmCaloSeed = False
794 
795  return flags
796 
797 

◆ electron()

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

Definition at line 267 of file BuildSignatureFlags.py.

267 def electron(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
268 
269  flags.input_name = instanceName
270  flags.name = "electron"
271  flags.suffix = "Electron"
272  flags.roi = "HLT_Roi_Electron"
273  flags.etaHalfWidth = 0.05 # this size should be increased to 0.1
274  flags.phiHalfWidth = 0.1
275  flags.doCloneRemoval = True
276  flags.doSeedRedundancyCheck = True
277  if recoMode=="InDet":
278  flags.doTRT = True
279  flags.keepTrackParameters = True
280  flags.electronPID = True
281  return flags
282 
283 @signatureActions

◆ electronLRT()

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

Definition at line 602 of file BuildSignatureFlags.py.

602 def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
603 
604  flags.input_name = instanceName
605  flags.name = "electronLRT"
606  flags.suffix = "ElecLRT"
607  flags.roi = "HLT_Roi_Electron"
608  flags.etaHalfWidth = 0.1
609  flags.phiHalfWidth = 0.4
610  flags.UsePixelSpacePoints = False
611  flags.Triplet_D0Max = 300.
612  flags.TrackInitialD0Max = 300.
613  flags.TrackZ0Max = 500.
614  flags.zedHalfWidth = 225.
615  flags.keepTrackParameters = True
616  flags.doSeedRedundancyCheck = True
617  flags.nClustersMin = 8
618  flags.isLRT = True
619  #pt config
620  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
621  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
622  flags.maxEta = 2.7
623  flags.doEmCaloSeed = False
624  return flags
625 
626 
627 @signatureActions

◆ fullScan()

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

Definition at line 494 of file BuildSignatureFlags.py.

494 def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
495 
496  flags.input_name = instanceName
497  flags.name = "fullScan"
498  flags.suffix = "FS"
499  flags.roi = "HLT_Roi_FS"
500  flags.vertex = "HLT_IDVertex_FS"
501  flags.adaptiveVertex = True
502  # these are being evaluated and may be added
503  # flags.addSingleTrackVertices = True
504  # flags.TracksMaxZinterval = 3
505  flags.vertex_jet = "HLT_IDVertex_FS"
506  flags.adaptiveVertex_jet = True
507  flags.doFullScan = True
508  flags.etaHalfWidth = 3.
509  flags.phiHalfWidth = math.pi
510  flags.doTRT = False
511  flags.DoubletDR_Max = 200
512  flags.SeedRadBinWidth = 10
513  flags.doSeedRedundancyCheck = True
514  flags.TripletDoPPS = False
515  flags.nClustersMin = 8
516  flags.UseTrigSeedML = 4
517  flags.dodEdxTrk = True
518  flags.doHitDV = True
519  flags.doDisappearingTrk = True if recoMode=="InDet" else False
520  flags.roadWidth = 5.
521  return flags
522 
523 
524 @signatureActions

◆ fullScanLRT()

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

Definition at line 711 of file BuildSignatureFlags.py.

711 def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
712 
713  flags.input_name = instanceName
714  flags.name = "fullScanLRT"
715  flags.suffix = "FSLRT"
716  flags.roi = "HLT_Roi_FS"
717  flags.doFullScan = True
718  flags.etaHalfWidth = 3.
719  flags.phiHalfWidth = math.pi
720  flags.doTRT = False
721  flags.doSeedRedundancyCheck = True
722  flags.UsePixelSpacePoints = False
723  flags.Triplet_D0Max = 300.
724  flags.TrackInitialD0Max = 300.
725  flags.TrackZ0Max = 500.
726  flags.Triplet_D0_PPS_Max = 300.
727  flags.DoubletDR_Max = 200
728  flags.nClustersMin = 8
729  flags.isLRT = True
730  #pt config
731  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
732  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
733  flags.maxEta = 2.7
734  flags.doEmCaloSeed = False
735 
736  return flags
737 
738 
739 @signatureActions

◆ jetSuper()

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

Definition at line 374 of file BuildSignatureFlags.py.

374 def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
375 
376  flags.input_name = instanceName
377  flags.name = "jetSuper"
378  flags.suffix = "JetSuper"
379  flags.vertex = "HLT_IDVertex_JetSuper"
380  flags.adaptiveVertex = True
381  flags.addSingleTrackVertices = True
382  flags.roi = "HLT_Roi_JetSuper"
383  flags.etaHalfWidth = 0.3
384  flags.phiHalfWidth = 0.3
385  flags.doFullScan = True
386  flags.pTmin = 1*Units.GeV
387  flags.minPT = tsetter(flags.minPT, flags.pTmin)
388  #-----
389  flags.doTRT = False
390  flags.DoubletDR_Max = 200
391  flags.SeedRadBinWidth = 10
392  flags.doSeedRedundancyCheck = True
393  flags.TripletDoPPS = False
394  flags.nClustersMin = 8
395  flags.UseTrigSeedML = 4
396  flags.roadWidth = 5.
397  return flags
398 
399 @signatureActions

◆ minBias()

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

Definition at line 400 of file BuildSignatureFlags.py.

400 def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
401 
402  flags.input_name = instanceName
403  flags.name = "minBias"
404  flags.suffix = "MinBias"
405  flags.roi = "HLT_Roi_MinBias"
406  flags.doFullScan = True
407  flags.pTmin = 0.1*Units.GeV # TODO: double check
408  flags.minPT = tsetter(flags.minPT, flags.pTmin)
409 
410  flags.doTRT = False
411  flags.etaHalfWidth = 3
412  flags.phiHalfWidth = math.pi
413  flags.doZFinder = True
414  flags.doZFinderOnly = True
415 
416  flags.nClustersMin = 5
417  flags.useSeedFilter = True
418  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
419  flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
420  flags.roadWidth = 20
421  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
422  return flags
423 
424 
425 @signatureActions

◆ minBiasPixel()

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

Definition at line 426 of file BuildSignatureFlags.py.

426 def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
427 
428  flags.input_name = instanceName
429  flags.name = "minBiasPixel"
430  flags.suffix = "MinBiasPixel"
431  flags.roi = "HLT_Roi_MinBias"
432  flags.doFullScan = True
433  flags.pTmin = 0.1*Units.GeV # this is good for HI which is the client of this setup
434  flags.minPT = tsetter(flags.minPT, flags.pTmin)
435 
436 
437  flags.maxHoles = 0 # HI setup
438  flags.maxPixelHoles = 0 # HI setup
439  flags.maxSctHoles = 0
440  flags.maxDoubleHoles = 0
441  flags.minSiNotShared = 3
442  flags.maxShared = 0
443  flags.nHolesMax = 0
444  flags.nHolesGapMax = 0
445  if recoMode=="InDet":
446  flags.useSCT = False
447  flags.useSCTSeeding = False
448  flags.useTRT = False
449 
450  flags.roadWidth = 12.0
451  flags.Xi2max = 15
452  flags.Xi2maxNoAdd = 35.0
453  flags.nWeightedClustersMin = 6
454  flags.doBremRecoverySi = False
455  flags.RunPixelPID = False # we use these tracks only for counting
456 
457  flags.doTRT = False
458  flags.etaHalfWidth = 3
459  flags.phiHalfWidth = math.pi
460  flags.doZFinder = False
461  flags.doZFinderOnly = True
462 
463  flags.minClusters = 3
464  flags.nClustersMin = 3
465  flags.useSeedFilter = True
466  flags.maxPrimaryImpact = 10.*Units.mm
467  flags.maxZImpact = 150.*Units.mm
468  flags.roadWidth = 20
469  flags.usePrdAssociationTool = False
470  return flags
471 
472 
473 
474 @signatureActions

◆ muon()

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

Definition at line 284 of file BuildSignatureFlags.py.

284 def muon(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
285 
286  flags.input_name = instanceName
287  flags.name = "muon"
288  flags.suffix = "Muon"
289  flags.roi = "HLT_Roi_L2SAMuon"
290  flags.Triplet_D0Max = 10.0
291  flags.doResMon = True
292  flags.DoPhiFiltering = False
293  flags.doSeedRedundancyCheck = True
294  flags.monPtMin = 12*Units.GeV
295  return flags
296 
297 @signatureActions

◆ muonIso()

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

Definition at line 298 of file BuildSignatureFlags.py.

298 def muonIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
299 
300  flags.input_name = instanceName
301  flags.name = "muonIso"
302  flags.suffix = "MuonIso"
303  flags.roi = "HLT_Roi_MuonIso"
304  flags.etaHalfWidth = 0.35
305  flags.phiHalfWidth = 0.35
306  flags.zedHalfWidth = 10.0
307  return flags
308 
309 @signatureActions

◆ muonLRT()

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

Definition at line 628 of file BuildSignatureFlags.py.

628 def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
629 
630  flags.input_name = instanceName
631  flags.name = "muonLRT"
632  flags.suffix = "MuonLRT"
633  flags.roi = "HLT_Roi_Muon"
634  flags.UsePixelSpacePoints = False
635  flags.etaHalfWidth = 0.2
636  flags.phiHalfWidth = 0.4
637  flags.Triplet_D0Max = 300.
638  flags.TrackInitialD0Max = 300.
639  flags.TrackZ0Max = 500.
640  flags.zedHalfWidth = 225.
641  flags.doSeedRedundancyCheck = True
642  flags.nClustersMin = 8
643  flags.isLRT = True
644  flags.doResMon = True
645  flags.DoPhiFiltering = False
646  #pt config
647  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
648  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
649  flags.maxEta = 2.7
650  flags.doEmCaloSeed = False
651 
652  return flags
653 
654 
655 
656 @signatureActions

◆ signatureActions()

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

Definition at line 238 of file BuildSignatureFlags.py.

238 def signatureActions(func):
239  """ convenience decorator to automate config steps """
240  def invokeSteps(*args, **kwargs):
241  flagsSig = func(*args, **kwargs) #invoke signature specific code
242  recoMode = args[2]
243  derivedFromSignatureFlags(flagsSig,recoMode) #invoke code dependant on signature flags
244  return flagsSig
245  return invokeSteps
246 
247 

◆ signatureTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.signatureTrigTrackingFlags ( str  mode)

Definition at line 158 of file BuildSignatureFlags.py.

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

◆ tauCore()

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

Definition at line 310 of file BuildSignatureFlags.py.

310 def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
311 
312  flags.input_name = instanceName
313  flags.name = "tauCore"
314  flags.suffix = "TauCore"
315  flags.roi = "HLT_Roi_TauCore"
316  flags.pTmin = 0.8*Units.GeV
317  flags.minPT = tsetter(flags.minPT, flags.pTmin)
318 
319  flags.holeSearch_FTF = True
320  return flags
321 
322 @signatureActions

◆ tauIso()

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

Definition at line 323 of file BuildSignatureFlags.py.

323 def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
324 
325  flags.input_name = instanceName
326  flags.name = "tauIso"
327  flags.suffix = "TauIso"
328  flags.roi = "HLT_Roi_TauIso"
329  flags.etaHalfWidth = 0.4
330  flags.phiHalfWidth = 0.4
331  flags.zedHalfWidth = 7.0
332  flags.adaptiveVertex = True
333  flags.addSingleTrackVertices = True
334  flags.vertex = "HLT_IDVertex_Tau"
335  flags.electronPID = False
336  flags.pTmin = 0.8*Units.GeV
337  flags.minPT = tsetter(flags.minPT, flags.pTmin)
338  return flags
339 
340 @signatureActions

◆ tauLRT()

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

Definition at line 657 of file BuildSignatureFlags.py.

657 def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
658 
659  flags.input_name = instanceName
660  flags.name = "tauLRT"
661  flags.suffix = "TauLRT"
662  flags.roi = "HLT_Roi_TauLRT"
663  flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
664  flags.pTmin = 0.8*Units.GeV
665  flags.minPT = tsetter(flags.minPT, flags.pTmin)
666  flags.etaHalfWidth = 0.4
667  flags.phiHalfWidth = 0.4
668  flags.zedHalfWidth = 225.
669  flags.UsePixelSpacePoints = False
670  flags.Triplet_D0Max = 300.
671  flags.TrackInitialD0Max = 300.
672  flags.TrackZ0Max = 500.
673  flags.nClustersMin = 8
674  flags.isLRT = True
675  #pt config
676  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
677  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
678  flags.maxEta = 2.7
679  flags.doEmCaloSeed = False
680  if recoMode=="InDet":
681  flags.doTRT = True
682 
683  return flags
684 
685 
686 @signatureActions

◆ tsetter()

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

248 def tsetter(var, value):
249  """ use previous type of the var and convert value to it
250  for the moment just makes list of a value if needed
251  """
252  type2set = type(var)
253  typeOfValue = type(value)
254  if type2set == typeOfValue:
255  var = value
256  else:
257  basic = (bool, str, int, float, type(None))
258  if isinstance(var,basic):
259  var = value
260  else:
261  var = [value]
262 
263  return var
264 
265 
266 @signatureActions

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags

Definition at line 220 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun

Definition at line 222 of file BuildSignatureFlags.py.

◆ log

python.BuildSignatureFlags.log

Definition at line 13 of file BuildSignatureFlags.py.

◆ mode

python.BuildSignatureFlags.mode

Definition at line 223 of file BuildSignatureFlags.py.

◆ sig

python.BuildSignatureFlags.sig

Definition at line 221 of file BuildSignatureFlags.py.

python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:359
python.BuildSignatureFlags.tauIso
AthConfigFlags tauIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:323
vtune_athena.format
format
Definition: vtune_athena.py:14
python.BuildSignatureFlags.muonLRT
AthConfigFlags muonLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:628
python.BuildSignatureFlags.tauLRT
AthConfigFlags tauLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:657
python.BuildSignatureFlags.addGlobalFlags
def addGlobalFlags(AthConfigFlags flags, str category)
Definition: BuildSignatureFlags.py:852
run
int run(int argc, char *argv[])
Definition: ttree2hdf5.cxx:28
python.BuildSignatureFlags.defaultITkTrigTrackingFlags
AthConfigFlags defaultITkTrigTrackingFlags()
Definition: BuildSignatureFlags.py:128
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
python.TrackingPassFlags.createTrackingPassFlags
def createTrackingPassFlags()
Definition: TrackingPassFlags.py:18
python.BuildSignatureFlags.diTau
AthConfigFlags diTau(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:341
python.BuildSignatureFlags.defaultModeTrigTrackingFlags
AthConfigFlags defaultModeTrigTrackingFlags(AthConfigFlags flags)
Definition: BuildSignatureFlags.py:155
python.BuildSignatureFlags.fullScanLRT
AthConfigFlags fullScanLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:711
python.BuildSignatureFlags.signatureTrigTrackingFlags
AthConfigFlags signatureTrigTrackingFlags(str mode)
Definition: BuildSignatureFlags.py:158
python.BuildSignatureFlags.collToRecordable
def collToRecordable(flags, name)
Definition: BuildSignatureFlags.py:829
python.BuildSignatureFlags.tauCore
AthConfigFlags tauCore(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:310
python.BuildSignatureFlags.defaultInDetTrigTrackingFlags
AthConfigFlags defaultInDetTrigTrackingFlags()
Definition: BuildSignatureFlags.py:94
python.BuildSignatureFlags.bmumux
AthConfigFlags bmumux(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:586
python.BuildSignatureFlags.minBiasPixel
AthConfigFlags minBiasPixel(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:426
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:545
python.BuildSignatureFlags.muonIso
AthConfigFlags muonIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:298
python.BuildSignatureFlags.defaultTrigTrackingFlags
def defaultTrigTrackingFlags(AthConfigFlags flags)
Definition: BuildSignatureFlags.py:15
python.BuildSignatureFlags.minBias
AthConfigFlags minBias(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:400
Base_Fragment.defaults
dictionary defaults
This includes now the top quark, the leptons and the bosons.
Definition: GeneratorFilters/share/common/Base_Fragment.py:79
python.processes.powheg.ZZ.ZZ.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZ.py:18
python.BuildSignatureFlags.beamSpotFS
AthConfigFlags beamSpotFS(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:525
python.BuildSignatureFlags.electronLRT
AthConfigFlags electronLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:602
python.BuildSignatureFlags.tsetter
def tsetter(var, value)
Definition: BuildSignatureFlags.py:248
python.TriggerEDM.recordable
def recordable(arg, runVersion=3)
Definition: TriggerEDM.py:34
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:475
python.BuildSignatureFlags.DJetLRT
AthConfigFlags DJetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:740
python.BuildSignatureFlags.DVtxLRT
AthConfigFlags DVtxLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:770
python.BuildSignatureFlags.jetSuper
AthConfigFlags jetSuper(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:374
python.BuildSignatureFlags.signatureActions
def signatureActions(func)
Definition: BuildSignatureFlags.py:238
python.BuildSignatureFlags.derivedFromSignatureFlags
def derivedFromSignatureFlags(AthConfigFlags flags, str recoMode)
Definition: BuildSignatureFlags.py:798
python.BuildSignatureFlags.fullScan
AthConfigFlags fullScan(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:494
python.TrackingPassFlags.createITkTrackingPassFlags
def createITkTrackingPassFlags()
ITk mode ####################.
Definition: TrackingPassFlags.py:121
python.BuildSignatureFlags.bjetLRT
AthConfigFlags bjetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:687
Generated on Tue Jul 15 2025 22:09:18 for ATLAS Offline Software by   doxygen 1.8.18