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

Classes

class  FlagValuesTest
 

Functions

def defaultTrigTrackingFlags (AthConfigFlags flags)
 
AthConfigFlags defaultInDetTrigTrackingFlags ()
 
AthConfigFlags defaultITkTrigTrackingFlags ()
 
AthConfigFlags defaultITkActsTrigTrackingFlags ()
 
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 868 of file BuildSignatureFlags.py.

868 def addGlobalFlags(flags: AthConfigFlags, category : str):
869  flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
870  flags.addFlag(f'{category}.doGPU', False)
871  flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
872  flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
873  flags.addFlag(f'{category}.UseTracklets', False)
874  flags.addFlag(f'{category}.trackletPoints', 1)
875  flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
876  flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
877  flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
878  flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
879  flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
880  flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
881  flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
882  flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
883  flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
884  flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
885  flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
886  flags.addFlag(f'{category}.TRT_DriftCircleKey', "TRT_TrigDriftCircles")
887  flags.addFlag(f'{category}.PixClustersAmbiMap', "TrigPixelClusterAmbiguitiesMap")
888  flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
889 

◆ beamSpot()

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

Definition at line 491 of file BuildSignatureFlags.py.

491 def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
492 
493  flags.input_name = instanceName
494  flags.name = "beamSpot"
495  flags.suffix = "BeamSpot"
496  flags.roi = "HLT_Roi_FS"
497  flags.doFullScan = True
498  flags.doZFinder = True
499  flags.DoubletDR_Max = 200
500  flags.SeedRadBinWidth = 10
501  flags.etaHalfWidth = 3
502  flags.phiHalfWidth = math.pi
503  flags.doTRT = False
504  flags.doSeedRedundancyCheck = True
505  flags.doRecord = False
506  return flags
507 
508 
509 @signatureActions

◆ beamSpotFS()

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

Definition at line 541 of file BuildSignatureFlags.py.

541 def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
542 
543  flags.input_name = instanceName
544  flags.name = "fullScan"
545  flags.suffix = "FS"
546  flags.roi = "HLT_Roi_FS"
547  flags.doFullScan = True
548  flags.etaHalfWidth = 3.
549  flags.phiHalfWidth = math.pi
550  flags.doTRT = False
551  flags.DoubletDR_Max = 200
552  flags.SeedRadBinWidth = 10
553  flags.TripletDoPPS = False
554  flags.nClustersMin = 8
555  flags.UseTrigSeedML = 4
556  flags.doRecord = False
557  return flags
558 
559 
560 @signatureActions

◆ bjet()

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

Definition at line 375 of file BuildSignatureFlags.py.

375 def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
376 
377  flags.input_name = instanceName
378  flags.name = "bjet"
379  flags.suffix = "Bjet"
380  flags.roi = "HLT_Roi_Bjet"
381  flags.etaHalfWidth = 0.4
382  flags.phiHalfWidth = 0.4
383  flags.zedHalfWidth = 10.0
384  flags.pTmin = 0.8*Units.GeV
385  flags.minPT = tsetter(flags.minPT, flags.pTmin)
386  flags.Xi2max = tsetter(flags.Xi2max,12.)
387  return flags
388 
389 @signatureActions

◆ bjetLRT()

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

Definition at line 703 of file BuildSignatureFlags.py.

703 def bjetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
704 
705  flags.input_name = instanceName
706  flags.name = "bjetLRT"
707  flags.suffix = "BjetLRT"
708  flags.roi = "HLT_Roi_Bjet"
709  flags.etaHalfWidth = 0.4
710  flags.phiHalfWidth = 0.4
711  flags.UsePixelSpacePoints = False
712  flags.Triplet_D0Max = 300.
713  flags.TrackInitialD0Max = 300.
714  flags.TrackZ0Max = 500.
715  flags.nClustersMin = 8
716  flags.isLRT = True
717  #pt config
718  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
719  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
720  flags.maxEta = 2.7
721  flags.doEmCaloSeed = False
722 
723  return flags
724 
725 
726 @signatureActions

◆ bmumux()

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

Definition at line 602 of file BuildSignatureFlags.py.

