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	ActsPLRClusteringToolCfg (flags, str name="ActsPLRClusteringTool", **kwargs)
ComponentAccumulator	ActsStripClusteringToolCfg (flags, str name="ActsStripClusteringTool", **kwargs)
ComponentAccumulator	ActsPixelClusterizationAlgCfg (flags, str name='ActsPixelClusterizationAlg', *, bool useCache=False, **kwargs)
ComponentAccumulator	ActsPLRClusterizationAlgCfg (flags, str name="ActsPLRClusterizationAlg", *, 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 294 of file ActsClusterizationConfig.py.

                                  **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
    kwargs.setdefault("PixelClustersCacheKey", "ActsPixelClusterCache_Back")
    kwargs.setdefault("StripClustersCacheKey", "ActsStripClusterCache_Back")
    acc.addEventAlgo(CompFactory.ActsTrk.Cache.CreatorAlg(name, **kwargs))
    return acc
 

ActsClusterizationCfg()

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

Definition at line 457 of file ActsClusterizationConfig.py.

                          previousActsExtension: str = None) -> ComponentAccumulator:
    assert previousActsExtension is None or isinstance(previousActsExtension, str)
 
    acc = ComponentAccumulator()
                      
    processPixels = flags.Detector.EnableITkPixel
    processStrips = flags.Detector.EnableITkStrip
    processHGTD = flags.Acts.useHGTDClusterInTrackFinding and flags.Detector.EnableHGTD
 
    kwargs = dict()
    kwargs.setdefault('processPixels', processPixels)
    kwargs.setdefault('processStrips', processStrips)
    kwargs.setdefault('processHGTD', processHGTD)
 
    # Clusterization is a three step process at maximum:
    #   (1) Cache Creation
    #   (2) Clusterization algorithm (reconstruction of clusters)
    #   (3) Preparation of collection for downstream algorithms
    # What step is scheduled depends on the tracking pass and the activation
    # or de-activation of caching mechanism.
    
    # Secondary passes do not need cache creation, that has to be performed
    # on the primary pass, and only if the caching is enabled.
    # Reconstruction can run on secondary passes only if the caching is enabled,
    # this is because we may need to process detector elements not processed
    # on the primary pass.
    # Preparation has to be performed on secondary passes always, and on primary
    # pass only if cache is enabled. In the latter case it is useed to collect all
    # the clusters from all views before passing them to the downstream algorithms
 
    from InDetConfig.ITkActsHelpers import isPrimaryPass, isValidationPass
    if isPrimaryPass(flags) or isValidationPass(flags):
        # Primary pass
        # Validation passes count as primary passes
        kwargs.setdefault('runCacheCreation', flags.Acts.useCache)
        kwargs.setdefault('runReconstruction', True)
        kwargs.setdefault('runPreparation', flags.Acts.useCache)
    else:
        # Secondary passes
        kwargs.setdefault('runCacheCreation', False)
        kwargs.setdefault('runReconstruction', flags.Acts.useCache)
        kwargs.setdefault('runPreparation', True)
        
    # Name of the RoI to be used
    roisName = f'{flags.Tracking.ActiveConfig.extension}RegionOfInterest'
    # Large Radius Tracking uses full scan RoI created in the primary pass
    if flags.Tracking.ActiveConfig.isLargeD0 and flags.Tracking.ActiveConfig.isSecondaryPass:
        from InDetConfig.ITkActsHelpers import primaryPassExtension
        roisName = f'{primaryPassExtension(flags)}RegionOfInterest'
        
    # Name of the Cluster container -> ITk + extension without "Acts" + Pixel or Strip + Clusters
    # We also define the same collection from the main ACTS pass (primary)
    primaryPixelClustersName = 'ITkPixelClusters'
    primaryStripClustersName = 'ITkStripClusters'
    primaryHgtdClustersName = 'HGTD_Clusters'
    pixelClustersName = primaryPixelClustersName
    stripClustersName = primaryStripClustersName
    hgtdClustersName = primaryHgtdClustersName
 
    # If the workflow is not a primary pass, then change the name of the cluster collections adding that information
    if flags.Tracking.ActiveConfig.isSecondaryPass:
        keyPrefix = flags.Tracking.ActiveConfig.extension.replace("Acts", "")
        pixelClustersName = f'ITk{keyPrefix}PixelClusters'
        stripClustersName = f'ITk{keyPrefix}StripClusters'
        hgtdClustersName = f'{keyPrefix}HGTD_Clusters'
    
    # Configuration for (1)
    if kwargs['runCacheCreation']:
        kwargs.setdefault('ClusterCacheCreatorAlg.name', f'{flags.Tracking.ActiveConfig.extension}ClusterCacheCreatorAlg')
 
    # Configuration for (2)
    if kwargs['runReconstruction']:
        if kwargs['processPixels']:
            kwargs.setdefault('PixelClusterizationAlg.name', f'{flags.Tracking.ActiveConfig.extension}PixelClusterizationAlg')
            kwargs.setdefault('PixelClusterizationAlg.useCache', flags.Acts.useCache)
            kwargs.setdefault('PixelClusterizationAlg.ClustersKey', pixelClustersName)
            kwargs.setdefault('PixelClusterizationAlg.ClusterCache', f'{flags.Tracking.ActiveConfig.extension}PixelClustersCache')
            if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
                kwargs.setdefault('PixelClusterizationAlg.ExtraInputs', {('ActsTrk::PrepRawDataAssociation', f'StoreGateSvc+{previousActsExtension}PrdMap')})
 
        if kwargs['processStrips']:
            kwargs.setdefault('StripClusterizationAlg.name', f'{flags.Tracking.ActiveConfig.extension}StripClusterizationAlg')
            kwargs.setdefault('StripClusterizationAlg.useCache', flags.Acts.useCache)
            kwargs.setdefault('StripClusterizationAlg.ClustersKey', stripClustersName)
            kwargs.setdefault('StripClusterizationAlg.ClusterCache', f'{flags.Tracking.ActiveConfig.extension}StripClustersCache')
            if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
                kwargs.setdefault('StripClusterizationAlg.ExtraInputs', {('ActsTrk::PrepRawDataAssociation', f'StoreGateSvc+{previousActsExtension}PrdMap')})
 
        if kwargs['processHGTD']:
            kwargs.setdefault('HgtdClusterizationAlg.name', f'{flags.Tracking.ActiveConfig.extension}HgtdClusterizationAlg')
            # HGTD algo has different convention ... need to use the same
            kwargs.setdefault('HgtdClusterizationAlg.ClusterContainerName', hgtdClustersName)
            if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
                kwargs.setdefault('HgtdClusterizationAlg.ExtraInputs', {('ActsTrk::PrepRawDataAssociation', f'StoreGateSvc+{previousActsExtension}PrdMap')})
 
 
    # Configuration for (3)
    if kwargs['runPreparation']:
        if kwargs['processPixels']:
            kwargs.setdefault('PixelClusterPreparationAlg.name', f'{flags.Tracking.ActiveConfig.extension}PixelClusterPreparationAlg')
            kwargs.setdefault('PixelClusterPreparationAlg.useCache', flags.Acts.useCache)
            kwargs.setdefault('PixelClusterPreparationAlg.OutputCollection', f'{pixelClustersName}_Cached' if kwargs['runReconstruction'] else pixelClustersName)
            # The input is one between the collection (w/o cache) and the IDC (w/ cache)
            if not flags.Acts.useCache:
                # Take the collection from the reconstruction step. If not available take the collection from the primary pass
                kwargs.setdefault('PixelClusterPreparationAlg.InputCollection', pixelClustersName if kwargs['runReconstruction'] else primaryPixelClustersName)
                kwargs.setdefault('PixelClusterPreparationAlg.InputIDC', '')
            else:
                kwargs.setdefault('PixelClusterPreparationAlg.InputCollection', '')
                kwargs.setdefault('PixelClusterPreparationAlg.InputIDC', f'{flags.Tracking.ActiveConfig.extension}PixelClustersCache')
            # Prd Map for removing previously used measurements
            if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
                kwargs.setdefault('PixelClusterPreparationAlg.InputPrdMap', f'{previousActsExtension}PrdMap')
                
        if kwargs['processStrips']:
            kwargs.setdefault('StripClusterPreparationAlg.name', f'{flags.Tracking.ActiveConfig.extension}StripClusterPreparationAlg')
            kwargs.setdefault('StripClusterPreparationAlg.useCache', flags.Acts.useCache)
            kwargs.setdefault('StripClusterPreparationAlg.OutputCollection', f'{stripClustersName}_Cached' if kwargs['runReconstruction'] else stripClustersName)
            if not flags.Acts.useCache:
                kwargs.setdefault('StripClusterPreparationAlg.InputCollection', stripClustersName if kwargs['runReconstruction'] else primaryStripClustersName)
                kwargs.setdefault('StripClusterPreparationAlg.InputIDC', '')
            else:
                kwargs.setdefault('StripClusterPreparationAlg.InputCollection', '')
                kwargs.setdefault('StripClusterPreparationAlg.InputIDC', f'{flags.Tracking.ActiveConfig.extension}StripClustersCache')
            # Prd Map for removing previously used measurements
            if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
                kwargs.setdefault('StripClusterPreparationAlg.InputPrdMap', f'{previousActsExtension}PrdMap')
 
        if kwargs['processHGTD']:
            kwargs.setdefault('HgtdClusterPreparationAlg.name', f'{flags.Tracking.ActiveConfig.extension}HgtdClusterPreparationAlg')
            kwargs.setdefault('HgtdClusterPreparationAlg.OutputCollection', f'{hgtdClustersName}_Cached' if kwargs['runReconstruction'] else hgtdClustersName)
            kwargs.setdefault('HgtdClusterPreparationAlg.InputCollection', hgtdClustersName if kwargs['runReconstruction'] else primaryHgtdClustersName)
            kwargs.setdefault('HgtdClusterPreparationAlg.InputIDC', '')
            if flags.Tracking.ActiveConfig.isSecondaryPass and previousActsExtension is not None:
                kwargs.setdefault('HgtdClusterPreparationAlg.InputPrdMap', f'{previousActsExtension}PrdMap')
 
    # Analysis algo(s)
    if flags.Acts.Clusters.doAnalysis:
        # Run analysis code on the resulting cluster collection produced by this tracking pass
        # This collection is the result of (3) if it ran, else the result of (2). We are sure at least one of them run
        if kwargs['processPixels']:
            kwargs.setdefault('PixelClusterAnalysisAlg.name', f'{flags.Tracking.ActiveConfig.extension}PixelClusterAnalysisAlg')
            kwargs.setdefault('PixelClusterAnalysisAlg.extension', flags.Tracking.ActiveConfig.extension)
            kwargs.setdefault('PixelClusterAnalysisAlg.MonGroupName', f'{flags.Tracking.ActiveConfig.extension}ClusterAnalysisAlg')
            kwargs.setdefault('PixelClusterAnalysisAlg.ClusterContainerKey', kwargs['PixelClusterPreparationAlg.OutputCollection'] if kwargs['runPreparation'] else kwargs['PixelClusterizationAlg.ClustersKey'])
 
        if kwargs['processStrips']:
            kwargs.setdefault('StripClusterAnalysisAlg.name', f'{flags.Tracking.ActiveConfig.extension}StripClusterAnalysisAlg')
            kwargs.setdefault('StripClusterAnalysisAlg.extension', flags.Tracking.ActiveConfig.extension)
            kwargs.setdefault('StripClusterAnalysisAlg.MonGroupName', f'{flags.Tracking.ActiveConfig.extension}ClusterAnalysisAlg')
            kwargs.setdefault('StripClusterAnalysisAlg.ClusterContainerKey', kwargs['StripClusterPreparationAlg.OutputCollection'] if kwargs['runPreparation'] else kwargs['StripClusterizationAlg.ClustersKey'])
                
        if kwargs['processHGTD']:
            kwargs.setdefault('HgtdClusterAnalysisAlg.name', f'{flags.Tracking.ActiveConfig.extension}HgtdClusterAnalysisAlg')
            kwargs.setdefault('HgtdClusterAnalysisAlg.extension', flags.Tracking.ActiveConfig.extension)
            kwargs.setdefault('HgtdClusterAnalysisAlg.MonGroupName', f'{flags.Tracking.ActiveConfig.extension}ClusterAnalysisAlg')
 
    acc.merge(ActsMainClusterizationCfg(flags, RoIs=roisName, **kwargs))
 
    # Persistification
    if flags.Acts.EDM.PersistifyClusters and kwargs['runReconstruction']:
        from ActsConfig.ActsPersistificationConfig import PersistifyClusters
        pixelClusterCollections = None if not kwargs['processPixels'] else [kwargs['PixelClusterizationAlg.ClustersKey']]
        stripClusterCollections = None if not kwargs['processStrips'] else [kwargs['StripClusterizationAlg.ClustersKey']]
        hgtdClusterCollections = None if not kwargs['processHGTD'] else [kwargs['HgtdClusterizationAlg.ClusterContainerName']]
        acc.merge(PersistifyClusters(flags,
                                     pixelClusterCollections=pixelClusterCollections,
                                     stripClusterCollections=stripClusterCollections,
                                     hgtdClusterCollections=hgtdClusterCollections))
    return acc

