ATLAS Offline Software
Functions
FPGATrackSimAlgorithmConfig Namespace Reference

Functions

def intList (string)
 
def floatList (floatStr)
 
def applyTag (obj, tag)
 
def addHoughTool (map_tag, algo_tag, doHitTracing)
 
def addHough_d0phi0_Tool (map_tag, algo_tag, doHitTracing)
 
def addHough1DShiftTool (map_tag, algo_tag)
 
def addLRTDoubletFPGATrackSimool (algo_tag)
 
def FPGATrackSimDataPrepMonitoringCfg (flags)
 original monitor histograms More...
 
def FPGATrackSimTrackMonCfg (name, flags, variety='road')
 new monitoring tool More...
 
def FPGATrackSimOverlapRemovalToolMonitoringCfg (flags)
 
def FPGATrackSimSecondStageAlgMonitoringCfg (flags)
 

Function Documentation

◆ addHough1DShiftTool()

def FPGATrackSimAlgorithmConfig.addHough1DShiftTool (   map_tag,
  algo_tag 
)

Definition at line 190 of file FPGATrackSimAlgorithmConfig.py.

190 def addHough1DShiftTool(map_tag, algo_tag):
191 
192  union = FPGATrackSimRoadUnionTool()
193 
194  tools = []
195  nSlice = FPGATrackSimMaps.getNSubregions(map_tag) if algo_tag['slicing'] else 1
196 
197  splitpt=algo_tag['splitpt']
198  for ptstep in range(splitpt):
199  qpt_min = algo_tag['qpt_min']
200  qpt_max = algo_tag['qpt_max']
201  lowpt = qpt_min + (qpt_max-qpt_min)/splitpt*ptstep
202  highpt = qpt_min + (qpt_max-qpt_min)/splitpt*(ptstep+1)
203 
204  for iSlice in range(nSlice):
205  tool = FPGATrackSimHough1DShiftTool("Hough1DShift_" + str(iSlice)+(("_pt{}".format(ptstep)) if splitpt>1 else ""))
206  tool.subRegion = iSlice if nSlice > 1 else -1
207  if algo_tag['radiiFile'] is not None:
208  tool.radiiFile = algo_tag['radiiFile']
209  tool.phi_min = algo_tag['phi_min']
210  tool.phi_max = algo_tag['phi_max']
211  tool.qpT_min = lowpt
212  tool.qpT_max = highpt
213  tool.nBins = algo_tag['xBins']
214  tool.useDiff = True
215  tool.variableExtend = True
216  tool.phiRangeCut = algo_tag['phiRangeCut']
217  tool.d0spread=-1.0 # mm
218  tool.iterStep = 0
219  tool.iterLayer = 7
220  tool.threshold = algo_tag['threshold'][0]
221 
222  try:
223  tool.hitExtend = algo_tag['hitExtend_x']
224  except Exception:
225  tool.hitExtend = floatList(algo_tag['hitExtend_x'])
226 
227  tools.append(tool)
228 
229  union.tools = tools # NB don't manipulate union.tools directly; for some reason the attributes get unset. Only set like is done here
230 
231  from AthenaCommon.AppMgr import ToolSvc
232  ToolSvc += union
233  return union
234 

◆ addHough_d0phi0_Tool()

def FPGATrackSimAlgorithmConfig.addHough_d0phi0_Tool (   map_tag,
  algo_tag,
  doHitTracing 
) 
Creates and adds the Hough transform tools to the tool svc

Definition at line 125 of file FPGATrackSimAlgorithmConfig.py.

