ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
ActsClusterizationConfig Namespace Reference

Functions

ComponentAccumulator ActsHgtdClusteringToolCfg (flags, str name="ActsHgtdClusteringTool", **kwargs)
ComponentAccumulator ActsHgtdTimedClusteringToolCfg (flags, str name="ActsHgtdTimedClusteringTool", **kwargs)
ComponentAccumulator ActsHgtdClusterizationAlgCfg (flags, str name="ActsHgtdClusterizationAlg", **kwargs)
ComponentAccumulator ActsPixelClusteringToolCfg (flags, str name="ActsPixelClusteringTool", **kwargs)
ComponentAccumulator ActsStripClusteringToolCfg (flags, str name="ActsStripClusteringTool", **kwargs)
ComponentAccumulator ActsPixelClusterizationAlgCfg (flags, str name='ActsPixelClusterizationAlg', *, bool useCache=False, **kwargs)
ComponentAccumulator ActsStripClusterizationAlgCfg (flags, str name='ActsStripClusterizationAlg', bool useCache=False, **kwargs)
ComponentAccumulator ActsClusterCacheCreatorAlgCfg (flags, str name="ActsClusterCacheCreatorAlg", **kwargs)
ComponentAccumulator ActsPixelClusterPreparationAlgCfg (flags, str name="ActsPixelClusterPreparationAlg", bool useCache=False, **kwargs)
ComponentAccumulator ActsStripClusterPreparationAlgCfg (flags, str name="ActsStripClusterPreparationAlg", bool useCache=False, **kwargs)
ComponentAccumulator ActsHgtdClusterPreparationAlgCfg (flags, str name='ActsHgtdClusterPreparationAlg', *, bool useCache=False, **kwargs)
ComponentAccumulator ActsMainClusterizationCfg (flags, *, str RoIs="ActsRegionOfInterest", **dict kwargs)
ComponentAccumulator ActsClusterizationCfg (flags, *, str previousActsExtension=None)

Function Documentation

◆ ActsClusterCacheCreatorAlgCfg()

ComponentAccumulator ActsClusterizationConfig.ActsClusterCacheCreatorAlgCfg ( flags,
str name = "ActsClusterCacheCreatorAlg",
** kwargs )

Definition at line 183 of file ActsClusterizationConfig.py.

185 **kwargs) -> ComponentAccumulator:
186 acc = ComponentAccumulator()
187 kwargs.setdefault("PixelClustersCacheKey", "ActsPixelClusterCache_Back")
188 kwargs.setdefault("StripClustersCacheKey", "ActsStripClusterCache_Back")
189 acc.addEventAlgo(CompFactory.ActsTrk.Cache.CreatorAlg(name, **kwargs))
190 return acc
191

◆ ActsClusterizationCfg()

ComponentAccumulator ActsClusterizationConfig.ActsClusterizationCfg ( flags,
* ,
str previousActsExtension = None )

Definition at line 330 of file ActsClusterizationConfig.py.