ActsHgtdClusteringToolCfg()

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

Definition at line 10 of file ActsClusterizationConfig.py.

                              **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
    if flags.HGTD.useALTIROC_RDO:
        kwargs.setdefault("useALTIROC_RDO", True)
        kwargs.setdefault("HGTD_TdcCalibrationTool", acc.popToolsAndMerge(HGTD_TdcCalibrationToolCfg(flags)))
    else:
        kwargs.setdefault("useALTIROC_RDO", False)
    acc.setPrivateTools(CompFactory.ActsTrk.HgtdClusteringTool(name, **kwargs))    
    return acc
 

ActsHgtdClusterizationAlgCfg()

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

Definition at line 35 of file ActsClusterizationConfig.py.

                                 **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    if flags.HGTD.Geometry.useGeoModelXml:
        from HGTD_GeoModelXml.HGTD_GeoModelConfig import HGTD_ReadoutGeometryCfg
    else:
        from HGTD_GeoModel.HGTD_GeoModelConfig import HGTD_ReadoutGeometryCfg
    acc.merge(HGTD_ReadoutGeometryCfg(flags))
 
    kwargs.setdefault('RDOContainerName', 'HGTD_RDOs')
    kwargs.setdefault('AltirocRDOContainerName', 'HGTD_ALTIROC_RDOs')
    kwargs.setdefault('ClusterContainerName', 'HGTD_Clusters')
 
    if 'ClusteringTool' not in kwargs:
        from HGTD_Config.HGTD_ConfigFlags import  ClusteringStrategy
        if flags.HGTD.Acts.ClusteringStrategy is ClusteringStrategy.SinglePad:
            kwargs.setdefault('ClusteringTool', acc.popToolsAndMerge(ActsHgtdClusteringToolCfg(flags)))
        else:
            kwargs.setdefault('ClusteringTool', acc.popToolsAndMerge(ActsHgtdTimedClusteringToolCfg(flags)))
 
    if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
        from ActsConfig.ActsMonitoringConfig import ActsHgtdClusterizationMonitoringToolCfg
        kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsHgtdClusterizationMonitoringToolCfg(flags)))
 
    if flags.HGTD.useALTIROC_RDO:
        kwargs.setdefault("useALTIROC_RDO", True)
    else:
        kwargs.setdefault("useALTIROC_RDO", False)
       
    acc.addEventAlgo(CompFactory.ActsTrk.HgtdClusterizationAlg(name, **kwargs))
    return acc
 
 
 