602 def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
603 
604  flags.input_name = instanceName
605  flags.name = "bphysics"
606  flags.suffix = "Bmumux"
607  flags.roi = "HLT_Roi_Bmumux"
608  flags.Triplet_D0Max = 10.
609  flags.DoPhiFiltering = False
610  flags.etaHalfWidth = 0.75
611  flags.phiHalfWidth = 0.75
612  flags.zedHalfWidth = 50.
613  flags.doSeedRedundancyCheck = True
614  flags.SuperRoI = True
615  return flags
616 
617 @signatureActions

◆ collToRecordable()

def python.BuildSignatureFlags.collToRecordable (   flags,
  name 
)

Definition at line 845 of file BuildSignatureFlags.py.

845 def collToRecordable(flags,name):
846  # ToDo: should just be a flag set per signature in the per signature config
847  # and not setting parameters using tests on the signature name
848  ret = name
849  signature = flags.input_name
850  firstStage = True if "FTF" in name else False
851  record = True
852  if firstStage:
853  if signature in ["minBias","minBiasPixel","bjetLRT",
854  "beamSpot","BeamSpot"]:
855  record = False
856  else:
857  if signature in ["tauCore","tauIso","tauIsoBDT",
858  "jet","fullScan","FS","jetSuper",
859  "beamSpot", "BeamSpot","beamSpotFS",
860  "bjetLRT","DJetLRT","DVtxLRT"]:
861  record = False
862 
863  if record:
864  ret = recordable(name)
865 
866  return ret
867 

◆ cosmics()

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

Definition at line 561 of file BuildSignatureFlags.py.

561 def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
562 
563  flags.input_name = instanceName
564  flags.name = "cosmics"
565  flags.suffix = "Cosmic"
566  flags.roi = "HLT_Roi_Cosmics"
567  flags.Triplet_D0Max = 1000.0
568  flags.Triplet_D0_PPS_Max = 1000.0
569  flags.TrackInitialD0Max = 1000.
570  flags.TrackZ0Max = 1000.
571  flags.doTRT = False
572  flags.doFullScan = True
573  flags.etaHalfWidth = 3
574  flags.phiHalfWidth = math.pi
575 
576  flags.minPT = tsetter(flags.minPT, 0.5*Units.GeV)
577 
578  flags.nClustersMin = 4
579  flags.minSiNotShared = 3
580  flags.maxShared = 0
581  flags.nHolesMax = 3
582  flags.maxSiHoles = 3
583  flags.maxSCTHoles = 3
584  flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
585  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
586 
587  flags.Xi2max = tsetter(flags.Xi2max, 60.)
588  flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
589  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
590 
591  flags.nWeightedClustersMin= 8
592  flags.useSeedFilter = True
593  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
594  flags.roadWidth = 75.
595  flags.maxZImpact= tsetter(flags.maxZImpact, 10000.*Units.mm)
596  if recoMode=="InDet":
597  flags.minTRTonTrk = 20
598 
599  return flags
600 
601 @signatureActions

◆ defaultInDetTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.defaultInDetTrigTrackingFlags ( )

Definition at line 95 of file BuildSignatureFlags.py.

95 def 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.

155 def 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.

129 def 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.

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

◆ defaultTrigTrackingFlags()

def python.BuildSignatureFlags.defaultTrigTrackingFlags ( AthConfigFlags  flags)

Definition at line 16 of file BuildSignatureFlags.py.

16 def 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()

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

Definition at line 814 of file BuildSignatureFlags.py.

814 def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
815 
816  flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
817  flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
818  flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
819  # ToDo: shouldn't be setting flags using this if type structures, the flags should be
820  # actually set somewhere in appropriate config functions
821  flags.tracks_IDTrig = collToRecordable(flags,"HLT_IDTrack_{}_IDTrig".format(flags.suffix if flags.input_name != "tauIso" else "Tau"))
822 
823  if recoMode == "Acts":
824  flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
825  flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
826 
827  if flags.isLRT: # to be moved to a separate function once LRTs differ
828  flags.minClusters = tsetter(flags.minClusters , 8)
829  flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
830  flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
831  flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
832  flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
833  flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
834  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
835  flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
836 
837 
838  if recoMode == "ITk":
839  flags.extension = flags.input_name #needed in the ITk mode?
840 
841  if flags.isLRT:
842  flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
843 
844 