332 previousActsExtension: str = None) -> ComponentAccumulator:
333 assert previousActsExtension is None or isinstance(previousActsExtension, str)
334
335 acc = ComponentAccumulator()
336
337 processPixels = flags.Detector.EnableITkPixel
338 processStrips = flags.Detector.EnableITkStrip
339 processHGTD = flags.Acts.useHGTDClusterInTrackFinding and flags.Detector.EnableHGTD
340
341 kwargs = dict()
342 kwargs.setdefault('processPixels', processPixels)
343 kwargs.setdefault('processStrips', processStrips)
344 kwargs.setdefault('processHGTD', processHGTD)
345
346 # Clusterization is a three step process at maximum:
347 # (1) Cache Creation
348 # (2) Clusterization algorithm (reconstruction of clusters)
349 # (3) Preparation of collection for downstream algorithms
350 # What step is scheduled depends on the tracking pass and the activation
351 # or de-activation of caching mechanism.
352
353 # Secondary passes do not need cache creation, that has to be performed
354 # on the primary pass, and only if the caching is enabled.
355 # Reconstruction can run on secondary passes only if the caching is enabled,
356 # this is because we may need to process detector elements not processed
357 # on the primary pass.
358 # Preparation has to be performed on secondary passes always, and on primary
359 # pass only if cache is enabled. In the latter case it is useed to collect all
360 # the clusters from all views before passing them to the downstream algorithms
361
362 from InDetConfig.ITkActsHelpers import isPrimaryPass, isValidationPass
363 if isPrimaryPass(flags) or isValidationPass(flags):
364 # Primary pass
365 # Validation passes count as primary passes
366 kwargs.setdefault('runCacheCreation', flags.Acts.useCache)
367 kwargs.setdefault('runReconstruction', True)
368 kwargs.setdefault('runPreparation', flags.Acts.useCache)
369 else:
370 # Secondary passes
371 kwargs.setdefault('runCacheCreation', False)
372 kwargs.setdefault('runReconstruction', flags.Acts.useCache)
373 kwargs.setdefault('runPreparation', True)
374
375 # Name of the RoI to be used
376 roisName = f'{flags.Tracking.ActiveConfig.extension}RegionOfInterest'
377 # Large Radius Tracking uses full scan RoI created in the primary pass
378 if flags.Tracking.ActiveConfig.extension == 'ActsLargeRadius':
379 from InDetConfig.ITkActsHelpers import primaryPassExtension
380 roisName = f'{primaryPassExtension(flags)}RegionOfInterest'
381
382 # Name of the Cluster container -> ITk + extension without "Acts" + Pixel or Strip + Clusters
383 # We also define the same collection from the main ACTS pass (primary)
384 primaryPixelClustersName = 'ITkPixelClusters'
385 primaryStripClustersName = 'ITkStripClusters'
386 primaryHgtdClustersName = 'HGTD_Clusters'
387 pixelClustersName = primaryPixelClustersName
388 stripClustersName = primaryStripClustersName
389 hgtdClustersName = primaryHgtdClustersName
390
391 # If the workflow is not a primary pass, then change the name of the cluster collections adding that information
392 if flags.Tracking.ActiveConfig.isSecondaryPass:
393 keyPrefix = flags.Tracking.ActiveConfig.extension.replace("Acts", "")
394 pixelClustersName = f'ITk{keyPrefix}PixelClusters'
395 stripClustersName = f'ITk{keyPrefix}StripClusters'
396 hgtdClustersName = f'{keyPrefix}HGTD_Clusters'
397
398 # Configuration for (1)
399 if kwargs['runCacheCreation']:
400 kwargs.setdefault('ClusterCacheCreatorAlg.name', f'{flags.Tracking.ActiveConfig.extension}ClusterCacheCreatorAlg')
401
402 # Configuration for (2)
403 if kwargs['runReconstruction']:
404 if kwargs['processPixels']:
405 kwargs.setdefault('PixelClusterizationAlg.name', f'{flags.Tracking.ActiveConfig.extension}PixelClusterizationAlg')
406 kwargs.setdefault('PixelClusterizationAlg.useCache', flags.Acts.useCache)
407 kwargs.setdefault('PixelClusterizationAlg.ClustersKey', pixelClustersName)
408 kwargs.setdefault('PixelClusterizationAlg.ClusterCache', f'{flags.Tracking.ActiveConfig.extension}PixelClustersCache')
409 if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
410 kwargs.setdefault('PixelClusterizationAlg.ExtraInputs', {('ActsTrk::PrepRawDataAssociation', f'StoreGateSvc+{previousActsExtension}PrdMap')})
411
412 if kwargs['processStrips']:
413 kwargs.setdefault('StripClusterizationAlg.name', f'{flags.Tracking.ActiveConfig.extension}StripClusterizationAlg')
414 kwargs.setdefault('StripClusterizationAlg.useCache', flags.Acts.useCache)
415 kwargs.setdefault('StripClusterizationAlg.ClustersKey', stripClustersName)
416 kwargs.setdefault('StripClusterizationAlg.ClusterCache', f'{flags.Tracking.ActiveConfig.extension}StripClustersCache')
417 if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
418 kwargs.setdefault('StripClusterizationAlg.ExtraInputs', {('ActsTrk::PrepRawDataAssociation', f'StoreGateSvc+{previousActsExtension}PrdMap')})
419
420 if kwargs['processHGTD']:
421 kwargs.setdefault('HgtdClusterizationAlg.name', f'{flags.Tracking.ActiveConfig.extension}HgtdClusterizationAlg')
422 # HGTD algo has different convention ... need to use the same
423 kwargs.setdefault('HgtdClusterizationAlg.ClusterContainerName', hgtdClustersName)
424 if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
425 kwargs.setdefault('HgtdClusterizationAlg.ExtraInputs', {('ActsTrk::PrepRawDataAssociation', f'StoreGateSvc+{previousActsExtension}PrdMap')})
426
427
428 # Configuration for (3)
429 if kwargs['runPreparation']:
430 if kwargs['processPixels']:
431 kwargs.setdefault('PixelClusterPreparationAlg.name', f'{flags.Tracking.ActiveConfig.extension}PixelClusterPreparationAlg')
432 kwargs.setdefault('PixelClusterPreparationAlg.useCache', flags.Acts.useCache)
433 kwargs.setdefault('PixelClusterPreparationAlg.OutputCollection', f'{pixelClustersName}_Cached' if kwargs['runReconstruction'] else pixelClustersName)
434 # The input is one between the collection (w/o cache) and the IDC (w/ cache)
435 if not flags.Acts.useCache:
436 # Take the collection from the reconstruction step. If not available take the collection from the primary pass
437 kwargs.setdefault('PixelClusterPreparationAlg.InputCollection', pixelClustersName if kwargs['runReconstruction'] else primaryPixelClustersName)
438 kwargs.setdefault('PixelClusterPreparationAlg.InputIDC', '')
439 else:
440 kwargs.setdefault('PixelClusterPreparationAlg.InputCollection', '')
441 kwargs.setdefault('PixelClusterPreparationAlg.InputIDC', f'{flags.Tracking.ActiveConfig.extension}PixelClustersCache')
442 # Prd Map for removing previously used measurements
443 if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
444 kwargs.setdefault('PixelClusterPreparationAlg.InputPrdMap', f'{previousActsExtension}PrdMap')
445
446 if kwargs['processStrips']:
447 kwargs.setdefault('StripClusterPreparationAlg.name', f'{flags.Tracking.ActiveConfig.extension}StripClusterPreparationAlg')
448 kwargs.setdefault('StripClusterPreparationAlg.useCache', flags.Acts.useCache)
449 kwargs.setdefault('StripClusterPreparationAlg.OutputCollection', f'{stripClustersName}_Cached' if kwargs['runReconstruction'] else stripClustersName)
450 if not flags.Acts.useCache:
451 kwargs.setdefault('StripClusterPreparationAlg.InputCollection', stripClustersName if kwargs['runReconstruction'] else primaryStripClustersName)
452 kwargs.setdefault('StripClusterPreparationAlg.InputIDC', '')
453 else:
454 kwargs.setdefault('StripClusterPreparationAlg.InputCollection', '')
455 kwargs.setdefault('StripClusterPreparationAlg.InputIDC', f'{flags.Tracking.ActiveConfig.extension}StripClustersCache')
456 # Prd Map for removing previously used measurements
457 if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
458 kwargs.setdefault('StripClusterPreparationAlg.InputPrdMap', f'{previousActsExtension}PrdMap')
459
460 if kwargs['processHGTD']:
461 kwargs.setdefault('HgtdClusterPreparationAlg.name', f'{flags.Tracking.ActiveConfig.extension}HgtdClusterPreparationAlg')
462 kwargs.setdefault('HgtdClusterPreparationAlg.OutputCollection', f'{hgtdClustersName}_Cached' if kwargs['runReconstruction'] else hgtdClustersName)
463 kwargs.setdefault('HgtdClusterPreparationAlg.InputCollection', hgtdClustersName if kwargs['runReconstruction'] else primaryHgtdClustersName)
464 kwargs.setdefault('HgtdClusterPreparationAlg.InputIDC', '')
465 if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
466 kwargs.setdefault('HgtdClusterPreparationAlg.InputPrdMap', f'{previousActsExtension}PrdMap')
467
468 # Analysis algo(s)
469 if flags.Acts.Clusters.doAnalysis:
470 # Run analysis code on the resulting cluster collection produced by this tracking pass
471 # This collection is the result of (3) if it ran, else the result of (2). We are sure at least one of them run
472 if kwargs['processPixels']:
473 kwargs.setdefault('PixelClusterAnalysisAlg.name', f'{flags.Tracking.ActiveConfig.extension}PixelClusterAnalysisAlg')
474 kwargs.setdefault('PixelClusterAnalysisAlg.extension', flags.Tracking.ActiveConfig.extension)
475 kwargs.setdefault('PixelClusterAnalysisAlg.MonGroupName', f'{flags.Tracking.ActiveConfig.extension}ClusterAnalysisAlg')
476 kwargs.setdefault('PixelClusterAnalysisAlg.ClusterContainerKey', kwargs['PixelClusterPreparationAlg.OutputCollection'] if kwargs['runPreparation'] else kwargs['PixelClusterizationAlg.ClustersKey'])
477
478 if kwargs['processStrips']:
479 kwargs.setdefault('StripClusterAnalysisAlg.name', f'{flags.Tracking.ActiveConfig.extension}StripClusterAnalysisAlg')
480 kwargs.setdefault('StripClusterAnalysisAlg.extension', flags.Tracking.ActiveConfig.extension)
481 kwargs.setdefault('StripClusterAnalysisAlg.MonGroupName', f'{flags.Tracking.ActiveConfig.extension}ClusterAnalysisAlg')
482 kwargs.setdefault('StripClusterAnalysisAlg.ClusterContainerKey', kwargs['StripClusterPreparationAlg.OutputCollection'] if kwargs['runPreparation'] else kwargs['StripClusterizationAlg.ClustersKey'])
483
484 if kwargs['processHGTD']:
485 kwargs.setdefault('HgtdClusterAnalysisAlg.name', f'{flags.Tracking.ActiveConfig.extension}HgtdClusterAnalysisAlg')
486 kwargs.setdefault('HgtdClusterAnalysisAlg.extension', flags.Tracking.ActiveConfig.extension)
487 kwargs.setdefault('HgtdClusterAnalysisAlg.MonGroupName', f'{flags.Tracking.ActiveConfig.extension}ClusterAnalysisAlg')
488
489 acc.merge(ActsMainClusterizationCfg(flags, RoIs=roisName, **kwargs))
490
491 # Persistification
492 if flags.Acts.EDM.PersistifyClusters and kwargs['runReconstruction']:
493 toAOD = []
494 if kwargs['processPixels']:
495 pixel_cluster_shortlist = ['-validationMeasurementLink']
496 pixel_cluster_variables = '.'.join(pixel_cluster_shortlist)
497
498 pixelClusterCollection = kwargs['PixelClusterizationAlg.ClustersKey']
499 toAOD += [f'xAOD::PixelClusterContainer#{pixelClusterCollection}',
500 f'xAOD::PixelClusterAuxContainer#{pixelClusterCollection}Aux.{pixel_cluster_variables}']
501
502 if kwargs['processStrips']:
503 strip_cluster_shortlist = ['-validationMeasurementLink']
504 strip_cluster_variables = '.'.join(strip_cluster_shortlist)
505
506 stripClusterCollection = kwargs['StripClusterizationAlg.ClustersKey']
507 toAOD += [f"xAOD::StripClusterContainer#{stripClusterCollection}",
508 f"xAOD::StripClusterAuxContainer#{stripClusterCollection}Aux.{strip_cluster_variables}"]
509
510 if kwargs['processHGTD']:
511 hgtdClusterCollection = kwargs['HgtdClusterizationAlg.ClusterContainerName']
512 toAOD += [f"xAOD::HGTDClusterContainer#{hgtdClusterCollection}",
513 f"xAOD::HGTDClusterAuxContainer#{hgtdClusterCollection}Aux."]
514
515 from OutputStreamAthenaPool.OutputStreamConfig import addToAOD
516 acc.merge(addToAOD(flags, toAOD))
517
518 return acc
519