ActsHgtdClusterPreparationAlgCfg()

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

Definition at line 351 of file ActsClusterizationConfig.py.

                                     **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
    kwargs.setdefault('InputCollection', 'HGTDClusters')
    kwargs.setdefault('DetectorElements', 'HGTD_DetectorElementCollection')
 
    # For the time being the HGTD Regional Selector tool does not exist
    
    if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
        from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
        kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
                                                                                               name = "ActsHgtdClusterPreparationMonitoringTool")))
 
    acc.addEventAlgo(CompFactory.ActsTrk.HgtdClusterDataPreparationAlg(name, **kwargs))
    return acc
 
 

ActsHgtdTimedClusteringToolCfg()

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

Definition at line 22 of file ActsClusterizationConfig.py.

                                   **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
    if flags.HGTD.useALTIROC_RDO:
        kwargs.setdefault("useALTIROC_RDO", True)
        kwargs.setdefault("HGTD_TdcCalibrationTool", acc.popToolsAndMerge(HGTD_TdcCalibrationToolCfg(flags)))
    else:
        kwargs.setdefault("useALTIROC_RDO", False)
    
    acc.setPrivateTools(CompFactory.ActsTrk.HgtdTimedClusteringTool(name, **kwargs))    
    return acc
 

ActsMainClusterizationCfg()

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