125 def addHough_d0phi0_Tool(map_tag, algo_tag, doHitTracing):
126  '''
127  Creates and adds the Hough transform tools to the tool svc
128  '''
129 
130  union = FPGATrackSimRoadUnionTool("LRTRoadUnionTool")
131 
132  if algo_tag['lrt_straighttrack_xVar'] == 'phi':
133  x_min = algo_tag['lrt_straighttrack_phi_min']
134  x_max = algo_tag['lrt_straighttrack_phi_max']
135  else:
136  raise NotImplementedError("x != phi")
137 
138  x_buffer = (x_max - x_min) / algo_tag['lrt_straighttrack_xBins'] * algo_tag['lrt_straighttrack_xBufferBins']
139  x_min -= x_buffer
140  x_max += x_buffer
141 
142  if algo_tag['lrt_straighttrack_yVar'] == 'd0':
143  y_min = algo_tag['lrt_straighttrack_d0_min']
144  y_max = algo_tag['lrt_straighttrack_d0_max']
145  else:
146  raise NotImplementedError("y != d0")
147 
148  y_buffer = (y_max - y_min) / algo_tag['lrt_straighttrack_yBins'] * algo_tag['lrt_straighttrack_yBufferBins']
149  y_min -= y_buffer
150  y_max += y_buffer
151 
152  tools = []
153  nSlice = FPGATrackSimMaps.getNSubregions(map_tag) if algo_tag['lrt_straighttrack_slicing'] else 1
154 
155  for iSlice in range(nSlice):
156  t = FPGATrackSimHoughTransform_d0phi0_Tool("HoughTransform_d0phi0_" + str(iSlice))
157 
158  t.subRegion = iSlice if nSlice > 1 else -1
159  t.phi_min = x_min
160  t.phi_max = x_max
161  t.d0_min = y_min
162  t.d0_max = y_max
163  t.nBins_x = algo_tag['lrt_straighttrack_xBins'] + 2 * algo_tag['lrt_straighttrack_xBufferBins']
164  t.nBins_y = algo_tag['lrt_straighttrack_yBins'] + 2 * algo_tag['lrt_straighttrack_yBufferBins']
165  t.threshold = algo_tag['lrt_straighttrack_threshold']
166  t.convolution = algo_tag['lrt_straighttrack_convolution']
167  t.combine_layers = algo_tag['lrt_straighttrack_combine_layers']
168  t.scale = algo_tag['lrt_straighttrack_scale']
169  t.convSize_x = algo_tag['lrt_straighttrack_convSize_x']
170  t.convSize_y = algo_tag['lrt_straighttrack_convSize_y']
171  t.traceHits = doHitTracing
172  t.stereo = algo_tag['lrt_straighttrack_stereo']
173  t.localMaxWindowSize = algo_tag['lrt_straighttrack_localMaxWindowSize']
174 
175  try:
176  t.hitExtend_x = algo_tag['lrt_straighttrack_hitExtend_x']
177  except Exception:
178  t.hitExtend_x = intList(algo_tag['lrt_straighttrack_hitExtend_x'])
179 
180 
181  tools.append(t)
182 
183  union.tools = tools # NB don't manipulate union.tools directly; for some reason the attributes get unset. Only set like is done here
184 
185  from AthenaCommon.AppMgr import ToolSvc
186  ToolSvc += union
187 
188  return union
189 

◆ addHoughTool()

def FPGATrackSimAlgorithmConfig.addHoughTool (   map_tag,
  algo_tag,
  doHitTracing 
) 
Creates and adds the Hough transform tools to the tool svc

Definition at line 51 of file FPGATrackSimAlgorithmConfig.py.

51 def addHoughTool(map_tag, algo_tag, doHitTracing):
52  '''
53  Creates and adds the Hough transform tools to the tool svc
54  '''
55 
56  union = FPGATrackSimRoadUnionTool()
57 
58  if algo_tag['xVar'] == 'phi':
59  x_min = algo_tag['phi_min']
60  x_max = algo_tag['phi_max']
61  else:
62  raise NotImplementedError("x != phi")
63 
64  x_buffer = (x_max - x_min) / algo_tag['xBins'] * algo_tag['xBufferBins']
65  x_min -= x_buffer
66  x_max += x_buffer
67 
68  if algo_tag['yVar'] == 'q/pt':
69  y_min = algo_tag['qpt_min']
70  y_max = algo_tag['qpt_max']
71  else:
72  raise NotImplementedError("y != q/pt")
73 
74  y_buffer = (y_max - y_min) / algo_tag['yBins'] * algo_tag['yBufferBins']
75  y_min -= y_buffer
76  y_max += y_buffer
77 
78  tools = []
79  nSlice = FPGATrackSimMaps.getNSubregions(map_tag) if algo_tag['slicing'] else 1
80 
81  d0_list = algo_tag['d0_slices'] or [0]
82 
83  for d0 in d0_list:
84  for iSlice in range(nSlice):
85  t = FPGATrackSimHoughTransformTool("HoughTransform_" + str(d0) + '_' + str(iSlice))
86 
87  t.subRegion = iSlice if nSlice > 1 else -1
88  t.phi_min = x_min
89  t.phi_max = x_max
90  t.qpT_min = y_min
91  t.qpT_max = y_max
92  t.d0_min = d0
93  t.d0_max = d0
94  t.nBins_x = algo_tag['xBins'] + 2 * algo_tag['xBufferBins']
95  t.nBins_y = algo_tag['yBins'] + 2 * algo_tag['yBufferBins']
96  t.threshold = algo_tag['threshold']
97  t.convolution = algo_tag['convolution']
98  t.combine_layers = algo_tag['combine_layers']
99  t.scale = algo_tag['scale']
100  t.convSize_x = algo_tag['convSize_x']
101  t.convSize_y = algo_tag['convSize_y']
102  t.traceHits = doHitTracing
103  t.localMaxWindowSize = algo_tag['localMaxWindowSize']
104  t.fieldCorrection = algo_tag['fieldCorrection']
105  if algo_tag['DoDeltaGPhis']:
106  t.IdealGeoRoads = True
107  try:
108  t.hitExtend_x = algo_tag['hitExtend_x']
109  except Exception:
110  t.hitExtend_x = intList(algo_tag['hitExtend_x'])
111 
112  tools.append(t)
113 
114  union.tools = tools # NB don't manipulate union.tools directly; for some reason the attributes get unset. Only set like is done here
115 
116 
117  from AthenaCommon.AppMgr import ToolSvc
118  ToolSvc += union
119 
120  return union
121 
122 # This is only for LRT, so draw on the LRT variables.
123 # That way we don't interfere with the standard Hough for first pass tracking,
124 # if using it.