◆ ActsHgtdClusteringToolCfg()

ComponentAccumulator ActsClusterizationConfig.ActsHgtdClusteringToolCfg ( flags,
str name = "ActsHgtdClusteringTool",
** kwargs )

Definition at line 8 of file ActsClusterizationConfig.py.

10 **kwargs) -> ComponentAccumulator:
11 acc = ComponentAccumulator()
12 acc.setPrivateTools(CompFactory.ActsTrk.HgtdClusteringTool(name, **kwargs))
13 return acc
14

◆ ActsHgtdClusterizationAlgCfg()

ComponentAccumulator ActsClusterizationConfig.ActsHgtdClusterizationAlgCfg ( flags,
str name = "ActsHgtdClusterizationAlg",
** kwargs )

Definition at line 22 of file ActsClusterizationConfig.py.

24 **kwargs) -> ComponentAccumulator:
25 acc = ComponentAccumulator()
26
27 if flags.HGTD.Geometry.useGeoModelXml:
28 from HGTD_GeoModelXml.HGTD_GeoModelConfig import HGTD_ReadoutGeometryCfg
29 else:
30 from HGTD_GeoModel.HGTD_GeoModelConfig import HGTD_ReadoutGeometryCfg
31 acc.merge(HGTD_ReadoutGeometryCfg(flags))
32
33 kwargs.setdefault('RDOContainerName', 'HGTD_RDOs')
34 kwargs.setdefault('ClusterContainerName', 'HGTD_Clusters')
35
36 if 'ClusteringTool' not in kwargs:
37 from HGTD_Config.HGTD_ConfigFlags import ClusteringStrategy
38 if flags.HGTD.Acts.ClusteringStrategy is ClusteringStrategy.SinglePad:
39 kwargs.setdefault('ClusteringTool', acc.popToolsAndMerge(ActsHgtdClusteringToolCfg(flags)))
40 else:
41 kwargs.setdefault('ClusteringTool', acc.popToolsAndMerge(ActsHgtdTimedClusteringToolCfg(flags)))
42
43 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
44 from ActsConfig.ActsMonitoringConfig import ActsHgtdClusterizationMonitoringToolCfg
45 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsHgtdClusterizationMonitoringToolCfg(flags)))
46
47 acc.addEventAlgo(CompFactory.ActsTrk.HgtdClusterizationAlg(name, **kwargs))
48 return acc
49
50
51