Definition at line 371 of file ActsClusterizationConfig.py.

                              **kwargs: dict) -> ComponentAccumulator:
    assert isinstance(RoIs, str)
    assert isinstance(kwargs, dict)
    
    acc = ComponentAccumulator()
 
    # Clusterization is a three step process at maximum:
    #   (1) Cache Creation
    #   (2) Clusterization algorithm (reconstruction of clusters)
    #   (3) Preparation of collection for downstream algorithms
    # What step is scheduled depends on the tracking pass and the activation
    # or de-activation of caching mechanism
    
    kwargs.setdefault('processPixels', flags.Detector.EnableITkPixel)
    kwargs.setdefault('processStrips', flags.Detector.EnableITkStrip)
    kwargs.setdefault('processHGTD', flags.Acts.useHGTDClusterInTrackFinding and flags.Detector.EnableHGTD)
    kwargs.setdefault('runCacheCreation', flags.Acts.useCache)
    kwargs.setdefault('runReconstruction', True)
    kwargs.setdefault('runPreparation', flags.Acts.useCache)    
 
    # Step (1)
    if kwargs['runCacheCreation']:
        acc.merge(ActsClusterCacheCreatorAlgCfg(flags,
                                                **extractChildKwargs(prefix='ClusterCacheCreatorAlg.', **kwargs)))
 
    # Step (2)
    if kwargs['runReconstruction']:
        if kwargs['processPixels']:
            if flags.Input.Format is Format.BS:
                if flags.Acts.EDM.PhaseII :
                    from ITkPixelByteStreamCnv.ITkPixelByteStreamCnvConfig import ITkPixelDecodingPhaseIIRDOAlgCfg
                    # @TODO nRDO estimation needs to be refined.
                    acc.merge( ITkPixelDecodingPhaseIIRDOAlgCfg(flags, nRDOs = 1200000, pixelRDOKey='ITkPixelRDOs') )
                else :
                    from ITkPixelByteStreamCnv.ITkPixelByteStreamCnvConfig import ITkPixelDecodingAlgCfg
                    # @TODO handle RoIs
                    acc.merge( ITkPixelDecodingAlgCfg(flags) )
 
            acc.merge(ActsPixelClusterizationAlgCfg(flags,
                                                    RoIs=RoIs,
                                                    **extractChildKwargs(prefix='PixelClusterizationAlg.', **kwargs)))
        if kwargs['processStrips']:
            if flags.Input.Format is Format.BS:
                from ITkStripsByteStreamCnv.ITkStripByteStreamCnvConfig import ITkStripRawDataProviderCfg
                # @TODO handle RoIs, need to toggle flag isRoI_Seeded, when ?
                acc.merge(ITkStripRawDataProviderCfg(flags,
                                                     RoIs=RoIs))
 
            acc.merge(ActsStripClusterizationAlgCfg(flags,
                                                    RoIs=RoIs,
                                                    **extractChildKwargs(prefix='StripClusterizationAlg.', **kwargs)))
        if kwargs['processHGTD']:
            acc.merge(ActsHgtdClusterizationAlgCfg(flags,
                                                   **extractChildKwargs(prefix='HgtdClusterizationAlg.', **kwargs)))
    # Step (3)
    if kwargs['runPreparation']:
        if kwargs['processPixels']:
            acc.merge(ActsPixelClusterPreparationAlgCfg(flags,
                                                        RoIs=RoIs,
                                                        **extractChildKwargs(prefix='PixelClusterPreparationAlg.', **kwargs)))
            
        if kwargs['processStrips']:
            acc.merge(ActsStripClusterPreparationAlgCfg(flags,
                                                        RoIs=RoIs,
                                                        **extractChildKwargs(prefix='StripClusterPreparationAlg.', **kwargs)))
 
        if kwargs['processHGTD']:
            acc.merge(ActsHgtdClusterPreparationAlgCfg(flags,
                                                       RoIs=RoIs,
                                                       **extractChildKwargs(prefix='HgtdClusterPreparationAlg.', **kwargs)))
            
    # Analysis extensions
    if flags.Acts.Clusters.doAnalysis:
        if kwargs['processPixels']:
            from ActsConfig.ActsAnalysisConfig import ActsPixelClusterAnalysisAlgCfg
            acc.merge(ActsPixelClusterAnalysisAlgCfg(flags, **extractChildKwargs(prefix='PixelClusterAnalysisAlg.', **kwargs)))
            
        if kwargs['processStrips']:
            from ActsConfig.ActsAnalysisConfig import ActsStripClusterAnalysisAlgCfg
            acc.merge(ActsStripClusterAnalysisAlgCfg(flags, **extractChildKwargs(prefix='StripClusterAnalysisAlg.', **kwargs)))
 
    return acc
 