◆ addLRTDoubletFPGATrackSimool()

def FPGATrackSimAlgorithmConfig.addLRTDoubletFPGATrackSimool (   algo_tag)

Definition at line 235 of file FPGATrackSimAlgorithmConfig.py.

235 def addLRTDoubletFPGATrackSimool(algo_tag):
236  tool = FPGATrackSimLLPDoubletHoughTransformTool()
237  tool.nBins_x = algo_tag['lrt_doublet_d0_bins']
238  tool.d0_range = algo_tag['lrt_doublet_d0_range']
239  tool.nBins_y = algo_tag['lrt_doublet_qpt_bins']
240  tool.qpT_range = algo_tag['lrt_doublet_qpt_range']
241  from AthenaCommon.AppMgr import ToolSvc
242  ToolSvc += tool
243  return tool
244 
245 

◆ applyTag()

def FPGATrackSimAlgorithmConfig.applyTag (   obj,
  tag 
) 
Applies the parameters in the supplied tag to the given FPGATrackSimAlgorithm object.

Definition at line 23 of file FPGATrackSimAlgorithmConfig.py.

23 def applyTag(obj, tag):
24  '''
25  Applies the parameters in the supplied tag to the given FPGATrackSimAlgorithm object.
26  '''
27 
28  params = { # List of configurable parameters for the given object type
29  'FPGATrackSimPatternMatchTool': [
30  'max_misses',
31  ],
32  'FPGATrackSimSectorMatchTool': [
33  'max_misses',
34  ],
35  'FPGATrackSimTrackFitterTool': [
36  'chi2DofRecoveryMin',
37  'chi2DofRecoveryMax',
38  'doMajority',
39  'nHits_noRecovery',
40  'GuessHits',
41  'DoMissingHitsChecks',
42  'IdealCoordFitType',
43  'DoDeltaGPhis'
44  ],
45  }
46 
47  for param in params[obj.getType()]:
48  setattr(obj, param, tag[param])
49 
50 

◆ floatList()

def FPGATrackSimAlgorithmConfig.floatList (   floatStr) 
Converts a list of floats in string form to an actual list. This is needed since
trfArgClasses doesn't have a argFloatList class

Definition at line 16 of file FPGATrackSimAlgorithmConfig.py.

16 def floatList(floatStr):
17  '''
18  Converts a list of floats in string form to an actual list. This is needed since
19  trfArgClasses doesn't have a argFloatList class
20  '''
21  return [ float(v) for v in floatStr.split(',') if v != '' ]
22 

◆ FPGATrackSimDataPrepMonitoringCfg()

def FPGATrackSimAlgorithmConfig.FPGATrackSimDataPrepMonitoringCfg (   flags)

original monitor histograms

Definition at line 247 of file FPGATrackSimAlgorithmConfig.py.