◆ ActsHgtdClusterPreparationAlgCfg()

ComponentAccumulator ActsClusterizationConfig.ActsHgtdClusterPreparationAlgCfg ( flags,
str name = 'ActsHgtdClusterPreparationAlg',
* ,
bool useCache = False,
** kwargs )

Definition at line 240 of file ActsClusterizationConfig.py.

244 **kwargs) -> ComponentAccumulator:
245 acc = ComponentAccumulator()
246 kwargs.setdefault('InputCollection', 'HGTDClusters')
247 kwargs.setdefault('DetectorElements', 'HGTD_DetectorElementCollection')
248
249 # For the time being the HGTD Regional Selector tool does not exist
250
251 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
252 from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
253 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
254 name = "ActsHgtdClusterPreparationMonitoringTool")))
255
256 acc.addEventAlgo(CompFactory.ActsTrk.HgtdClusterDataPreparationAlg(name, **kwargs))
257 return acc
258
259

◆ ActsHgtdTimedClusteringToolCfg()

ComponentAccumulator ActsClusterizationConfig.ActsHgtdTimedClusteringToolCfg ( flags,
str name = "ActsHgtdTimedClusteringTool",
** kwargs )

Definition at line 15 of file ActsClusterizationConfig.py.

17 **kwargs) -> ComponentAccumulator:
18 acc = ComponentAccumulator()
19 acc.setPrivateTools(CompFactory.ActsTrk.HgtdTimedClusteringTool(name, **kwargs))
20 return acc
21

