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 201 of file ActsClusterizationConfig.py.

203 **kwargs) -> ComponentAccumulator:
204 acc = ComponentAccumulator()
205 kwargs.setdefault("PixelClustersCacheKey", "ActsPixelClusterCache_Back")
206 kwargs.setdefault("StripClustersCacheKey", "ActsStripClusterCache_Back")
207 acc.addEventAlgo(CompFactory.ActsTrk.Cache.CreatorAlg(name, **kwargs))
208 return acc
209

◆ ActsClusterizationCfg()

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

Definition at line 348 of file ActsClusterizationConfig.py.

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

◆ ActsHgtdClusteringToolCfg()

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

Definition at line 9 of file ActsClusterizationConfig.py.

11 **kwargs) -> ComponentAccumulator:
12 acc = ComponentAccumulator()
13 if flags.HGTD.useALTIROC_RDO:
14 kwargs.setdefault("useALTIROC_RDO", True)
15 kwargs.setdefault("HGTD_TdcCalibrationTool", acc.popToolsAndMerge(HGTD_TdcCalibrationToolCfg(flags)))
16 else:
17 kwargs.setdefault("useALTIROC_RDO", False)
18 acc.setPrivateTools(CompFactory.ActsTrk.HgtdClusteringTool(name, **kwargs))
19 return acc
20

◆ ActsHgtdClusterizationAlgCfg()

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

Definition at line 34 of file ActsClusterizationConfig.py.

36 **kwargs) -> ComponentAccumulator:
37 acc = ComponentAccumulator()
38
39 if flags.HGTD.Geometry.useGeoModelXml:
40 from HGTD_GeoModelXml.HGTD_GeoModelConfig import HGTD_ReadoutGeometryCfg
41 else:
42 from HGTD_GeoModel.HGTD_GeoModelConfig import HGTD_ReadoutGeometryCfg
43 acc.merge(HGTD_ReadoutGeometryCfg(flags))
44
45 kwargs.setdefault('RDOContainerName', 'HGTD_RDOs')
46 kwargs.setdefault('AltirocRDOContainerName', 'HGTD_ALTIROC_RDOs')
47 kwargs.setdefault('ClusterContainerName', 'HGTD_Clusters')
48
49 if 'ClusteringTool' not in kwargs:
50 from HGTD_Config.HGTD_ConfigFlags import ClusteringStrategy
51 if flags.HGTD.Acts.ClusteringStrategy is ClusteringStrategy.SinglePad:
52 kwargs.setdefault('ClusteringTool', acc.popToolsAndMerge(ActsHgtdClusteringToolCfg(flags)))
53 else:
54 kwargs.setdefault('ClusteringTool', acc.popToolsAndMerge(ActsHgtdTimedClusteringToolCfg(flags)))
55
56 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
57 from ActsConfig.ActsMonitoringConfig import ActsHgtdClusterizationMonitoringToolCfg
58 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsHgtdClusterizationMonitoringToolCfg(flags)))
59
60 if flags.HGTD.useALTIROC_RDO:
61 kwargs.setdefault("useALTIROC_RDO", True)
62 else:
63 kwargs.setdefault("useALTIROC_RDO", False)
64
65 acc.addEventAlgo(CompFactory.ActsTrk.HgtdClusterizationAlg(name, **kwargs))
66 return acc
67
68
69

◆ ActsHgtdClusterPreparationAlgCfg()

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

Definition at line 258 of file ActsClusterizationConfig.py.

262 **kwargs) -> ComponentAccumulator:
263 acc = ComponentAccumulator()
264 kwargs.setdefault('InputCollection', 'HGTDClusters')
265 kwargs.setdefault('DetectorElements', 'HGTD_DetectorElementCollection')
266
267 # For the time being the HGTD Regional Selector tool does not exist
268
269 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
270 from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
271 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
272 name = "ActsHgtdClusterPreparationMonitoringTool")))
273
274 acc.addEventAlgo(CompFactory.ActsTrk.HgtdClusterDataPreparationAlg(name, **kwargs))
275 return acc
276
277

◆ ActsHgtdTimedClusteringToolCfg()

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

Definition at line 21 of file ActsClusterizationConfig.py.

23 **kwargs) -> ComponentAccumulator:
24 acc = ComponentAccumulator()
25 if flags.HGTD.useALTIROC_RDO:
26 kwargs.setdefault("useALTIROC_RDO", True)
27 kwargs.setdefault("HGTD_TdcCalibrationTool", acc.popToolsAndMerge(HGTD_TdcCalibrationToolCfg(flags)))
28 else:
29 kwargs.setdefault("useALTIROC_RDO", False)
30
31 acc.setPrivateTools(CompFactory.ActsTrk.HgtdTimedClusteringTool(name, **kwargs))
32 return acc
33