ActsPixelClusteringToolCfg()

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

Definition at line 71 of file ActsClusterizationConfig.py.

                               **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    if flags.Acts.Clusters.RetrieveChargeInformation:
        from PixelConditionsAlgorithms.ITkPixelConditionsConfig import ITkPixelChargeCalibCondAlgCfg, ITkPixelOfflineCalibCondAlgCfg
        acc.merge(ITkPixelChargeCalibCondAlgCfg(flags))
        acc.merge(ITkPixelOfflineCalibCondAlgCfg(flags))        
        kwargs.setdefault('PixelChargeCalibCondData', 'ITkPixelChargeCalibCondData')
 
    if "PixelLorentzAngleTool" not in kwargs:
        from SiLorentzAngleTool.ITkPixelLorentzAngleConfig import ITkPixelLorentzAngleToolCfg
        kwargs.setdefault("PixelLorentzAngleTool", acc.popToolsAndMerge( ITkPixelLorentzAngleToolCfg(flags) ))
 
    kwargs.setdefault('UseWeightedPosition', flags.Acts.Clusters.UseWeightedPosition)
 
    #Always use broad errors if cosmics
    kwargs.setdefault('UseBroadErrors', flags.Acts.Clusters.UsePixelBroadErrors or flags.Beam.Type is BeamType.Cosmics)
 
    if flags.Acts.EDM.PhaseII :
        acc.setPrivateTools(CompFactory.ActsTrk.PhaseIIPixelClusteringTool(name, **kwargs))
    else :
        acc.setPrivateTools(CompFactory.ActsTrk.PixelClusteringTool(name, **kwargs))
    return acc
 
 