◆ ActsMainClusterizationCfg()

ComponentAccumulator ActsClusterizationConfig.ActsMainClusterizationCfg ( flags,
* ,
str RoIs = "ActsRegionOfInterest",
**dict kwargs )

Definition at line 260 of file ActsClusterizationConfig.py.

263 **kwargs: dict) -> ComponentAccumulator:
264 assert isinstance(RoIs, str)
265 assert isinstance(kwargs, dict)
266
267 acc = ComponentAccumulator()
268
269 # Clusterization is a three step process at maximum:
270 # (1) Cache Creation
271 # (2) Clusterization algorithm (reconstruction of clusters)
272 # (3) Preparation of collection for downstream algorithms
273 # What step is scheduled depends on the tracking pass and the activation
274 # or de-activation of caching mechanism
275
276 kwargs.setdefault('processPixels', flags.Detector.EnableITkPixel)
277 kwargs.setdefault('processStrips', flags.Detector.EnableITkStrip)
278 kwargs.setdefault('processHGTD', flags.Acts.useHGTDClusterInTrackFinding and flags.Detector.EnableHGTD)
279 kwargs.setdefault('runCacheCreation', flags.Acts.useCache)
280 kwargs.setdefault('runReconstruction', True)
281 kwargs.setdefault('runPreparation', flags.Acts.useCache)
282
283 # Step (1)
284 if kwargs['runCacheCreation']:
285 acc.merge(ActsClusterCacheCreatorAlgCfg(flags,
286 **extractChildKwargs(prefix='ClusterCacheCreatorAlg.', **kwargs)))
287
288 # Step (2)
289 if kwargs['runReconstruction']:
290 if kwargs['processPixels']:
291 acc.merge(ActsPixelClusterizationAlgCfg(flags,
292 RoIs=RoIs,
293 **extractChildKwargs(prefix='PixelClusterizationAlg.', **kwargs)))
294 if kwargs['processStrips']:
295 acc.merge(ActsStripClusterizationAlgCfg(flags,
296 RoIs=RoIs,
297 **extractChildKwargs(prefix='StripClusterizationAlg.', **kwargs)))
298 if kwargs['processHGTD']:
299 acc.merge(ActsHgtdClusterizationAlgCfg(flags,
300 **extractChildKwargs(prefix='HgtdClusterizationAlg.', **kwargs)))
301 # Step (3)
302 if kwargs['runPreparation']:
303 if kwargs['processPixels']:
304 acc.merge(ActsPixelClusterPreparationAlgCfg(flags,
305 RoIs=RoIs,
306 **extractChildKwargs(prefix='PixelClusterPreparationAlg.', **kwargs)))
307
308 if kwargs['processStrips']:
309 acc.merge(ActsStripClusterPreparationAlgCfg(flags,
310 RoIs=RoIs,
311 **extractChildKwargs(prefix='StripClusterPreparationAlg.', **kwargs)))
312
313 if kwargs['processHGTD']:
314 acc.merge(ActsHgtdClusterPreparationAlgCfg(flags,
315 RoIs=RoIs,
316 **extractChildKwargs(prefix='HgtdClusterPreparationAlg.', **kwargs)))
317
318 # Analysis extensions
319 if flags.Acts.Clusters.doAnalysis:
320 if kwargs['processPixels']:
321 from ActsConfig.ActsAnalysisConfig import ActsPixelClusterAnalysisAlgCfg
322 acc.merge(ActsPixelClusterAnalysisAlgCfg(flags, **extractChildKwargs(prefix='PixelClusterAnalysisAlg.', **kwargs)))
323
324 if kwargs['processStrips']:
325 from ActsConfig.ActsAnalysisConfig import ActsStripClusterAnalysisAlgCfg
326 acc.merge(ActsStripClusterAnalysisAlgCfg(flags, **extractChildKwargs(prefix='StripClusterAnalysisAlg.', **kwargs)))
327
328 return acc
329