◆ diTau()

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

Definition at line 357 of file BuildSignatureFlags.py.

357 def diTau(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
358 
359  flags.input_name = instanceName
360  flags.name = "diTau"
361  flags.suffix = "DiTau"
362  flags.roi = "HLT_Roi_DiTau"
363  flags.etaHalfWidth = 1.0
364  flags.phiHalfWidth = 1.0
365  flags.zedHalfWidth = 7.0
366  flags.adaptiveVertex = True
367  flags.addSingleTrackVertices = True
368  flags.vertex = "HLT_IDVertex_DiTau"
369  flags.electronPID = False
370  flags.pTmin = 0.8*Units.GeV
371  flags.minPT = tsetter(flags.minPT, flags.pTmin)
372  return flags
373 
374 @signatureActions

◆ DJetLRT()

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

Definition at line 756 of file BuildSignatureFlags.py.

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

◆ DVtxLRT()

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

Definition at line 786 of file BuildSignatureFlags.py.

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

◆ electron()

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

Definition at line 283 of file BuildSignatureFlags.py.

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

◆ electronLRT()

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

Definition at line 618 of file BuildSignatureFlags.py.

618 def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
619 
620  flags.input_name = instanceName
621  flags.name = "electronLRT"
622  flags.suffix = "ElecLRT"
623  flags.roi = "HLT_Roi_Electron"
624  flags.etaHalfWidth = 0.1
625  flags.phiHalfWidth = 0.4
626  flags.UsePixelSpacePoints = False
627  flags.Triplet_D0Max = 300.
628  flags.TrackInitialD0Max = 300.
629  flags.TrackZ0Max = 500.
630  flags.zedHalfWidth = 225.
631  flags.keepTrackParameters = True
632  flags.doSeedRedundancyCheck = True
633  flags.nClustersMin = 8
634  flags.isLRT = True
635  #pt config
636  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
637  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
638  flags.maxEta = 2.7
639  flags.doEmCaloSeed = False
640  return flags
641 
642 
643 @signatureActions

◆ fullScan()

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

Definition at line 510 of file BuildSignatureFlags.py.

510 def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
511 
512  flags.input_name = instanceName
513  flags.name = "fullScan"
514  flags.suffix = "FS"
515  flags.roi = "HLT_Roi_FS"
516  flags.vertex = "HLT_IDVertex_FS"
517  flags.adaptiveVertex = True
518  # these are being evaluated and may be added
519  # flags.addSingleTrackVertices = True
520  # flags.TracksMaxZinterval = 3
521  flags.vertex_jet = "HLT_IDVertex_FS"
522  flags.adaptiveVertex_jet = True
523  flags.doFullScan = True
524  flags.etaHalfWidth = 3.
525  flags.phiHalfWidth = math.pi
526  flags.doTRT = False
527  flags.DoubletDR_Max = 200
528  flags.SeedRadBinWidth = 10
529  flags.doSeedRedundancyCheck = True
530  flags.TripletDoPPS = False
531  flags.nClustersMin = 8
532  flags.UseTrigSeedML = 4
533  flags.dodEdxTrk = True
534  flags.doHitDV = True
535  flags.doDisappearingTrk = True if recoMode=="InDet" else False
536  flags.roadWidth = 5.
537  return flags
538 
539 
540 @signatureActions

◆ fullScanLRT()

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

Definition at line 727 of file BuildSignatureFlags.py.

727 def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
728 
729  flags.input_name = instanceName
730  flags.name = "fullScanLRT"
731  flags.suffix = "FSLRT"
732  flags.roi = "HLT_Roi_FS"
733  flags.doFullScan = True
734  flags.etaHalfWidth = 3.
735  flags.phiHalfWidth = math.pi
736  flags.doTRT = False
737  flags.doSeedRedundancyCheck = True
738  flags.UsePixelSpacePoints = False
739  flags.Triplet_D0Max = 300.
740  flags.TrackInitialD0Max = 300.
741  flags.TrackZ0Max = 500.
742  flags.Triplet_D0_PPS_Max = 300.
743  flags.DoubletDR_Max = 200
744  flags.nClustersMin = 8
745  flags.isLRT = True
746  #pt config
747  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
748  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
749  flags.maxEta = 2.7
750  flags.doEmCaloSeed = False
751 
752  return flags
753 
754 
755 @signatureActions

◆ jetSuper()

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

Definition at line 390 of file BuildSignatureFlags.py.

390 def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
391 
392  flags.input_name = instanceName
393  flags.name = "jetSuper"
394  flags.suffix = "JetSuper"
395  flags.vertex = "HLT_IDVertex_JetSuper"
396  flags.adaptiveVertex = True
397  flags.addSingleTrackVertices = True
398  flags.roi = "HLT_Roi_JetSuper"
399  flags.etaHalfWidth = 0.3
400  flags.phiHalfWidth = 0.3
401  flags.doFullScan = True
402  flags.pTmin = 1*Units.GeV
403  flags.minPT = tsetter(flags.minPT, flags.pTmin)
404  #-----
405  flags.doTRT = False
406  flags.DoubletDR_Max = 200
407  flags.SeedRadBinWidth = 10
408  flags.doSeedRedundancyCheck = True
409  flags.TripletDoPPS = False
410  flags.nClustersMin = 8
411  flags.UseTrigSeedML = 4
412  flags.roadWidth = 5.
413  return flags
414 
415 @signatureActions

◆ minBias()

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

Definition at line 416 of file BuildSignatureFlags.py.

416 def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
417 
418  flags.input_name = instanceName
419  flags.name = "minBias"
420  flags.suffix = "MinBias"
421  flags.roi = "HLT_Roi_MinBias"
422  flags.doFullScan = True
423  flags.pTmin = 0.1*Units.GeV # TODO: double check
424  flags.minPT = tsetter(flags.minPT, flags.pTmin)
425 
426  flags.doTRT = False
427  flags.etaHalfWidth = 3
428  flags.phiHalfWidth = math.pi
429  flags.doZFinder = True
430  flags.doZFinderOnly = True
431 
432  flags.nClustersMin = 5
433  flags.useSeedFilter = True
434  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
435  flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
436  flags.roadWidth = 20
437  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
438  return flags
439 
440 
441 @signatureActions

◆ minBiasPixel()

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

Definition at line 442 of file BuildSignatureFlags.py.

442 def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
443 
444  flags.input_name = instanceName
445  flags.name = "minBiasPixel"
446  flags.suffix = "MinBiasPixel"
447  flags.roi = "HLT_Roi_MinBias"
448  flags.doFullScan = True
449  flags.pTmin = 0.1*Units.GeV # this is good for HI which is the client of this setup
450  flags.minPT = tsetter(flags.minPT, flags.pTmin)
451 
452 
453  flags.maxHoles = 0 # HI setup
454  flags.maxPixelHoles = 0 # HI setup
455  flags.maxSctHoles = 0
456  flags.maxDoubleHoles = 0
457  flags.minSiNotShared = 3
458  flags.maxShared = 0
459  flags.nHolesMax = 0
460  flags.nHolesGapMax = 0
461  if recoMode=="InDet":
462  flags.useSCT = False
463  flags.useSCTSeeding = False
464  flags.useTRT = False
465 
466  flags.roadWidth = 12.0
467  flags.Xi2max = 15
468  flags.Xi2maxNoAdd = 35.0
469  flags.nWeightedClustersMin = 6
470  flags.doBremRecoverySi = False
471  flags.RunPixelPID = False # we use these tracks only for counting
472 
473  flags.doTRT = False
474  flags.etaHalfWidth = 3
475  flags.phiHalfWidth = math.pi
476  flags.doZFinder = False
477  flags.doZFinderOnly = True
478 
479  flags.minClusters = 3
480  flags.nClustersMin = 3
481  flags.useSeedFilter = True
482  flags.maxPrimaryImpact = 10.*Units.mm
483  flags.maxZImpact = 150.*Units.mm
484  flags.roadWidth = 20
485  flags.usePrdAssociationTool = False
486  return flags
487 
488 
489 
490 @signatureActions

◆ muon()

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

Definition at line 300 of file BuildSignatureFlags.py.

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

◆ muonIso()

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

Definition at line 314 of file BuildSignatureFlags.py.

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

◆ muonLRT()

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

Definition at line 644 of file BuildSignatureFlags.py.

644 def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
645 
646  flags.input_name = instanceName
647  flags.name = "muonLRT"
648  flags.suffix = "MuonLRT"
649  flags.roi = "HLT_Roi_Muon"
650  flags.UsePixelSpacePoints = False
651  flags.etaHalfWidth = 0.2
652  flags.phiHalfWidth = 0.4
653  flags.Triplet_D0Max = 300.
654  flags.TrackInitialD0Max = 300.
655  flags.TrackZ0Max = 500.
656  flags.zedHalfWidth = 225.
657  flags.doSeedRedundancyCheck = True
658  flags.nClustersMin = 8
659  flags.isLRT = True
660  flags.doResMon = True
661  flags.DoPhiFiltering = False
662  #pt config
663  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
664  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
665  flags.maxEta = 2.7
666  flags.doEmCaloSeed = False
667 
668  return flags
669 
670 
671 
672 @signatureActions

◆ signatureActions()

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

Definition at line 254 of file BuildSignatureFlags.py.

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

◆ signatureTrigTrackingFlags()

AthConfigFlags python.BuildSignatureFlags.signatureTrigTrackingFlags ( str  mode)

Definition at line 174 of file BuildSignatureFlags.py.

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

◆ tauCore()

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

Definition at line 326 of file BuildSignatureFlags.py.

326 def tauCore(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
327 
328  flags.input_name = instanceName
329  flags.name = "tauCore"
330  flags.suffix = "TauCore"
331  flags.roi = "HLT_Roi_TauCore"
332  flags.pTmin = 0.8*Units.GeV
333  flags.minPT = tsetter(flags.minPT, flags.pTmin)
334 
335  flags.holeSearch_FTF = True
336  return flags
337 
338 @signatureActions

◆ tauIso()

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

Definition at line 339 of file BuildSignatureFlags.py.

339 def tauIso(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
340 
341  flags.input_name = instanceName
342  flags.name = "tauIso"
343  flags.suffix = "TauIso"
344  flags.roi = "HLT_Roi_TauIso"
345  flags.etaHalfWidth = 0.4
346  flags.phiHalfWidth = 0.4
347  flags.zedHalfWidth = 7.0
348  flags.adaptiveVertex = True
349  flags.addSingleTrackVertices = True
350  flags.vertex = "HLT_IDVertex_Tau"
351  flags.electronPID = False
352  flags.pTmin = 0.8*Units.GeV
353  flags.minPT = tsetter(flags.minPT, flags.pTmin)
354  return flags
355 
356 @signatureActions

◆ tauLRT()

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

Definition at line 673 of file BuildSignatureFlags.py.

673 def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
674 
675  flags.input_name = instanceName
676  flags.name = "tauLRT"
677  flags.suffix = "TauLRT"
678  flags.roi = "HLT_Roi_TauLRT"
679  flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
680  flags.pTmin = 0.8*Units.GeV
681  flags.minPT = tsetter(flags.minPT, flags.pTmin)
682  flags.etaHalfWidth = 0.4
683  flags.phiHalfWidth = 0.4
684  flags.zedHalfWidth = 225.
685  flags.UsePixelSpacePoints = False
686  flags.Triplet_D0Max = 300.
687  flags.TrackInitialD0Max = 300.
688  flags.TrackZ0Max = 500.
689  flags.nClustersMin = 8
690  flags.isLRT = True
691  #pt config
692  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
693  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
694  flags.maxEta = 2.7
695  flags.doEmCaloSeed = False
696  if recoMode=="InDet":
697  flags.doTRT = True
698 
699  return flags
700 
701 
702 @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 264 of file BuildSignatureFlags.py.

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

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags

Definition at line 236 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun

Definition at line 238 of file BuildSignatureFlags.py.

◆ log

python.BuildSignatureFlags.log

Definition at line 14 of file BuildSignatureFlags.py.

◆ mode

python.BuildSignatureFlags.mode

Definition at line 239 of file BuildSignatureFlags.py.

◆ sig

python.BuildSignatureFlags.sig

Definition at line 237 of file BuildSignatureFlags.py.

python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:375
python.BuildSignatureFlags.tauIso
AthConfigFlags tauIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:339
vtune_athena.format
format
Definition: vtune_athena.py:14
python.BuildSignatureFlags.muonLRT
AthConfigFlags muonLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:644
python.BuildSignatureFlags.tauLRT
AthConfigFlags tauLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:673
python.BuildSignatureFlags.electron
AthConfigFlags electron(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:283
python.BuildSignatureFlags.addGlobalFlags
def addGlobalFlags(AthConfigFlags flags, str category)
Definition: BuildSignatureFlags.py:868
python.BuildSignatureFlags.muon
AthConfigFlags muon(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:300
run
int run(int argc, char *argv[])
Definition: ttree2hdf5.cxx:28
defaults
Definition: MSVtxValidationAlg.h:43
python.processes.powheg.ZZj_MiNNLO.ZZj_MiNNLO.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZj_MiNNLO.py:18
python.BuildSignatureFlags.defaultITkActsTrigTrackingFlags
AthConfigFlags defaultITkActsTrigTrackingFlags()
Definition: BuildSignatureFlags.py:155
python.BuildSignatureFlags.defaultITkTrigTrackingFlags
AthConfigFlags defaultITkTrigTrackingFlags()
Definition: BuildSignatureFlags.py:129
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
python.TrackingPassFlags.createTrackingPassFlags
def createTrackingPassFlags()
Definition: TrackingPassFlags.py:17
python.BuildSignatureFlags.diTau
AthConfigFlags diTau(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:357
python.BuildSignatureFlags.defaultModeTrigTrackingFlags
AthConfigFlags defaultModeTrigTrackingFlags(AthConfigFlags flags)
Definition: BuildSignatureFlags.py:171
python.BuildSignatureFlags.fullScanLRT
AthConfigFlags fullScanLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:727
python.BuildSignatureFlags.signatureTrigTrackingFlags
AthConfigFlags signatureTrigTrackingFlags(str mode)
Definition: BuildSignatureFlags.py:174
python.BuildSignatureFlags.collToRecordable
def collToRecordable(flags, name)
Definition: BuildSignatureFlags.py:845
python.BuildSignatureFlags.tauCore
AthConfigFlags tauCore(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:326
python.BuildSignatureFlags.defaultInDetTrigTrackingFlags
AthConfigFlags defaultInDetTrigTrackingFlags()
Definition: BuildSignatureFlags.py:95
python.BuildSignatureFlags.bmumux
AthConfigFlags bmumux(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:602
python.BuildSignatureFlags.minBiasPixel
AthConfigFlags minBiasPixel(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:442
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:561
python.BuildSignatureFlags.muonIso
AthConfigFlags muonIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:314
python.BuildSignatureFlags.defaultTrigTrackingFlags
def defaultTrigTrackingFlags(AthConfigFlags flags)
Definition: BuildSignatureFlags.py:16
python.BuildSignatureFlags.minBias
AthConfigFlags minBias(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:416
python.BuildSignatureFlags.beamSpotFS
AthConfigFlags beamSpotFS(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:541
python.BuildSignatureFlags.electronLRT
AthConfigFlags electronLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:618
ActsTrackingPassFlags.createActsTrackingPassFlags
def createActsTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:37
python.BuildSignatureFlags.tsetter
def tsetter(var, value)
Definition: BuildSignatureFlags.py:264
python.TriggerEDM.recordable
def recordable(arg, runVersion=3)
Definition: TriggerEDM.py:37
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:491
python.BuildSignatureFlags.DJetLRT
AthConfigFlags DJetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:756
python.BuildSignatureFlags.DVtxLRT
AthConfigFlags DVtxLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:786
python.BuildSignatureFlags.jetSuper
AthConfigFlags jetSuper(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:390
python.BuildSignatureFlags.signatureActions
def signatureActions(func)
Definition: BuildSignatureFlags.py:254
python.BuildSignatureFlags.derivedFromSignatureFlags
def derivedFromSignatureFlags(AthConfigFlags flags, str recoMode)
Definition: BuildSignatureFlags.py:814
python.BuildSignatureFlags.fullScan
AthConfigFlags fullScan(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:510
python.TrackingPassFlags.createITkTrackingPassFlags
def createITkTrackingPassFlags()
ITk mode ####################.
Definition: TrackingPassFlags.py:120
python.BuildSignatureFlags.bjetLRT
AthConfigFlags bjetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:703
Generated on Tue Oct 21 2025 22:03:26 for ATLAS Offline Software by   doxygen 1.8.18