ActsPixelClusterizationAlgCfg()

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

Definition at line 156 of file ActsClusterizationConfig.py.

                                  **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    kwargs.setdefault("IDHelper", "PixelID")
    if flags.Acts.EDM.PhaseII and flags.Input.Format is not Format.BS:
        # convert persistent to PhaseIIPixelRawDataContainer instead
        acc.merge(PhaseIIPixelRawDataContainerCfg(flags, RDOKey="ITkPixelRDOs"))
    kwargs.setdefault("RDOContainerKey", "ITkPixelRDOs")
    kwargs.setdefault("ClustersKey", "ITkPixelClusters")
    kwargs.setdefault("DetEleCollKey", "ITkPixelDetectorElementCollection")
    # Regional selection
    kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
 
    kwargs.setdefault('ClusterCacheBackend', 'ActsPixelClusterCache_Back')
    kwargs.setdefault('ClusterCache', 'ActsPixelClustersCache')
 
    if 'RegSelTool' not in kwargs:
        from RegionSelector.RegSelToolConfig import regSelTool_ITkPixel_Cfg
        kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkPixel_Cfg(flags)))
 
    if 'ClusteringTool' not in kwargs:
        kwargs.setdefault("ClusteringTool", acc.popToolsAndMerge(ActsPixelClusteringToolCfg(flags)))
 
    if 'DetElStatus' not in kwargs:
        from PixelConditionsAlgorithms.ITkPixelConditionsConfig import ITkPixelDetectorElementStatusAlgCfg
        acc.merge(ITkPixelDetectorElementStatusAlgCfg(flags))
        kwargs.setdefault('DetElStatus', 'ITkPixelDetectorElementStatus')
                
    if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
        from ActsConfig.ActsMonitoringConfig import ActsITkPixelClusterizationMonitoringToolCfg
        kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsITkPixelClusterizationMonitoringToolCfg(flags)))
 
    if flags.Acts.EDM.PhaseII :
        if not useCache:
            acc.addEventAlgo(CompFactory.ActsTrk.PhaseIIPixelClusterizationAlg(name, **kwargs))
        else:
            acc.addEventAlgo(CompFactory.ActsTrk.PhaseIIPixelCacheClusterizationAlg(name, **kwargs))
    else :
        if not useCache:
            acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterizationAlg(name, **kwargs))
        else:
            acc.addEventAlgo(CompFactory.ActsTrk.PixelCacheClusterizationAlg(name, **kwargs))
    return acc
 
 

ActsPixelClusterPreparationAlgCfg()

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

Definition at line 303 of file ActsClusterizationConfig.py.

                                      **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    kwargs.setdefault('InputCollection', 'ITkPixelClusters')
    kwargs.setdefault('DetectorElements', 'ITkPixelDetectorElementCollection')
    
    if 'RegSelTool' not in kwargs:
        from RegionSelector.RegSelToolConfig import regSelTool_ITkPixel_Cfg
        kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkPixel_Cfg(flags)))
        
    if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
        from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
        kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
                                                                                               name = "ActsPixelClusterPreparationMonitoringTool")))
 
    if not useCache:
        acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterDataPreparationAlg(name, **kwargs))
    else:
        acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterCacheDataPreparationAlg(name, **kwargs))
    return acc
 

ActsPLRClusteringToolCfg()

ComponentAccumulator ActsClusterizationConfig.ActsPLRClusteringToolCfg	(		flags,
		str	name = "ActsPLRClusteringTool",
		**	kwargs )