247 def FPGATrackSimDataPrepMonitoringCfg(flags):
248  from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
249  result = ComponentAccumulator()
250  from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
251  monTool = GenericMonitoringTool(flags, 'MonTool')
252  nbin=1000
253  low=-0.5
254  high=99999.5
255  if flags.Trigger.FPGATrackSim.singleTrackSample:
256  nbin=100
257  high=99.5
258 
259  monTool.defineHistogram('regionID', path='EXPERT', type='TH1I', title='regionID', xbins=nbin, xmin=low, xmax=high)
260  monTool.defineHistogram('nHits_1st', path='EXPERT', type='TH1I', title='nHits_1st', xbins=nbin, xmin=low, xmax=high)
261  monTool.defineHistogram('nHits_1st_unmapped', path='EXPERT', type='TH1I', title='nHits_1st_unmapped', xbins=nbin, xmin=low, xmax=high)
262  result.setPrivateTools(monTool)
263 
264  return result
265 
266 

◆ FPGATrackSimOverlapRemovalToolMonitoringCfg()

def FPGATrackSimAlgorithmConfig.FPGATrackSimOverlapRemovalToolMonitoringCfg (   flags)

Definition at line 332 of file FPGATrackSimAlgorithmConfig.py.

332 def FPGATrackSimOverlapRemovalToolMonitoringCfg(flags):
333  from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
334  result = ComponentAccumulator()
335  from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
336  monTool = GenericMonitoringTool(flags, 'MonTool')
337 
338  monTool.defineHistogram('ntrack_passOR', path='EXPERT', type='TH1I', title='ntrack_passOR', xbins=20, xmin=0, xmax=10)
339  monTool.defineHistogram('barcodeFrac_passOR', path='EXPERT', type='TH1I', title='barcodeFrac_passOR', xbins=20, xmin=0, xmax=1.5)
340 
341  result.setPrivateTools(monTool)
342 
343  return result
344 

◆ FPGATrackSimSecondStageAlgMonitoringCfg()

def FPGATrackSimAlgorithmConfig.FPGATrackSimSecondStageAlgMonitoringCfg (   flags)

Definition at line 345 of file FPGATrackSimAlgorithmConfig.py.