◆ ActsMainClusterizationCfg()

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

Definition at line 278 of file ActsClusterizationConfig.py.

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

◆ ActsPixelClusteringToolCfg()

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

Definition at line 70 of file ActsClusterizationConfig.py.

72 **kwargs) -> ComponentAccumulator:
73 acc = ComponentAccumulator()
74
75 if flags.Acts.Clusters.RetrieveChargeInformation:
76 from PixelConditionsAlgorithms.ITkPixelConditionsConfig import ITkPixelChargeCalibCondAlgCfg, ITkPixelOfflineCalibCondAlgCfg
77 acc.merge(ITkPixelChargeCalibCondAlgCfg(flags))
78 acc.merge(ITkPixelOfflineCalibCondAlgCfg(flags))
79 kwargs.setdefault('PixelChargeCalibCondData', 'ITkPixelChargeCalibCondData')
80
81 if "PixelLorentzAngleTool" not in kwargs:
82 from SiLorentzAngleTool.ITkPixelLorentzAngleConfig import ITkPixelLorentzAngleToolCfg
83 kwargs.setdefault("PixelLorentzAngleTool", acc.popToolsAndMerge( ITkPixelLorentzAngleToolCfg(flags) ))
84
85 kwargs.setdefault('UseWeightedPosition', flags.Acts.Clusters.UseWeightedPosition)
86
87 #Always use broad errors if cosmics
88 kwargs.setdefault('UseBroadErrors', flags.Acts.Clusters.UsePixelBroadErrors or flags.Beam.Type is BeamType.Cosmics)
89
90 acc.setPrivateTools(CompFactory.ActsTrk.PixelClusteringTool(name, **kwargs))
91 return acc
92
93

◆ ActsPixelClusterizationAlgCfg()

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

Definition at line 124 of file ActsClusterizationConfig.py.

128 **kwargs) -> ComponentAccumulator:
129 acc = ComponentAccumulator()
130
131 kwargs.setdefault("IDHelper", "PixelID")
132 kwargs.setdefault("RDOContainerKey", "ITkPixelRDOs")
133 kwargs.setdefault("ClustersKey", "ITkPixelClusters")
134 kwargs.setdefault("DetEleCollKey", "ITkPixelDetectorElementCollection")
135 # Regional selection
136 kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
137
138 kwargs.setdefault('ClusterCacheBackend', 'ActsPixelClusterCache_Back')
139 kwargs.setdefault('ClusterCache', 'ActsPixelClustersCache')
140
141 if 'RegSelTool' not in kwargs:
142 from RegionSelector.RegSelToolConfig import regSelTool_ITkPixel_Cfg
143 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkPixel_Cfg(flags)))
144
145 if 'ClusteringTool' not in kwargs:
146 kwargs.setdefault("ClusteringTool", acc.popToolsAndMerge(ActsPixelClusteringToolCfg(flags)))
147
148 if 'DetElStatus' not in kwargs:
149 from PixelConditionsAlgorithms.ITkPixelConditionsConfig import ITkPixelDetectorElementStatusAlgCfg
150 acc.merge(ITkPixelDetectorElementStatusAlgCfg(flags))
151 kwargs.setdefault('DetElStatus', 'ITkPixelDetectorElementStatus')
152
153 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
154 from ActsConfig.ActsMonitoringConfig import ActsITkPixelClusterizationMonitoringToolCfg
155 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsITkPixelClusterizationMonitoringToolCfg(flags)))
156
157 if not useCache:
158 acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterizationAlg(name, **kwargs))
159 else:
160 acc.addEventAlgo(CompFactory.ActsTrk.PixelCacheClusterizationAlg(name, **kwargs))
161 return acc
162

◆ ActsPixelClusterPreparationAlgCfg()

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

Definition at line 210 of file ActsClusterizationConfig.py.

213 **kwargs) -> ComponentAccumulator:
214 acc = ComponentAccumulator()
215
216 kwargs.setdefault('InputCollection', 'ITkPixelClusters')
217 kwargs.setdefault('DetectorElements', 'ITkPixelDetectorElementCollection')
218
219 if 'RegSelTool' not in kwargs:
220 from RegionSelector.RegSelToolConfig import regSelTool_ITkPixel_Cfg
221 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkPixel_Cfg(flags)))
222
223 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
224 from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
225 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
226 name = "ActsPixelClusterPreparationMonitoringTool")))
227
228 if not useCache:
229 acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterDataPreparationAlg(name, **kwargs))
230 else:
231 acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterCacheDataPreparationAlg(name, **kwargs))
232 return acc
233