Definition at line 98 of file ActsClusterizationConfig.py.

                             **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    if flags.Acts.Clusters.RetrieveChargeInformation:
        from PixelConditionsAlgorithms.PLR_ConditionsConfig import PLR_ChargeCalibCondAlgCfg
        acc.merge(PLR_ChargeCalibCondAlgCfg(flags))
        kwargs.setdefault("PixelChargeCalibCondData", "PLR_ChargeCalibCondData")
 
    if "PixelLorentzAngleTool" not in kwargs:
        from SiLorentzAngleTool.PLR_LorentzAngleConfig import PLR_LorentzAngleToolCfg
        kwargs.setdefault("PixelLorentzAngleTool",
                          acc.popToolsAndMerge(PLR_LorentzAngleToolCfg(flags)))
 
    kwargs.setdefault("IDHelperName", "PLR_ID")
    kwargs.setdefault("UseWeightedPosition", flags.Acts.Clusters.UseWeightedPosition)
 
    # Always use broad errors if cosmics
    kwargs.setdefault("UseBroadErrors",
                      flags.Acts.Clusters.UsePixelBroadErrors or flags.Beam.Type is BeamType.Cosmics)
 
    if flags.Acts.EDM.PhaseII :
        acc.setPrivateTools(CompFactory.ActsTrk.PhaseIIPixelClusteringTool(name, **kwargs))
    else :
        acc.setPrivateTools(CompFactory.ActsTrk.PixelClusteringTool(name, **kwargs))
    return acc
 
 

ActsPLRClusterizationAlgCfg()

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

Definition at line 205 of file ActsClusterizationConfig.py.

                                **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    kwargs.setdefault("IDHelper", "PLR_ID")
    if flags.Acts.EDM.PhaseII and flags.Input.Format is not Format.BS:
        # convert persistent to PhaseIIPixelRawDataContainer instead
        acc.merge(PhaseIIPixelRawDataContainerCfg(flags,RDOKey="PLR_RDOs"))
    kwargs.setdefault("RDOContainerKey", "PLR_RDOs")
    kwargs.setdefault("ClustersKey", "PLR_Clusters")
    kwargs.setdefault("DetEleCollKey", "PLR_DetectorElementCollection")
    kwargs.setdefault("RoIs", "ActsRegionOfInterest")
 
    kwargs.setdefault("ClusterCacheBackend", "ActsPLRClusterCache_Back")
    kwargs.setdefault("ClusterCache", "ActsPLRClustersCache")
 
    if "RegSelTool" not in kwargs:
        from RegionSelector.RegSelToolConfig import regSelTool_PLR_Cfg
        kwargs.setdefault("RegSelTool", acc.popToolsAndMerge(regSelTool_PLR_Cfg(flags)))
 
    if "ClusteringTool" not in kwargs:
        kwargs.setdefault("ClusteringTool", acc.popToolsAndMerge(ActsPLRClusteringToolCfg(flags)))
 
    if "DetElStatus" not in kwargs:
        from PixelConditionsAlgorithms.PLR_ConditionsConfig import PLR_DetectorElementStatusAlgCfg
        acc.merge(PLR_DetectorElementStatusAlgCfg(flags))
        kwargs.setdefault("DetElStatus", "PLR_DetectorElementStatus")
 
    if flags.Acts.doMonitoring and "MonTool" not in kwargs:
        from ActsConfig.ActsMonitoringConfig import ActsITkPixelClusterizationMonitoringToolCfg
        kwargs.setdefault("MonTool", acc.popToolsAndMerge(
            ActsITkPixelClusterizationMonitoringToolCfg(
                flags,
                name="ActsPLRClusterizationMonitoringTool")))
 
    # @TODO just call ActsPixelClusterizationAlgCfg ?
    if flags.Acts.EDM.PhaseII :
        if not useCache:
            acc.addEventAlgo(CompFactory.ActsTrk.PhaseIIPixelClusterizationAlg(name, **kwargs))
        else:
            acc.addEventAlgo(CompFactory.ActsTrk.PhaseIIPixelCacheClusterizationAlg(name, **kwargs))
    else :
        if not useCache:
            acc.addEventAlgo(CompFactory.ActsTrk.PixelClusterizationAlg(name, **kwargs))
        else:
            acc.addEventAlgo(CompFactory.ActsTrk.PixelCacheClusterizationAlg(name, **kwargs))
    return acc
 

ActsStripClusteringToolCfg()

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