◆ ActsPixelClusteringToolCfg()

ComponentAccumulator ActsClusterizationConfig.ActsPixelClusteringToolCfg ( flags,
str name = "ActsPixelClusteringTool",
** kwargs )

Definition at line 52 of file ActsClusterizationConfig.py.

54 **kwargs) -> ComponentAccumulator:
55 acc = ComponentAccumulator()
56
57 if flags.Acts.Clusters.RetrieveChargeInformation:
58 from PixelConditionsAlgorithms.ITkPixelConditionsConfig import ITkPixelChargeCalibCondAlgCfg, ITkPixelOfflineCalibCondAlgCfg
59 acc.merge(ITkPixelChargeCalibCondAlgCfg(flags))
60 acc.merge(ITkPixelOfflineCalibCondAlgCfg(flags))
61 kwargs.setdefault('PixelChargeCalibCondData', 'ITkPixelChargeCalibCondData')
62
63 if "PixelLorentzAngleTool" not in kwargs:
64 from SiLorentzAngleTool.ITkPixelLorentzAngleConfig import ITkPixelLorentzAngleToolCfg
65 kwargs.setdefault("PixelLorentzAngleTool", acc.popToolsAndMerge( ITkPixelLorentzAngleToolCfg(flags) ))
66
67 kwargs.setdefault('UseWeightedPosition', flags.Acts.Clusters.UseWeightedPosition)
68
69 #Always use broad errors if cosmics
70 kwargs.setdefault('UseBroadErrors', flags.Acts.Clusters.UsePixelBroadErrors or flags.Beam.Type is BeamType.Cosmics)
71
72 acc.setPrivateTools(CompFactory.ActsTrk.PixelClusteringTool(name, **kwargs))
73 return acc
74
75