345 def FPGATrackSimSecondStageAlgMonitoringCfg(flags):
346  from FPGATrackSimConfTools.FPGATrackSimDataPrepConfig import getPhiRange,getEtaRange
347  from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
348  result = ComponentAccumulator()
349  from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
350  monTool = GenericMonitoringTool(flags, 'MonTool')
351  nbin=100
352  low=-0.5
353  high=99.5
354 
355  from FPGATrackSimConfTools.FPGATrackSimHelperFunctions import convertRegionsExpressionToArray
356  flagsLS = flags.clone()
357  phiranges=[]
358  etaranges=[]
359  for region in convertRegionsExpressionToArray(flags.Trigger.FPGATrackSim.regionList):
360  flagsLS.Trigger.FPGATrackSim.region = region
361  phiranges.append(getPhiRange(flags))
362  etaranges.append(getEtaRange(flags))
363  phimin = min([v[0] for v in phiranges])
364  phimax = max([v[1] for v in phiranges])
365  etamin = min([v[0] for v in etaranges])
366  etamax = max([v[1] for v in etaranges])
367 
368  phimin = phimin-flags.Trigger.FPGATrackSim.phiShift
369  phimax = phimax-flags.Trigger.FPGATrackSim.phiShift
370 
371  monTool.defineHistogram('nHits_2nd', path='EXPERT', type='TH1I', title='nHits_2nd', xbins=nbin, xmin=low, xmax=high)
372  monTool.defineHistogram('nHits_2nd_unmapped', path='EXPERT', type='TH1I', title='nHits_2nd_unmapped', xbins=nbin, xmin=low, xmax=high)
373  monTool.defineHistogram('nroads_2nd', path='EXPERT', type='TH1I', title='nroads_2nd', xbins=nbin, xmin=low, xmax=high)
374  monTool.defineHistogram('nroads_2nd_postfilter', path='EXPERT', type='TH1I', title='nroads_2nd_postfilter', xbins=nbin, xmin=low, xmax=high)
375  monTool.defineHistogram('layerIDs_2nd', path='EXPERT', type='TH1I', title='layerIDs_2nd', xbins=20, xmin=-0.5, xmax = 19.5)
376  monTool.defineHistogram('layerIDs_2nd_best', path='EXPERT', type='TH1I', title='layerIDs_2nd_best', xbins=20, xmin=-0.5, xmax = 19.5)
377  monTool.defineHistogram('completed_roads_NN', path='EXPERT', type='TH1I', title='completed_roads_NN', xbins=20, xmin=-0.5, xmax = 19.5)
378  monTool.defineHistogram('chi2_2nd_all', path='EXPERT', type='TH1F', title='chi2_2nd_all', xbins=nbin, xmin=low, xmax=high)
379  monTool.defineHistogram('chi2_2nd_afterOLR', path='EXPERT', type='TH1F', title='chi2_2nd_afterOLR', xbins=nbin, xmin=0, xmax=10.0)
380  monTool.defineHistogram('best_chi2_2nd', path='EXPERT', type='TH1F', title='best_chi2_2nd', xbins=nbin, xmin=low, xmax=high)
381  monTool.defineHistogram('ntrack_2nd', path='EXPERT', type='TH1F', title='ntrack_2nd', xbins=nbin, xmin=low, xmax=high)
382  monTool.defineHistogram('ntrack_2nd_afterOLR', path='EXPERT', type='TH1F', title='ntrack_2nd_afterOLR', xbins=nbin, xmin=low, xmax=high)
383  monTool.defineHistogram('eff_road_2nd,pT', path='EXPERT', type='TEfficiency', title='eff_road_pt', xbins=20, xmin=0, xmax=100)
384  monTool.defineHistogram('eff_track_2nd,pT', path='EXPERT', type='TEfficiency', title='eff_track_pt', xbins=20, xmin=0, xmax=100)
385  monTool.defineHistogram('eff_track_chi2_2nd,pT', path='EXPERT', type='TEfficiency', title='eff_track_chi2_pt', xbins=20, xmin=0, xmax=100)
386  monTool.defineHistogram('eff_road_2nd,pT_zoom', path='EXPERT', type='TEfficiency', title='eff_road_pt_zoom', xbins=10, xmin=0, xmax=10)
387  monTool.defineHistogram('eff_track_2nd,pT_zoom', path='EXPERT', type='TEfficiency', title='eff_track_pt_zoom', xbins=10, xmin=0, xmax=10)
388  monTool.defineHistogram('eff_track_chi2_2nd,pT_zoom', path='EXPERT', type='TEfficiency', title='eff_track_chi2_pt_zoom', xbins=10, xmin=0, xmax=10)
389  monTool.defineHistogram('eff_road_2nd,eta', path='EXPERT', type='TEfficiency', title='eff_road_eta', xbins = 20, xmin=etamin, xmax=etamax)
390  monTool.defineHistogram('eff_track_2nd,eta', path='EXPERT', type='TEfficiency', title='eff_track_eta', xbins = 20, xmin=etamin, xmax=etamax)
391  monTool.defineHistogram('eff_track_chi2_2nd,eta', path='EXPERT', type='TEfficiency', title='eff_track_chi2_eta', xbins = 20, xmin=etamin, xmax=etamax)
392  monTool.defineHistogram('eff_road_2nd,phi', path='EXPERT', type='TEfficiency', title='eff_road_phi', xbins = 20, xmin=phimin, xmax=phimax)
393  monTool.defineHistogram('eff_track_2nd,phi', path='EXPERT', type='TEfficiency', title='eff_track_phi', xbins = 20, xmin=phimin, xmax=phimax)
394  monTool.defineHistogram('eff_track_chi2_2nd,phi', path='EXPERT', type='TEfficiency', title='eff_track_chi2_phi', xbins = 20, xmin=phimin, xmax=phimax)
395  monTool.defineHistogram('eff_road_2nd,d0', path='EXPERT', type='TEfficiency', title='eff_road_d0', xbins = 20, xmin = -2.0, xmax = 2.0)
396  monTool.defineHistogram('eff_track_2nd,d0', path='EXPERT', type='TEfficiency', title='eff_track_d0', xbins = 20, xmin = -2.0, xmax = 2.0)
397  monTool.defineHistogram('eff_track_chi2_2nd,d0', path='EXPERT', type='TEfficiency', title='eff_track_chi2_d0', xbins = 20, xmin = -2.0, xmax = 2.0)
398  monTool.defineHistogram('eff_road_2nd,z0', path='EXPERT', type='TEfficiency', title='eff_road_z0', xbins = 20, xmin = -150, xmax = 150.0)
399  monTool.defineHistogram('eff_track_2nd,z0', path='EXPERT', type='TEfficiency', title='eff_track_z0', xbins = 20, xmin = -150.0, xmax = 150.0)
400  monTool.defineHistogram('eff_track_chi2_2nd,z0', path='EXPERT', type='TEfficiency', title='eff_track_chi2_z0', xbins = 20, xmin = -150.0, xmax = 150.0)
401 
402  result.setPrivateTools(monTool)
403 
404  return result

