ITkActsParticleCreationConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 
def ITkActsTrackParticleCreationCfg(flags,
                                    *,
                                    TrackContainers: list[str],
                                    TrackParticleContainer: str,
                                    persistifyCollection: bool = True,
                                    PerigeeExpression: str = None) -> ComponentAccumulator:
    # This function does the following:
    # - Creates track particles from a collection of track containers
    # - Attaches truth decoration to the track particles
    # - Persistifies the track particles
    # The function will be called within the loop on the tracking passes, if the uses asks
    # for collections to be stored in different containers, as well as just before the primary
    # vertex reconstruction, on the ensamble of track collections requested during reconstruction
    # (but always on the primary pass tracks)    
 
    assert isinstance(TrackContainers, list)
    for container in TrackContainers:
        assert isinstance(container, str)
 
    # Set the perigee expression to be used for track particle creation
    # This is used by Heavy Ion configuration
    if PerigeeExpression is None:
        PerigeeExpression = flags.Tracking.perigeeExpression
 
    print("Storing track and track particle containers:")
    print(f"- track collection(s): {TrackContainers}")
    print(f"- track particle collection: {TrackParticleContainer}")
        
    acc = ComponentAccumulator()
 
    prefix = "ActsCombined" if not flags.hasCategory("Tracking.ActiveConfig") else flags.Tracking.ActiveConfig.extension
    prefix += f"To{TrackParticleContainer}"
    from ActsConfig.ActsEventCnvConfig import ActsTrackToTrackParticleCnvAlgCfg, xAODtoTrkConverterAlgCfg
    acc.merge(ActsTrackToTrackParticleCnvAlgCfg(flags,
                                                name = f"{prefix}TrackToTrackParticleCnvAlg",
                                                ACTSTracksLocation = TrackContainers,
                                                TrackParticlesOutKey = TrackParticleContainer,
                                                PerigeeExpression = PerigeeExpression))
    
    if flags.Acts.doxAODToTrkConversion and \
       "Temporary" not in TrackParticleContainer and \
       "Seed" not in TrackParticleContainer:
        acc.merge(xAODtoTrkConverterAlgCfg(flags,
                                       name=f"{prefix}TrackParticleToTrkCnvAlg",
                                       TrackParticles = TrackParticleContainer,
                                       OutTrackContainer="Combined{tracks}Tracks".format(tracks = 
                                                        TrackParticleContainer[:TrackParticleContainer.rfind("Track")]) ))
    if flags.Tracking.doTruth :
        from AthenaCommon.Constants import WARNING, INFO
        track_to_truth_maps = []
        from ActsConfig.ActsTruthConfig import ActsTrackParticleTruthDecorationAlgCfg
        for trackContainer in TrackContainers:
            track_to_truth_maps.append(f"{trackContainer}ToTruthParticleAssociation")
            acc.merge(ActsTrackParticleTruthDecorationAlgCfg(flags,
                                                             name = f'{prefix}TruthDecorationAlg',
                                                             TrackToTruthAssociationMaps = track_to_truth_maps,
                                                             TrackParticleContainerName = TrackParticleContainer,
                                                             OutputLevel = WARNING              if len(TrackContainers)==1 else INFO,
                                                             ComputeTrackRecoEfficiency = False if len(TrackContainers)==1 else True))
 
    # Additional decorations
    if flags.Acts.storeTrackStateInfo:
        from ActsConfig.ActsObjectDecorationConfig import ActsMeasurementToTrackParticleDecorationAlgCfg
        acc.merge(ActsMeasurementToTrackParticleDecorationAlgCfg(flags,
                                                                 name = f"ActsMeasurementTo{TrackParticleContainer}DecorationAlg",
                                                                 TrackParticleKey = TrackParticleContainer))
        
        if flags.Acts.Particles.doAnalysis:
            from ActsConfig.ActsAnalysisConfig import ActsResidualAnalysisAlgCfg
            acc.merge(ActsResidualAnalysisAlgCfg(flags,
                                                 name = f"Acts{TrackParticleContainer}ResidualAnalysisAlg",
                                                 TrackParticles = TrackParticleContainer))
            
    # Persistification
    # By default this is always happening, but in the case the perigee strategy is set
    # to Vertex we need to create a temporary track particle collection wrt the BeamLine
    # which does not need to be persistified
    if persistifyCollection:
        from ActsConfig.ActsPersistificationConfig import PersistifyTrackParticles
        acc.merge(PersistifyTrackParticles(flags,
                                           trackParticleCollections=[TrackParticleContainer]))
    return acc
 
 
def ITkActsTrackParticlePersistificationCfg(flags) -> ComponentAccumulator:
    acc = ComponentAccumulator()
    # Particle creation and persistification
    # Tracks from CKF and SiSPSeededTracks{extension}TrackParticles
    if flags.Tracking.ActiveConfig.storeSiSPSeededTracks:        
        # Naming convention for track particles: SiSPSeededTracks{extension}TrackParticles
        TrackParticleContainer = f'SiSPSeededTracks{flags.Tracking.ActiveConfig.extension}TrackParticles'
        acc.merge(ITkActsTrackParticleCreationCfg(flags,
                                                  TrackContainers = [f"{flags.Tracking.ActiveConfig.extension}Tracks"],
                                                  TrackParticleContainer = TrackParticleContainer))
 
    
    # Track from CKF or ambiguity resolution if we want separate containers
    # In case no ambiguity resolution is scheduled, the CKF tracks will be used instead of those from the ambiguity resolution
    if flags.Tracking.ActiveConfig.storeSeparateContainer:
        # If we do not want the track collection to be merged with another collection
        # then we immediately create the track particles from it
        # Naming convention for track particles: InDet{extension}TrackParticles
        # (unless the pass overrides it via storedTrackParticlesExtension)
        acts_tracks = f"{flags.Tracking.ActiveConfig.extension}Tracks" if not flags.Acts.doAmbiguityResolution else f"{flags.Tracking.ActiveConfig.extension}ResolvedTracks"
        from InDetConfig.ITkActsHelpers import separateTrackParticleContainerName
        TrackParticles = separateTrackParticleContainerName(flags)
        acc.merge(ITkActsTrackParticleCreationCfg(flags,
                                                  TrackContainers = [acts_tracks],
                                                  TrackParticleContainer = TrackParticles))
        
    return acc