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

832 def addGlobalFlags(flags: AthConfigFlags, category : str):
833  flags.addFlag(f'{category}.RoiZedWidthDefault', 180.0 * Units.mm)
834  flags.addFlag(f'{category}.doGPU', False)
835  flags.addFlag(f'{category}.UseTrigTrackFollowing', False)
836  flags.addFlag(f'{category}.UseTrigRoadPredictor', False)
837  flags.addFlag(f'{category}.UseTracklets', False)
838  flags.addFlag(f'{category}.trackletPoints', 1)
839  flags.addFlag(f'{category}.PixelClusterCacheKey', "PixelTrigClustersCache")
840  flags.addFlag(f'{category}.SCTClusterCacheKey', "SCT_ClustersCache")
841  flags.addFlag(f'{category}.SpacePointCachePix', "PixelSpacePointCache")
842  flags.addFlag(f'{category}.SpacePointCacheSCT', "SctSpacePointCache")
843  flags.addFlag(f'{category}.SCTBSErrCacheKey', "SctBSErrCache")
844  flags.addFlag(f'{category}.SCTFlaggedCondCacheKey', "SctFlaggedCondCache")
845  flags.addFlag(f'{category}.SCTRDOCacheKey', "SctRDOCache")
846  flags.addFlag(f'{category}.PixRDOCacheKey', "PixRDOCache")
847  flags.addFlag(f'{category}.PixBSErrCacheKey', "PixBSErrCache")
848  flags.addFlag(f'{category}.TRTRDOCacheKey', "TrtRDOCache")
849  flags.addFlag(f'{category}.TRT_DriftCircleCacheKey', "TRT_DriftCircleCache")
850  flags.addFlag(f'{category}.ClusterAmbiguitiesMap', "TrigPixelClusterAmbiguitiesMap")
851 
852 

◆ beamSpot()

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

Definition at line 455 of file BuildSignatureFlags.py.