◆ ActsStripClusteringToolCfg()

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

Definition at line 94 of file ActsClusterizationConfig.py.

96 **kwargs) -> ComponentAccumulator:
97 acc = ComponentAccumulator()
98
99 if 'LorentzAngleTool' not in kwargs:
100 from SiLorentzAngleTool.ITkStripLorentzAngleConfig import ITkStripLorentzAngleToolCfg
101 kwargs.setdefault("LorentzAngleTool", acc.popToolsAndMerge(ITkStripLorentzAngleToolCfg(flags)))
102
103 kwargs.setdefault("conditionsTool",None)
104 if "StripDetElStatus" not in kwargs :
105 from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import (
106 ITkStripDetectorElementStatusAlgCfg)
107 acc.merge(ITkStripDetectorElementStatusAlgCfg(flags))
108 kwargs.setdefault("StripDetElStatus", "ITkStripDetectorElementStatus")
109
110 # Disable noisy modules suppression
111 kwargs.setdefault("maxFiredStrips", 0)
112
113 if flags.ITk.selectStripIntimeHits and 'timeBins' not in kwargs:
114 coll_25ns = flags.Beam.BunchSpacing<=25 and flags.Beam.Type is BeamType.Collisions
115 kwargs.setdefault("timeBins", "01X" if coll_25ns else "X1X")
116
117
118 #Error strategy
119 kwargs.setdefault("errorStrategy",flags.Acts.Clusters.StripClusteringErrorMode.value)
120
121 acc.setPrivateTools(CompFactory.ActsTrk.StripClusteringTool(name, **kwargs))
122 return acc
123

◆ ActsStripClusterizationAlgCfg()

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

Definition at line 163 of file ActsClusterizationConfig.py.

166 **kwargs) -> ComponentAccumulator:
167 acc = ComponentAccumulator()
168
169 kwargs.setdefault("RDOContainerKey", "ITkStripRDOs")
170 kwargs.setdefault("ClustersKey", "ITkStripClusters")
171 kwargs.setdefault("IDHelper", "SCT_ID")
172 kwargs.setdefault("DetEleCollKey", "ITkStripDetectorElementCollection")
173 # Regional selection
174 kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
175
176 kwargs.setdefault('ClusterCacheBackend', 'ActsStripClusterCache_Back')
177 kwargs.setdefault('ClusterCache', 'ActsStripClustersCache')
178
179 if 'RegSelTool' not in kwargs:
180 from RegionSelector.RegSelToolConfig import regSelTool_ITkStrip_Cfg
181 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkStrip_Cfg(flags)))
182
183 if 'DetElStatus' not in kwargs :
184 from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import ITkStripDetectorElementStatusAlgCfg
185 acc.merge(ITkStripDetectorElementStatusAlgCfg(flags))
186 kwargs.setdefault("DetElStatus", "ITkStripDetectorElementStatus")
187
188 if 'ClusteringTool' not in kwargs:
189 kwargs.setdefault("ClusteringTool", acc.popToolsAndMerge(ActsStripClusteringToolCfg(flags)))
190
191 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
192 from ActsConfig.ActsMonitoringConfig import ActsITkStripClusterizationMonitoringToolCfg
193 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsITkStripClusterizationMonitoringToolCfg(flags)))
194
195 if not useCache:
196 acc.addEventAlgo(CompFactory.ActsTrk.StripClusterizationAlg(name, **kwargs))
197 else:
198 acc.addEventAlgo(CompFactory.ActsTrk.StripCacheClusterizationAlg(name, **kwargs))
199 return acc
200

◆ ActsStripClusterPreparationAlgCfg()

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

Definition at line 234 of file ActsClusterizationConfig.py.

237 **kwargs) -> ComponentAccumulator:
238 acc = ComponentAccumulator()
239
240 kwargs.setdefault('InputCollection', 'ITkStripClusters')
241 kwargs.setdefault('DetectorElements', 'ITkStripDetectorElementCollection')
242
243 if 'RegSelTool' not in kwargs:
244 from RegionSelector.RegSelToolConfig import regSelTool_ITkStrip_Cfg
245 kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkStrip_Cfg(flags)))
246
247 if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
248 from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
249 kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
250 name = "ActsStripClusterPreparationMonitoringTool")))
251
252 if not useCache:
253 acc.addEventAlgo(CompFactory.ActsTrk.StripClusterDataPreparationAlg(name, **kwargs))
254 else:
255 acc.addEventAlgo(CompFactory.ActsTrk.StripClusterCacheDataPreparationAlg(name, **kwargs))
256 return acc
257
Generated on for ATLAS Offline Software by doxygen 1.14.0