◆ FPGATrackSimTrackMonCfg()

def FPGATrackSimAlgorithmConfig.FPGATrackSimTrackMonCfg (   name,
  flags,
  variety = 'road' 
)

new monitoring tool

Definition at line 268 of file FPGATrackSimAlgorithmConfig.py.

268 def FPGATrackSimTrackMonCfg(name,flags,variety='road'):
269  from FPGATrackSimConfTools.FPGATrackSimDataPrepConfig import getPhiRange, getEtaRange, nameWithRegionSuffix
270  from AthenaConfiguration.ComponentFactory import CompFactory
271  from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
272  monTool = GenericMonitoringTool(flags, 'MonTool')
273 
274  from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
275  result = ComponentAccumulator()
276 
277  nbin=1000
278  low=-0.5
279  high=99999.5
280  if flags.Trigger.FPGATrackSim.singleTrackSample:
281  nbin=100
282  high=99.5
283 
284  phis=getPhiRange(flags)
285  etas=getEtaRange(flags)
286  phimin=phis[0]
287  phimax=phis[1]
288  etamin=etas[0]
289  etamax=etas[1]
290 
291  phimin = phimin-flags.Trigger.FPGATrackSim.phiShift
292  phimax = phimax-flags.Trigger.FPGATrackSim.phiShift
293 
294 
296  if variety=='road':
297  monTool.defineHistogram('nRoads', path='EXPERT', type='TH1I', title='nRoads', xbins=nbin, xmin=low, xmax=high)
298  monTool.defineHistogram('layerIDs', path='EXPERT', type='TH1I', title='layerIDs', xbins=20, xmin=-0.5, xmax = 19.5)
299  monTool.defineHistogram('nLayers', path='EXPERT', type='TH1I', title='nLayers', xbins=nbin, xmin=low, xmax=high)
300 
301 
302  elif variety=='track':
303  monTool.defineHistogram('nTracks', path='EXPERT', type='TH1I', title='nTracks', xbins=nbin, xmin=low, xmax=high)
304  monTool.defineHistogram('chi2_all', path='EXPERT', type='TH1F', title='chi2_all', xbins=nbin, xmin=low, xmax=high)
305  monTool.defineHistogram('best_chi2', path='EXPERT', type='TH1F', title='best_chi2', xbins=nbin, xmin=low, xmax=high)
306 
307 
308  monTool.defineHistogram(f'eff_{variety},pT_zoom', path='EXPERT', type='TEfficiency', title=f'eff_{variety} vs pT_zoom', xbins=10, xmin=0, xmax=10)
309  monTool.defineHistogram(f'eff_{variety},pT', path='EXPERT', type='TEfficiency', title=f'eff_{variety} vs pT', xbins=20, xmin=0, xmax=100)
310  monTool.defineHistogram(f'eff_{variety},eta', path='EXPERT', type='TEfficiency', title=f'eff_{variety} vs eta', xbins=20, xmin=etamin, xmax=etamax)
311  monTool.defineHistogram(f'eff_{variety},phi', path='EXPERT', type='TEfficiency', title=f'eff_{variety} vs phi', xbins=20, xmin=phimin, xmax=phimax)
312  monTool.defineHistogram(f'eff_{variety},d0', path='EXPERT', type='TEfficiency', title=f'eff_{variety} vs d0', xbins=20, xmin=-2.0, xmax=2.0)
313  monTool.defineHistogram(f'eff_{variety},z0', path='EXPERT', type='TEfficiency', title=f'eff_{variety} vs z0', xbins=20, xmin=-150.0, xmax=150.0)
314 
315 
316  trackmon = CompFactory.FPGATrackSimTrackMonitor(nameWithRegionSuffix(flags,f"{variety}_monitor_{name}"))
317 
318 
319  trackmon.MonTool = monTool
320 
321 
322 
323  result.setPrivateTools(trackmon)
324 
325  return result
326 
327 
328 
329 
330 
331 