◆ ActsPixelClusterizationAlgCfg()

ComponentAccumulator ActsClusterizationConfig.ActsPixelClusterizationAlgCfg ( flags,
str name = 'ActsPixelClusterizationAlg',
* ,
bool useCache = False,
** kwargs )

Definition at line 106 of file ActsClusterizationConfig.py.

110 **kwargs) -> ComponentAccumulator:
111 acc = ComponentAccumulator()
112
113 kwargs.setdefault("IDHelper", "PixelID")
114 kwargs.setdefault("RDOContainerKey", "ITkPixelRDOs")
115 kwargs.setdefault("ClustersKey", "ITkPixelClusters")
116 kwargs.setdefault("DetEleCollKey", "ITkPixelDetectorElementCollection")
117 # Regional selection
118 kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
119
120 kwargs.setdefault('ClusterCacheBackend', 'ActsPixelClusterCache_Back')
121 kwargs.setdefault('ClusterCache', 'ActsPixelClustersCache')
122
123 if 'RegSelTool' not in kwargs:
124 from RegionSelector.RegSelToolConfig import regSelTool_ITkPixel_Cfg
125 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkPixel_Cfg(flags)))
126
127 if 'ClusteringTool' not in kwargs:
128 kwargs.setdefault("ClusteringTool", acc.popToolsAndMerge(ActsPixelClusteringToolCfg(flags)))
129
130 if 'DetElStatus' not in kwargs:
131 from PixelConditionsAlgorithms.ITkPixelConditionsConfig import ITkPixelDetectorElementStatusAlgCfg
132 acc.merge(ITkPixelDetectorElementStatusAlgCfg(flags))
133 kwargs.setdefault('DetElStatus', 'ITkPixelDetectorElementStatus')
134
135 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
136 from ActsConfig.ActsMonitoringConfig import ActsITkPixelClusterizationMonitoringToolCfg
137 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsITkPixelClusterizationMonitoringToolCfg(flags)))
138
139 if not useCache:
140 acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterizationAlg(name, **kwargs))
141 else:
142 acc.addEventAlgo(CompFactory.ActsTrk.PixelCacheClusterizationAlg(name, **kwargs))
143 return acc
144

◆ ActsPixelClusterPreparationAlgCfg()

ComponentAccumulator ActsClusterizationConfig.ActsPixelClusterPreparationAlgCfg ( flags,
str name = "ActsPixelClusterPreparationAlg",
bool useCache = False,
** kwargs )

Definition at line 192 of file ActsClusterizationConfig.py.

195 **kwargs) -> ComponentAccumulator:
196 acc = ComponentAccumulator()
197
198 kwargs.setdefault('InputCollection', 'ITkPixelClusters')
199 kwargs.setdefault('DetectorElements', 'ITkPixelDetectorElementCollection')
200
201 if 'RegSelTool' not in kwargs:
202 from RegionSelector.RegSelToolConfig import regSelTool_ITkPixel_Cfg
203 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkPixel_Cfg(flags)))
204
205 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
206 from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
207 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
208 name = "ActsPixelClusterPreparationMonitoringTool")))
209
210 if not useCache:
211 acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterDataPreparationAlg(name, **kwargs))
212 else:
213 acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterCacheDataPreparationAlg(name, **kwargs))
214 return acc
215

◆ ActsStripClusteringToolCfg()

ComponentAccumulator ActsClusterizationConfig.ActsStripClusteringToolCfg ( flags,
str name = "ActsStripClusteringTool",
** kwargs )

Definition at line 76 of file ActsClusterizationConfig.py.