Definition at line 127 of file ActsClusterizationConfig.py.

                               **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    if 'LorentzAngleTool' not in kwargs:
        from SiLorentzAngleTool.ITkStripLorentzAngleConfig import ITkStripLorentzAngleToolCfg
        kwargs.setdefault("LorentzAngleTool", acc.popToolsAndMerge(ITkStripLorentzAngleToolCfg(flags)))
 
    if "StripDetElStatus" not in kwargs :
        from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import  (
            ITkStripDetectorElementStatusAlgCfg)
        acc.merge(ITkStripDetectorElementStatusAlgCfg(flags))
        kwargs.setdefault("StripDetElStatus", "ITkStripDetectorElementStatus")
 
    # Disable noisy modules suppression
    kwargs.setdefault("maxFiredStrips", 0)
 
    if flags.ITk.selectStripIntimeHits and 'timeBins' not in kwargs:
        coll_25ns = flags.Beam.BunchSpacing<=25 and flags.Beam.Type is BeamType.Collisions
        kwargs.setdefault("timeBins", "01X" if coll_25ns else "X1X")
 
 
    #Error strategy
    kwargs.setdefault("errorStrategy",flags.Acts.Clusters.StripClusteringErrorMode.value)
 
    acc.setPrivateTools(CompFactory.ActsTrk.StripClusteringTool(name, **kwargs))
    return acc
 

ActsStripClusterizationAlgCfg()

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

Definition at line 256 of file ActsClusterizationConfig.py.

                                  **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    kwargs.setdefault("RDOContainerKey", "ITkStripRDOs")
    kwargs.setdefault("ClustersKey", "ITkStripClusters")
    kwargs.setdefault("IDHelper", "SCT_ID")
    kwargs.setdefault("DetEleCollKey", "ITkStripDetectorElementCollection")
    # Regional selection
    kwargs.setdefault('RoIs', 'ActsRegionOfInterest')
 
    kwargs.setdefault('ClusterCacheBackend', 'ActsStripClusterCache_Back')
    kwargs.setdefault('ClusterCache', 'ActsStripClustersCache')
 
    if 'RegSelTool' not in kwargs:
        from RegionSelector.RegSelToolConfig import regSelTool_ITkStrip_Cfg
        kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkStrip_Cfg(flags)))
 
    if 'DetElStatus' not in kwargs :
        from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import  ITkStripDetectorElementStatusAlgCfg
        acc.merge(ITkStripDetectorElementStatusAlgCfg(flags))
        kwargs.setdefault("DetElStatus", "ITkStripDetectorElementStatus")
 
    if 'ClusteringTool' not in kwargs:
        kwargs.setdefault("ClusteringTool", acc.popToolsAndMerge(ActsStripClusteringToolCfg(flags)))
 
    if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
        from ActsConfig.ActsMonitoringConfig import ActsITkStripClusterizationMonitoringToolCfg
        kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsITkStripClusterizationMonitoringToolCfg(flags)))
 
    if not useCache:
        acc.addEventAlgo(CompFactory.ActsTrk.StripClusterizationAlg(name, **kwargs))
    else:
        acc.addEventAlgo(CompFactory.ActsTrk.StripCacheClusterizationAlg(name, **kwargs))
    return acc
 

ActsStripClusterPreparationAlgCfg()

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

Definition at line 327 of file ActsClusterizationConfig.py.

                                      **kwargs) -> ComponentAccumulator:
    acc = ComponentAccumulator()
 
    kwargs.setdefault('InputCollection', 'ITkStripClusters')
    kwargs.setdefault('DetectorElements', 'ITkStripDetectorElementCollection')
 
    if 'RegSelTool' not in kwargs:
        from RegionSelector.RegSelToolConfig import regSelTool_ITkStrip_Cfg
        kwargs.setdefault('RegSelTool', acc.popToolsAndMerge(regSelTool_ITkStrip_Cfg(flags)))
        
    if flags.Acts.doMonitoring and 'MonTool' not in kwargs:
        from ActsConfig.ActsMonitoringConfig import ActsDataPreparationMonitoringToolCfg
        kwargs.setdefault('MonTool', acc.popToolsAndMerge(ActsDataPreparationMonitoringToolCfg(flags,
                                                                                               name = "ActsStripClusterPreparationMonitoringTool")))
 
    if not useCache:
        acc.addEventAlgo(CompFactory.ActsTrk.StripClusterDataPreparationAlg(name, **kwargs))
    else:
        acc.addEventAlgo(CompFactory.ActsTrk.StripClusterCacheDataPreparationAlg(name, **kwargs))
    return acc