◆ intList()

def FPGATrackSimAlgorithmConfig.intList (   string)

Definition at line 13 of file FPGATrackSimAlgorithmConfig.py.

13 def intList(string):
14  return [ int(v) for v in string.split(',') if v != '' ]
15 
FPGATrackSimHoughTransformTool
Definition: FPGATrackSimHoughTransformTool.h:91
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:342
vtune_athena.format
format
Definition: vtune_athena.py:14
python.FPGATrackSimDataPrepConfig.getEtaRange
def getEtaRange(flags)
Definition: FPGATrackSimDataPrepConfig.py:99
FPGATrackSimAlgorithmConfig.addLRTDoubletFPGATrackSimool
def addLRTDoubletFPGATrackSimool(algo_tag)
Definition: FPGATrackSimAlgorithmConfig.py:235
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
FPGATrackSimAlgorithmConfig.addHough_d0phi0_Tool
def addHough_d0phi0_Tool(map_tag, algo_tag, doHitTracing)
Definition: FPGATrackSimAlgorithmConfig.py:125
FPGATrackSimAlgorithmConfig.FPGATrackSimDataPrepMonitoringCfg
def FPGATrackSimDataPrepMonitoringCfg(flags)
original monitor histograms
Definition: FPGATrackSimAlgorithmConfig.py:247
FPGATrackSimHelperFunctions.convertRegionsExpressionToArray
def convertRegionsExpressionToArray(expression, min_value=0, max_value=1279)
Definition: FPGATrackSimHelperFunctions.py:6
GenericMonitoringTool
Definition: GenericMonitoringTool.h:51
FPGATrackSimAlgorithmConfig.addHoughTool
def addHoughTool(map_tag, algo_tag, doHitTracing)
Definition: FPGATrackSimAlgorithmConfig.py:51
FPGATrackSimAlgorithmConfig.floatList
def floatList(floatStr)
Definition: FPGATrackSimAlgorithmConfig.py:16
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
FPGATrackSimAlgorithmConfig.applyTag
def applyTag(obj, tag)
Definition: FPGATrackSimAlgorithmConfig.py:23
FPGATrackSimAlgorithmConfig.FPGATrackSimSecondStageAlgMonitoringCfg
def FPGATrackSimSecondStageAlgMonitoringCfg(flags)
Definition: FPGATrackSimAlgorithmConfig.py:345
FPGATrackSimHoughTransform_d0phi0_Tool
Definition: FPGATrackSimHoughTransform_d0phi0_Tool.h:38
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
FPGATrackSimAlgorithmConfig.FPGATrackSimTrackMonCfg
def FPGATrackSimTrackMonCfg(name, flags, variety='road')
new monitoring tool
Definition: FPGATrackSimAlgorithmConfig.py:268
FPGATrackSimAlgorithmConfig.intList
def intList(string)
Definition: FPGATrackSimAlgorithmConfig.py:13
FPGATrackSimHough1DShiftTool
Definition: FPGATrackSimHough1DShiftTool.h:85
FPGATrackSimRoadUnionTool
Definition: FPGATrackSimRoadUnionTool.h:28
FPGATrackSimAlgorithmConfig.addHough1DShiftTool
def addHough1DShiftTool(map_tag, algo_tag)
Definition: FPGATrackSimAlgorithmConfig.py:190
str
Definition: BTagTrackIpAccessor.cxx:11
FPGATrackSimLLPDoubletHoughTransformTool
Definition: FPGATrackSimLLPDoubletHoughTransformTool.h:26
python.FPGATrackSimDataPrepConfig.getPhiRange
def getPhiRange(flags)
Definition: FPGATrackSimDataPrepConfig.py:70
python.FPGATrackSimDataPrepConfig.nameWithRegionSuffix
def nameWithRegionSuffix(flags, basename)
Definition: FPGATrackSimDataPrepConfig.py:8
FPGATrackSimAlgorithmConfig.FPGATrackSimOverlapRemovalToolMonitoringCfg
def FPGATrackSimOverlapRemovalToolMonitoringCfg(flags)
Definition: FPGATrackSimAlgorithmConfig.py:332
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
Generated on Mon Nov 10 2025 22:05:19 for ATLAS Offline Software by   doxygen 1.8.18