78 **kwargs) -> ComponentAccumulator:
79 acc = ComponentAccumulator()
80
81 if 'LorentzAngleTool' not in kwargs:
82 from SiLorentzAngleTool.ITkStripLorentzAngleConfig import ITkStripLorentzAngleToolCfg
83 kwargs.setdefault("LorentzAngleTool", acc.popToolsAndMerge(ITkStripLorentzAngleToolCfg(flags)))
84
85 kwargs.setdefault("conditionsTool",None)
86 if "StripDetElStatus" not in kwargs :
87 from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import (
88 ITkStripDetectorElementStatusAlgCfg)
89 acc.merge(ITkStripDetectorElementStatusAlgCfg(flags))
90 kwargs.setdefault("StripDetElStatus", "ITkStripDetectorElementStatus")
91
92 # Disable noisy modules suppression
93 kwargs.setdefault("maxFiredStrips", 0)
94
95 if flags.ITk.selectStripIntimeHits and 'timeBins' not in kwargs:
96 coll_25ns = flags.Beam.BunchSpacing<=25 and flags.Beam.Type is BeamType.Collisions
97 kwargs.setdefault("timeBins", "01X" if coll_25ns else "X1X")
98
99
100 #Error strategy
101 kwargs.setdefault("errorStrategy",flags.Acts.Clusters.StripClusteringErrorMode.value)
102
103 acc.setPrivateTools(CompFactory.ActsTrk.StripClusteringTool(name, **kwargs))
104 return acc
105

◆ ActsStripClusterizationAlgCfg()

ComponentAccumulator ActsClusterizationConfig.ActsStripClusterizationAlgCfg ( flags,
str name = 'ActsStripClusterizationAlg',
bool useCache = False,
** kwargs )

Definition at line 145 of file ActsClusterizationConfig.py.

148 **kwargs) -> ComponentAccumulator:
149 acc = ComponentAccumulator()
150
151 kwargs.setdefault("RDOContainerKey", "ITkStripRDOs")
152 kwargs.setdefault("ClustersKey", "ITkStripClusters")
153 kwargs.setdefault("IDHelper", "SCT_ID")
154 kwargs.setdefault("DetEleCollKey", "ITkStripDetectorElementCollection")
155 # Regional selection
156 kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
157
158 kwargs.setdefault('ClusterCacheBackend', 'ActsStripClusterCache_Back')
159 kwargs.setdefault('ClusterCache', 'ActsStripClustersCache')
160
161 if 'RegSelTool' not in kwargs:
162 from RegionSelector.RegSelToolConfig import regSelTool_ITkStrip_Cfg
163 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkStrip_Cfg(flags)))
164
165 if 'DetElStatus' not in kwargs :
166 from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import ITkStripDetectorElementStatusAlgCfg
167 acc.merge(ITkStripDetectorElementStatusAlgCfg(flags))
168 kwargs.setdefault("DetElStatus", "ITkStripDetectorElementStatus")
169
170 if 'ClusteringTool' not in kwargs:
171 kwargs.setdefault("ClusteringTool", acc.popToolsAndMerge(ActsStripClusteringToolCfg(flags)))
172
173 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
174 from ActsConfig.ActsMonitoringConfig import ActsITkStripClusterizationMonitoringToolCfg
175 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsITkStripClusterizationMonitoringToolCfg(flags)))
176
177 if not useCache:
178 acc.addEventAlgo(CompFactory.ActsTrk.StripClusterizationAlg(name, **kwargs))
179 else:
180 acc.addEventAlgo(CompFactory.ActsTrk.StripCacheClusterizationAlg(name, **kwargs))
181 return acc
182

◆ ActsStripClusterPreparationAlgCfg()

ComponentAccumulator ActsClusterizationConfig.ActsStripClusterPreparationAlgCfg ( flags,
str name = "ActsStripClusterPreparationAlg",
bool useCache = False,
** kwargs )

Definition at line 216 of file ActsClusterizationConfig.py.

219 **kwargs) -> ComponentAccumulator:
220 acc = ComponentAccumulator()
221
222 kwargs.setdefault('InputCollection', 'ITkStripClusters')
223 kwargs.setdefault('DetectorElements', 'ITkStripDetectorElementCollection')
224
225 if 'RegSelTool' not in kwargs:
226 from RegionSelector.RegSelToolConfig import regSelTool_ITkStrip_Cfg
227 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkStrip_Cfg(flags)))
228
229 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
230 from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
231 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
232 name = "ActsStripClusterPreparationMonitoringTool")))
233
234 if not useCache:
235 acc.addEventAlgo(CompFactory.ActsTrk.StripClusterDataPreparationAlg(name, **kwargs))
236 else:
237 acc.addEventAlgo(CompFactory.ActsTrk.StripClusterCacheDataPreparationAlg(name, **kwargs))
238 return acc
239
Generated on for ATLAS Offline Software by doxygen 1.14.0