455 def beamSpot(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
456 
457  flags.input_name = instanceName
458  flags.name = "beamSpot"
459  flags.suffix = "BeamSpot"
460  flags.roi = "HLT_Roi_FS"
461  flags.doFullScan = True
462  flags.doZFinder = True
463  flags.DoubletDR_Max = 200
464  flags.SeedRadBinWidth = 10
465  flags.etaHalfWidth = 3
466  flags.phiHalfWidth = math.pi
467  flags.doTRT = False
468  flags.doSeedRedundancyCheck = True
469  flags.doRecord = False
470  return flags
471 
472 
473 @signatureActions

◆ beamSpotFS()

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

Definition at line 505 of file BuildSignatureFlags.py.

505 def beamSpotFS(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
506 
507  flags.input_name = instanceName
508  flags.name = "fullScan"
509  flags.suffix = "FS"
510  flags.roi = "HLT_Roi_FS"
511  flags.doFullScan = True
512  flags.etaHalfWidth = 3.
513  flags.phiHalfWidth = math.pi
514  flags.doTRT = False
515  flags.DoubletDR_Max = 200
516  flags.SeedRadBinWidth = 10
517  flags.TripletDoPPS = False
518  flags.nClustersMin = 8
519  flags.UseTrigSeedML = 4
520  flags.doRecord = False
521  return flags
522 
523 
524 @signatureActions

◆ bjet()

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

Definition at line 339 of file BuildSignatureFlags.py.

339 def bjet(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
340 
341  flags.input_name = instanceName
342  flags.name = "bjet"
343  flags.suffix = "Bjet"
344  flags.roi = "HLT_Roi_Bjet"
345  flags.etaHalfWidth = 0.4
346  flags.phiHalfWidth = 0.4
347  flags.zedHalfWidth = 10.0
348  flags.pTmin = 0.8*Units.GeV
349  flags.minPT = tsetter(flags.minPT, flags.pTmin)
350  flags.Xi2max = tsetter(flags.Xi2max,12.)
351  return flags
352 
353 @signatureActions

◆ bjetLRT()

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

Definition at line 667 of file BuildSignatureFlags.py.

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

◆ bmumux()

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

Definition at line 566 of file BuildSignatureFlags.py.

566 def bmumux(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
567 
568  flags.input_name = instanceName
569  flags.name = "bphysics"
570  flags.suffix = "Bmumux"
571  flags.roi = "HLT_Roi_Bmumux"
572  flags.Triplet_D0Max = 10.
573  flags.DoPhiFiltering = False
574  flags.etaHalfWidth = 0.75
575  flags.phiHalfWidth = 0.75
576  flags.zedHalfWidth = 50.
577  flags.doSeedRedundancyCheck = True
578  flags.SuperRoI = True
579  return flags
580 
581 @signatureActions

◆ collToRecordable()

def python.BuildSignatureFlags.collToRecordable (   flags,
  name 
)

Definition at line 809 of file BuildSignatureFlags.py.

809 def collToRecordable(flags,name):
810  # ToDo: should just be a flag set per signature in the per signature config
811  # and not setting parameters using tests on the signature name
812  ret = name
813  signature = flags.input_name
814  firstStage = True if "FTF" in name else False
815  record = True
816  if firstStage:
817  if signature in ["minBias","minBiasPixel","bjetLRT",
818  "beamSpot","BeamSpot"]:
819  record = False
820  else:
821  if signature in ["tauCore","tauIso","tauIsoBDT",
822  "jet","fullScan","FS","jetSuper",
823  "beamSpot", "BeamSpot","beamSpotFS",
824  "bjetLRT","DJetLRT","DVtxLRT"]:
825  record = False
826 
827  if record:
828  ret = recordable(name)
829 
830  return ret
831 

◆ cosmics()

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

Definition at line 525 of file BuildSignatureFlags.py.

525 def cosmics(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
526 
527  flags.input_name = instanceName
528  flags.name = "cosmics"
529  flags.suffix = "Cosmic"
530  flags.roi = "HLT_Roi_Cosmics"
531  flags.Triplet_D0Max = 1000.0
532  flags.Triplet_D0_PPS_Max = 1000.0
533  flags.TrackInitialD0Max = 1000.
534  flags.TrackZ0Max = 1000.
535  flags.doTRT = False
536  flags.doFullScan = True
537  flags.etaHalfWidth = 3
538  flags.phiHalfWidth = math.pi
539 
540  flags.minPT = tsetter(flags.minPT, 0.5*Units.GeV)
541 
542  flags.nClustersMin = 4
543  flags.minSiNotShared = 3
544  flags.maxShared = 0
545  flags.nHolesMax = 3
546  flags.maxSiHoles = 3
547  flags.maxSCTHoles = 3
548  flags.maxPixelHoles = tsetter(flags.maxPixelHoles,3)
549  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 1000.*Units.mm)
550 
551  flags.Xi2max = tsetter(flags.Xi2max, 60.)
552  flags.Xi2maxNoAdd = tsetter(flags.Xi2maxNoAdd, 100.)
553  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles,1)
554 
555  flags.nWeightedClustersMin= 8
556  flags.useSeedFilter = True
557  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
558  flags.roadWidth = 75.
559  flags.maxZImpact= tsetter(flags.maxZImpact, 10000.*Units.mm)
560  if recoMode=="InDet":
561  flags.minTRTonTrk = 20
562 
563  return flags
564 
565 @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 778 of file BuildSignatureFlags.py.

778 def derivedFromSignatureFlags(flags: AthConfigFlags, recoMode : str):
779 
780  flags.trkTracks_FTF = f'HLT_IDTrkTrack_{flags.suffix}_FTF'
781  flags.trkTracks_IDTrig = f'HLT_IDTrkTrack_{flags.suffix}_IDTrig'
782  flags.tracks_FTF = collToRecordable(flags, f'HLT_IDTrack_{flags.suffix}_FTF')
783  # ToDo: shouldn't be setting flags using this if type structures, the flags should be
784  # actually set somewhere in appropriate config functions
785  flags.tracks_IDTrig = collToRecordable(flags,"HLT_IDTrack_{}_IDTrig".format(flags.suffix if flags.input_name != "tauIso" else "Tau"))
786 
787  if recoMode == "Acts":
788  flags.trkTracks_FTF = f'HLT_Acts_{flags.suffix}_Tracks'
789  flags.trkTracks_IDTrig = f'HLT_Acts_{flags.suffix}_Ambi_Tracks'
790 
791  if flags.isLRT: # to be moved to a separate function once LRTs differ
792  flags.minClusters = tsetter(flags.minClusters , 8)
793  flags.nHolesGapMax = tsetter(flags.nHolesGapMax , 1)
794  flags.nWeightedClustersMin= tsetter(flags.nWeightedClustersMin, 8)
795  flags.maxSiHoles = tsetter(flags.maxSiHoles , 2)
796  flags.maxSCTHoles = tsetter(flags.maxSCTHoles , 1)
797  flags.maxPixelHoles = tsetter(flags.maxPixelHoles , 1)
798  flags.maxDoubleHoles = tsetter(flags.maxDoubleHoles , 0)
799  flags.maxZImpact = tsetter(flags.maxZImpact , 500.)
800 
801 
802  if recoMode == "ITk":
803  flags.extension = flags.input_name #needed in the ITk mode?
804 
805  if flags.isLRT:
806  flags.UsePixelSpacePoints = True #In LRT cases they use only SCT SP, but for ITk we want pixel SP
807 
808 

◆ DJetLRT()

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

Definition at line 720 of file BuildSignatureFlags.py.

720 def DJetLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
721 
722  flags.input_name = instanceName
723  flags.name = "DJetLRT"
724  flags.suffix = "DJLRT"
725  flags.roi = "HLT_Roi_DJ"
726  flags.doFullScan = False
727  flags.etaHalfWidth = 0.4
728  flags.phiHalfWidth = 0.4
729  flags.zedHalfWidth = 225.
730  flags.doTRT = False
731  flags.doSeedRedundancyCheck = True
732  flags.UsePixelSpacePoints = False
733  flags.Triplet_D0Max = 300.
734  flags.TrackInitialD0Max = 300.
735  flags.TrackZ0Max = 500.
736  flags.Triplet_D0_PPS_Max = 300.
737  flags.DoubletDR_Max = 200
738  flags.nClustersMin = 8
739  flags.isLRT = True
740  #pt config
741  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
742  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
743  flags.maxEta = 2.7
744  flags.doEmCaloSeed = False
745 
746  return flags
747 
748 
749 @signatureActions

◆ DVtxLRT()

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

Definition at line 750 of file BuildSignatureFlags.py.

750 def DVtxLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
751 
752  flags.input_name = instanceName
753  flags.name = "DVtxLRT"
754  flags.suffix = "DVLRT"
755  flags.roi = "HLT_Roi_DV"
756  flags.doFullScan = False
757  flags.etaHalfWidth = 0.35
758  flags.phiHalfWidth = 0.35
759  flags.doTRT = False
760  flags.doSeedRedundancyCheck = True
761  flags.UsePixelSpacePoints = False
762  flags.Triplet_D0Max = 300.
763  flags.TrackInitialD0Max = 300.
764  flags.TrackZ0Max = 500.
765  flags.Triplet_D0_PPS_Max = 300.
766  flags.DoubletDR_Max = 200
767  flags.nClustersMin = 8
768  flags.isLRT = True
769  #pt config
770  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
771  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
772  flags.maxEta = 2.7
773  flags.doEmCaloSeed = False
774 
775  return flags
776 
777 

◆ electron()

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

Definition at line 265 of file BuildSignatureFlags.py.

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

◆ electronLRT()

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

Definition at line 582 of file BuildSignatureFlags.py.

582 def electronLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
583 
584  flags.input_name = instanceName
585  flags.name = "electronLRT"
586  flags.suffix = "ElecLRT"
587  flags.roi = "HLT_Roi_Electron"
588  flags.etaHalfWidth = 0.1
589  flags.phiHalfWidth = 0.4
590  flags.UsePixelSpacePoints = False
591  flags.Triplet_D0Max = 300.
592  flags.TrackInitialD0Max = 300.
593  flags.TrackZ0Max = 500.
594  flags.zedHalfWidth = 225.
595  flags.keepTrackParameters = True
596  flags.doSeedRedundancyCheck = True
597  flags.nClustersMin = 8
598  flags.isLRT = True
599  #pt config
600  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
601  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
602  flags.maxEta = 2.7
603  flags.doEmCaloSeed = False
604  return flags
605 
606 
607 @signatureActions

◆ fullScan()

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

Definition at line 474 of file BuildSignatureFlags.py.

474 def fullScan(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
475 
476  flags.input_name = instanceName
477  flags.name = "fullScan"
478  flags.suffix = "FS"
479  flags.roi = "HLT_Roi_FS"
480  flags.vertex = "HLT_IDVertex_FS"
481  flags.adaptiveVertex = True
482  # these are being evaluated and may be added
483  # flags.addSingleTrackVertices = True
484  # flags.TracksMaxZinterval = 3
485  flags.vertex_jet = "HLT_IDVertex_FS"
486  flags.adaptiveVertex_jet = True
487  flags.doFullScan = True
488  flags.etaHalfWidth = 3.
489  flags.phiHalfWidth = math.pi
490  flags.doTRT = False
491  flags.DoubletDR_Max = 200
492  flags.SeedRadBinWidth = 10
493  flags.doSeedRedundancyCheck = True
494  flags.TripletDoPPS = False
495  flags.nClustersMin = 8
496  flags.UseTrigSeedML = 4
497  flags.dodEdxTrk = True
498  flags.doHitDV = True
499  flags.doDisappearingTrk = True if recoMode=="InDet" else False
500  flags.roadWidth = 5.
501  return flags
502 
503 
504 @signatureActions

◆ fullScanLRT()

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

Definition at line 691 of file BuildSignatureFlags.py.

691 def fullScanLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
692 
693  flags.input_name = instanceName
694  flags.name = "fullScanLRT"
695  flags.suffix = "FSLRT"
696  flags.roi = "HLT_Roi_FS"
697  flags.doFullScan = True
698  flags.etaHalfWidth = 3.
699  flags.phiHalfWidth = math.pi
700  flags.doTRT = False
701  flags.doSeedRedundancyCheck = True
702  flags.UsePixelSpacePoints = False
703  flags.Triplet_D0Max = 300.
704  flags.TrackInitialD0Max = 300.
705  flags.TrackZ0Max = 500.
706  flags.Triplet_D0_PPS_Max = 300.
707  flags.DoubletDR_Max = 200
708  flags.nClustersMin = 8
709  flags.isLRT = True
710  #pt config
711  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
712  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
713  flags.maxEta = 2.7
714  flags.doEmCaloSeed = False
715 
716  return flags
717 
718 
719 @signatureActions

◆ jetSuper()

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

Definition at line 354 of file BuildSignatureFlags.py.

354 def jetSuper(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
355 
356  flags.input_name = instanceName
357  flags.name = "jetSuper"
358  flags.suffix = "JetSuper"
359  flags.vertex = "HLT_IDVertex_JetSuper"
360  flags.adaptiveVertex = True
361  flags.addSingleTrackVertices = True
362  flags.roi = "HLT_Roi_JetSuper"
363  flags.etaHalfWidth = 0.3
364  flags.phiHalfWidth = 0.3
365  flags.doFullScan = True
366  flags.pTmin = 1*Units.GeV
367  flags.minPT = tsetter(flags.minPT, flags.pTmin)
368  #-----
369  flags.doTRT = False
370  flags.DoubletDR_Max = 200
371  flags.SeedRadBinWidth = 10
372  flags.doSeedRedundancyCheck = True
373  flags.TripletDoPPS = False
374  flags.nClustersMin = 8
375  flags.UseTrigSeedML = 4
376  flags.roadWidth = 5.
377  return flags
378 
379 @signatureActions

◆ minBias()

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

Definition at line 380 of file BuildSignatureFlags.py.

380 def minBias(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
381 
382  flags.input_name = instanceName
383  flags.name = "minBias"
384  flags.suffix = "MinBias"
385  flags.roi = "HLT_Roi_MinBias"
386  flags.doFullScan = True
387  flags.pTmin = 0.1*Units.GeV # TODO: double check
388  flags.minPT = tsetter(flags.minPT, flags.pTmin)
389 
390  flags.doTRT = False
391  flags.etaHalfWidth = 3
392  flags.phiHalfWidth = math.pi
393  flags.doZFinder = True
394  flags.doZFinderOnly = True
395 
396  flags.nClustersMin = 5
397  flags.useSeedFilter = True
398  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 10.*Units.mm)
399  flags.maxZImpact = tsetter(flags.maxZImpact, 150.*Units.mm)
400  flags.roadWidth = 20
401  flags.usePrdAssociationTool = False #for backward compatibility #2023fix?
402  return flags
403 
404 
405 @signatureActions

◆ minBiasPixel()

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

Definition at line 406 of file BuildSignatureFlags.py.

406 def minBiasPixel(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
407 
408  flags.input_name = instanceName
409  flags.name = "minBiasPixel"
410  flags.suffix = "MinBiasPixel"
411  flags.roi = "HLT_Roi_MinBias"
412  flags.doFullScan = True
413  flags.pTmin = 0.1*Units.GeV # this is good for HI which is the client of this setup
414  flags.minPT = tsetter(flags.minPT, flags.pTmin)
415 
416 
417  flags.maxHoles = 0 # HI setup
418  flags.maxPixelHoles = 0 # HI setup
419  flags.maxSctHoles = 0
420  flags.maxDoubleHoles = 0
421  flags.minSiNotShared = 3
422  flags.maxShared = 0
423  flags.nHolesMax = 0
424  flags.nHolesGapMax = 0
425  if recoMode=="InDet":
426  flags.useSCT = False
427  flags.useSCTSeeding = False
428  flags.useTRT = False
429 
430  flags.roadWidth = 12.0
431  flags.Xi2max = 15
432  flags.Xi2maxNoAdd = 35.0
433  flags.nWeightedClustersMin = 6
434  flags.doBremRecoverySi = False
435  flags.RunPixelPID = False # we use these tracks only for counting
436 
437  flags.doTRT = False
438  flags.etaHalfWidth = 3
439  flags.phiHalfWidth = math.pi
440  flags.doZFinder = False
441  flags.doZFinderOnly = True
442 
443  flags.minClusters = 3
444  flags.nClustersMin = 3
445  flags.useSeedFilter = True
446  flags.maxPrimaryImpact = 10.*Units.mm
447  flags.maxZImpact = 150.*Units.mm
448  flags.roadWidth = 20
449  flags.usePrdAssociationTool = False
450  return flags
451 
452 
453 
454 @signatureActions

◆ muon()

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

Definition at line 282 of file BuildSignatureFlags.py.

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

◆ muonIso()

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

Definition at line 296 of file BuildSignatureFlags.py.

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

◆ muonLRT()

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

Definition at line 608 of file BuildSignatureFlags.py.

608 def muonLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
609 
610  flags.input_name = instanceName
611  flags.name = "muonLRT"
612  flags.suffix = "MuonLRT"
613  flags.roi = "HLT_Roi_Muon"
614  flags.UsePixelSpacePoints = False
615  flags.etaHalfWidth = 0.2
616  flags.phiHalfWidth = 0.4
617  flags.Triplet_D0Max = 300.
618  flags.TrackInitialD0Max = 300.
619  flags.TrackZ0Max = 500.
620  flags.zedHalfWidth = 225.
621  flags.doSeedRedundancyCheck = True
622  flags.nClustersMin = 8
623  flags.isLRT = True
624  flags.doResMon = True
625  flags.DoPhiFiltering = False
626  #pt config
627  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
628  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
629  flags.maxEta = 2.7
630  flags.doEmCaloSeed = False
631 
632  return flags
633 
634 
635 
636 @signatureActions

◆ signatureActions()

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

Definition at line 236 of file BuildSignatureFlags.py.

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

◆ 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  "bjet" : bjet,
175 
176  "fullScan" : fullScan,
177  "FS" : fullScan,
178  "jetSuper" : jetSuper,
179 
180  "beamSpot" : beamSpot,
181  "BeamSpot" : beamSpot,
182  "beamSpotFS" : beamSpotFS,
183 
184  "cosmics" : cosmics,
185  "bmumux" : bmumux,
186 
187  "minBias" : minBias,
188  "minBiasPixel" : minBiasPixel,
189 
190  "electronLRT" : electronLRT,
191  "muonLRT" : muonLRT,
192  "tauLRT" : tauLRT,
193  "bjetLRT" : bjetLRT,
194  "fullScanLRT" : fullScanLRT,
195  "DJetLRT" : DJetLRT,
196  "DVtxLRT" : DVtxLRT,
197  }
198 
199  flags = AthConfigFlags()
200 
201  if mode == "InDet":
202  category = 'Trigger.InDetTracking'
203  defaults = defaultInDetTrigTrackingFlags
204  elif mode == "ITk":
205  category = 'Trigger.ITkTracking'
206  defaults = defaultITkTrigTrackingFlags
207  elif mode == "Acts":
208  category = "Trigger.ActsTracking"
209  defaults = defaultITkTrigTrackingFlags
210  else:
211  log.error("Acts not supported yet")
212 
213 
214  class categoryGeneratorWrapper():
215  """ wrap function which can be consumed by addFlagsCategory and provide its args """
216  def __init__(self, fun : Callable[[AthConfigFlags, str, str], AthConfigFlags],
217  flags : AthConfigFlags, signatureInstance : str, recoMode : str):
218  self.flags = flags
219  self.sig = signatureInstance
220  self.fun = fun
221  self.mode= recoMode
222  def run(self):
223  return self.fun(self.flags,self.sig,self.mode)
224 
225  for i in signatureSet.keys():
226  trackingflags = deepcopy(defaults())
227  a = categoryGeneratorWrapper(signatureSet[i],trackingflags,i,mode)
228  signatureCategory = "{}.{}".format(category,i)
229  flags.addFlagsCategory(signatureCategory,a.run,prefix=True)
230 
231  addGlobalFlags(flags, category) # they should not be needed / backward compatibility
232 
233  return flags
234 
235 

◆ tauCore()

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

Definition at line 308 of file BuildSignatureFlags.py.

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

◆ tauIso()

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

Definition at line 321 of file BuildSignatureFlags.py.

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

◆ tauLRT()

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

Definition at line 637 of file BuildSignatureFlags.py.

637 def tauLRT(flags: AthConfigFlags, instanceName: str, recoMode: str) -> AthConfigFlags:
638 
639  flags.input_name = instanceName
640  flags.name = "tauLRT"
641  flags.suffix = "TauLRT"
642  flags.roi = "HLT_Roi_TauLRT"
643  flags.vertex = "HLT_IDVertex_Tau" # TODO: does this need renaming?
644  flags.pTmin = 0.8*Units.GeV
645  flags.minPT = tsetter(flags.minPT, flags.pTmin)
646  flags.etaHalfWidth = 0.4
647  flags.phiHalfWidth = 0.4
648  flags.zedHalfWidth = 225.
649  flags.UsePixelSpacePoints = False
650  flags.Triplet_D0Max = 300.
651  flags.TrackInitialD0Max = 300.
652  flags.TrackZ0Max = 500.
653  flags.nClustersMin = 8
654  flags.isLRT = True
655  #pt config
656  flags.maxPrimaryImpact = tsetter(flags.maxPrimaryImpact, 300.*Units.mm)
657  flags.maxEMImpact = tsetter(flags.maxEMImpact, 300.*Units.mm)
658  flags.maxEta = 2.7
659  flags.doEmCaloSeed = False
660  if recoMode=="InDet":
661  flags.doTRT = True
662 
663  return flags
664 
665 
666 @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 246 of file BuildSignatureFlags.py.

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

Variable Documentation

◆ flags

python.BuildSignatureFlags.flags

Definition at line 218 of file BuildSignatureFlags.py.

◆ fun

python.BuildSignatureFlags.fun

Definition at line 220 of file BuildSignatureFlags.py.

◆ log

python.BuildSignatureFlags.log

Definition at line 13 of file BuildSignatureFlags.py.

◆ mode

python.BuildSignatureFlags.mode

Definition at line 221 of file BuildSignatureFlags.py.

◆ sig

python.BuildSignatureFlags.sig

Definition at line 219 of file BuildSignatureFlags.py.

python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:339
python.BuildSignatureFlags.tauIso
AthConfigFlags tauIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:321
vtune_athena.format
format
Definition: vtune_athena.py:14
python.BuildSignatureFlags.muonLRT
AthConfigFlags muonLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:608
python.BuildSignatureFlags.tauLRT
AthConfigFlags tauLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:637
python.BuildSignatureFlags.electron
AthConfigFlags electron(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:265
python.BuildSignatureFlags.addGlobalFlags
def addGlobalFlags(AthConfigFlags flags, str category)
Definition: BuildSignatureFlags.py:832
python.BuildSignatureFlags.muon
AthConfigFlags muon(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:282
run
int run(int argc, char *argv[])
Definition: ttree2hdf5.cxx:28
python.BuildSignatureFlags.defaultITkTrigTrackingFlags
AthConfigFlags defaultITkTrigTrackingFlags()
Definition: BuildSignatureFlags.py:128
python.TrackingPassFlags.createTrackingPassFlags
def createTrackingPassFlags()
Definition: TrackingPassFlags.py:18
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:691
python.BuildSignatureFlags.signatureTrigTrackingFlags
AthConfigFlags signatureTrigTrackingFlags(str mode)
Definition: BuildSignatureFlags.py:158
python.BuildSignatureFlags.collToRecordable
def collToRecordable(flags, name)
Definition: BuildSignatureFlags.py:809
python.BuildSignatureFlags.tauCore
AthConfigFlags tauCore(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:308
python.BuildSignatureFlags.defaultInDetTrigTrackingFlags
AthConfigFlags defaultInDetTrigTrackingFlags()
Definition: BuildSignatureFlags.py:94
python.BuildSignatureFlags.bmumux
AthConfigFlags bmumux(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:566
python.BuildSignatureFlags.minBiasPixel
AthConfigFlags minBiasPixel(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:406
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:525
python.BuildSignatureFlags.muonIso
AthConfigFlags muonIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:296
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:380
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:505
python.BuildSignatureFlags.electronLRT
AthConfigFlags electronLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:582
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
python.BuildSignatureFlags.tsetter
def tsetter(var, value)
Definition: BuildSignatureFlags.py:246
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:455
python.BuildSignatureFlags.DJetLRT
AthConfigFlags DJetLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:720
python.BuildSignatureFlags.DVtxLRT
AthConfigFlags DVtxLRT(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:750
python.BuildSignatureFlags.jetSuper
AthConfigFlags jetSuper(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:354
python.BuildSignatureFlags.signatureActions
def signatureActions(func)
Definition: BuildSignatureFlags.py:236
python.BuildSignatureFlags.derivedFromSignatureFlags
def derivedFromSignatureFlags(AthConfigFlags flags, str recoMode)
Definition: BuildSignatureFlags.py:778
python.BuildSignatureFlags.fullScan
AthConfigFlags fullScan(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:474
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:667
Generated on Sat Jan 25 2025 22:02:14 for ATLAS Offline Software by   doxygen 1.8.18