Functions
	CombinedTrackingPassFlagSets (flags, resetCache=False)
	ClusterSplitProbabilityContainerName (flags)
	InDetCosmicsTrackRecoPreProcessingCfg (flags)
	InDetPreProcessingCfg (flags)
	SiDetectorElementStatusCfg (flags, suffix="")
	SiSubDetTrackRecoCfg (flags, detector="", extensions_list=None, ClusterSplitProbContainer="")
	TRTTrackRecoCfg (flags, extensions_list=None)
	TRTStandalonePassRecoCfg (flags, InputCombinedInDetTracks=None, InputExtendedInDetTracks=None, StatTrackCollections=None, StatTrackTruthCollections=None)
	StoreTrackSeparateContainerCfg (flags, TrackContainer="", ClusterSplitProbContainer="")
	TrackOverlayResolvedTracksName (flags)
	TrackOverlayRoIRemovedTracksName (flags)
	BackTrackingRecoCfg (flags, InputCombinedInDetTracks=None, InputExtendedInDetTracks=None, StatTrackCollections=None, StatTrackTruthCollections=None, ClusterSplitProbContainer="")
	TrackRecoPassCfg (flags, extension="", doTrackingSiPattern=True, InputCombinedInDetTracks=None, InputExtendedInDetTracks=None, StatTrackCollections=None, StatTrackTruthCollections=None, ClusterSplitProbContainer="")
	TrackFinalCfg (flags, InputCombinedInDetTracks=None, StatTrackCollections=None, StatTrackTruthCollections=None)
	PseudoTrackFinalCfg (flags)
	ObserverTrackFinalCfg (flags)
	TrackSeedsFinalCfg (flags)
	SiSPSeededTracksFinalCfg (flags)
	InDetStatsCfg (flags, StatTrackCollections=None, StatTrackTruthCollections=None)
	ExtendedPRDInfoCfg (flags)
	InDetTrackRecoCfg (flags)
	Main ID tracking config #####################.
	TrackRecoConfigTest (flags=None)

Variables
list	_flags_set = []
list	_extensions_list = []

Function Documentation

◆ BackTrackingRecoCfg()

BackTrackingRecoCfg	(	flags,
		InputCombinedInDetTracks = None,
		InputExtendedInDetTracks = None,
		StatTrackCollections = None,
		StatTrackTruthCollections = None,
		ClusterSplitProbContainer = "" )

Definition at line 385 of file TrackRecoConfig.py.

                        ClusterSplitProbContainer=""):
    result = ComponentAccumulator()
 
    if InputCombinedInDetTracks is None:
        InputCombinedInDetTracks = []
    if InputExtendedInDetTracks is None:
        InputExtendedInDetTracks = []
    if StatTrackCollections is None:
        StatTrackCollections = []
    if StatTrackTruthCollections is None:
        StatTrackTruthCollections = []
 
    from InDetConfig.BackTrackingConfig import BackTrackingCfg
    result.merge(BackTrackingCfg(
        flags,
        InputCollections=InputCombinedInDetTracks,
        ClusterSplitProbContainer=ClusterSplitProbContainer))
 
    ClusterSplitProbContainer = (
        "InDetTRT_SeededAmbiguityProcessorSplitProb" +
        flags.Tracking.ActiveConfig.extension)
    TRTSeededTracks = "TRTSeededTracks"
    ResolvedTRTSeededTracks = "ResolvedTRTSeededTracks"
    InputCombinedInDetTracks += [ResolvedTRTSeededTracks]
    InputExtendedInDetTracks += [ResolvedTRTSeededTracks]
    StatTrackCollections += [TRTSeededTracks,
                             ResolvedTRTSeededTracks]
    StatTrackTruthCollections += [TRTSeededTracks+"TruthCollection",
                                  ResolvedTRTSeededTracks+"TruthCollection"]
 
    return result, ClusterSplitProbContainer
 
 
# Returns CA + ClusterSplitProbContainer

◆ ClusterSplitProbabilityContainerName()

ClusterSplitProbabilityContainerName ( flags )

Definition at line 89 of file TrackRecoConfig.py.

def ClusterSplitProbabilityContainerName(flags):
    if flags.Detector.GeometryITk:
        from InDetConfig.ITkTrackRecoConfig import (
            ITkClusterSplitProbabilityContainerName)
        return ITkClusterSplitProbabilityContainerName(flags)
 
    flags_set = CombinedTrackingPassFlagSets(flags)
    extension = flags_set[-1].Tracking.ActiveConfig.extension
 
    # No ambi processing for TRT standalone, so pick the previous pass
    if extension == "TRTStandalone":
        extension = flags_set[-2].Tracking.ActiveConfig.extension
 
    ClusterSplitProbContainer = "InDetAmbiguityProcessorSplitProb" + extension
 
    # Only primary pass + back-tracking
    if len(flags_set) == 1 and flags.Tracking.doBackTracking:
        ClusterSplitProbContainer = (
            "InDetTRT_SeededAmbiguityProcessorSplitProb" + extension)
    return ClusterSplitProbContainer
 
# TODO find config to validate this
 
 

◆ CombinedTrackingPassFlagSets()

CombinedTrackingPassFlagSets	(		flags,
			resetCache = False )

Definition at line 11 of file TrackRecoConfig.py.

def CombinedTrackingPassFlagSets(flags, resetCache=False):
 
    global _flags_set
    if _flags_set and not resetCache:
        return _flags_set
 
    flags_set = []
 
    # Primary Pass
    flags = flags.cloneAndReplace(
        "Tracking.ActiveConfig",
        f"Tracking.{flags.Tracking.PrimaryPassConfig.value}Pass",
        # Keep original flags as some of the subsequent passes use
        # lambda functions relying on them
        keepOriginal=True)
    flags_set += [flags]
 
    # LRT pass
    if flags.Tracking.doLargeD0 or flags.Tracking.doLowPtLargeD0:
 
        if flags.Tracking.doLowPtLargeD0:
            flagsLRT = flags.cloneAndReplace("Tracking.ActiveConfig",
                                             "Tracking.LowPtLargeD0Pass")
        elif flags.Tracking.doLargeD0:
            flagsLRT = flags.cloneAndReplace("Tracking.ActiveConfig",
                                             "Tracking.R3LargeD0Pass")
 
        flags_set += [flagsLRT]
 
    # LowPtRoI pass (low-pt tracks in high pile-up environment)
    if flags.Tracking.doLowPtRoI:
        flagsLowPtRoI = flags.cloneAndReplace("Tracking.ActiveConfig",
                                              "Tracking.LowPtRoIPass")
        flags_set += [flagsLowPtRoI]
 
    # LowPt pass
    if flags.Tracking.doLowPt:
        from TrkConfig.TrkConfigFlags import PrimaryPassConfig
        flagsLowPt = None
        if flags.Tracking.PrimaryPassConfig is not PrimaryPassConfig.HeavyIon:
            flagsLowPt = flags.cloneAndReplace("Tracking.ActiveConfig",
                                               "Tracking.LowPtPass")
            flags_set += [flagsLowPt]
 
    # VeryLowPt pass
    if flags.Tracking.doVeryLowPt:
        flagsVeryLowPt = flags.cloneAndReplace("Tracking.ActiveConfig",
                                               "Tracking.VeryLowPtPass")
        flags_set += [flagsVeryLowPt]
 
    # TRT standalone pass
    if flags.Tracking.doTRTStandalone:
        flagsTRTStandalone = flags.cloneAndReplace("Tracking.ActiveConfig",
                                                   "Tracking.TRTStandalonePass")
        flags_set += [flagsTRTStandalone]
 
    # Forward tracklets
    if flags.Tracking.doForwardTracks:
        flagsForward = flags.cloneAndReplace("Tracking.ActiveConfig",
                                             "Tracking.ForwardPass")
        flags_set += [flagsForward]
 
    # Disappearing pixel tracklets
    if flags.Tracking.doTrackSegmentsDisappearing:
        flagsDisappearing = flags.cloneAndReplace("Tracking.ActiveConfig",
                                                  "Tracking.DisappearingPass")
        flags_set += [flagsDisappearing]
 
    # Beam gas
    if flags.Tracking.doBeamGas:
        flagsBeamGas = flags.cloneAndReplace("Tracking.ActiveConfig",
                                             "Tracking.BeamGasPass")
        flags_set += [flagsBeamGas]
 
    _flags_set = flags_set  # Put into cache
 
    return flags_set
 

◆ ExtendedPRDInfoCfg()

ExtendedPRDInfoCfg ( flags )

Definition at line 759 of file TrackRecoConfig.py.

def ExtendedPRDInfoCfg(flags):
    result = ComponentAccumulator()
 
    if (flags.Tracking.doTIDE_AmbiTrackMonitoring or
        flags.Tracking.doPseudoTracking):
        from InDetConfig.InDetPrepRawDataToxAODConfig import (
            InDetPixelPrepDataToxAOD_ExtraTruthCfg as PixelPrepDataToxAODCfg,
            InDetSCT_PrepDataToxAOD_ExtraTruthCfg as SCT_PrepDataToxAODCfg,
            InDetTRT_PrepDataToxAOD_ExtraTruthCfg as TRT_PrepDataToxAODCfg)
    else:
        from InDetConfig.InDetPrepRawDataToxAODConfig import (
            InDetPixelPrepDataToxAODCfg as PixelPrepDataToxAODCfg,
            InDetSCT_PrepDataToxAODCfg as SCT_PrepDataToxAODCfg,
            InDetTRT_PrepDataToxAODCfg as TRT_PrepDataToxAODCfg)
 
    if flags.Tracking.writeExtendedSi_PRDInfo:
        result.merge(PixelPrepDataToxAODCfg(
            flags,
            ClusterSplitProbabilityName=(
                ClusterSplitProbabilityContainerName(flags))))
        result.merge(SCT_PrepDataToxAODCfg(flags))
 
    if flags.Tracking.writeExtendedTRT_PRDInfo:
        result.merge(TRT_PrepDataToxAODCfg(flags))
 
    from DerivationFrameworkInDet.InDetToolsConfig import TSOS_CommonKernelCfg
    # Set up one algorithm for each output tracking container    
    # Always done for default pass
    # Done for other passes if pass requests to store track seeds OR track candidates OR requests separate container 
    # Input handling/configuration of algorithm for specific cases is done in TSOS_CommonKernelCfg
    listOfExtensionsRequesting = [
        e for e in _extensions_list if (e == '')
        or (flags.Tracking[f"{e}Pass"].storeTrackSeeds) # Store Si track seeds
        or (flags.Tracking[f"{e}Pass"].storeSiSPSeededTracks) # Store Si candidate tracks
        or (flags.Tracking[f"{e}Pass"].storeSeparateContainer) ] # Particular tracking pass requesting separate container from main pass
    result.merge(TSOS_CommonKernelCfg(
        flags, listOfExtensions = listOfExtensionsRequesting))
 
    if flags.Tracking.doTIDE_AmbiTrackMonitoring:
        from DerivationFrameworkInDet.InDetToolsConfig import (
            ObserverTSOS_CommonKernelCfg)
        result.merge(ObserverTSOS_CommonKernelCfg(flags))
 
    if flags.Tracking.doPseudoTracking:
        from DerivationFrameworkInDet.InDetToolsConfig import (
            PseudoTSOS_CommonKernelCfg)
        result.merge(PseudoTSOS_CommonKernelCfg(flags))
 
    if flags.Tracking.doStoreTrackSeeds:
        from DerivationFrameworkInDet.InDetToolsConfig import (
            SiSPSeedsTSOS_CommonKernelCfg)
        # Setup one algorithm for each output tracking container
        listOfExtensionsRequesting = [
            e for e in _extensions_list if (e == '') or
            flags.Tracking[f"{e}Pass"].storeTrackSeeds ]
        result.merge(SiSPSeedsTSOS_CommonKernelCfg(
            flags, listOfExtensions = listOfExtensionsRequesting))
 
    if flags.Tracking.doStoreSiSPSeededTracks:
        from DerivationFrameworkInDet.InDetToolsConfig import (
            SiSPTSOS_CommonKernelCfg)
        # Setup one algorithm for each output tracking container
        listOfExtensionsRequesting = [
            e for e in _extensions_list if (e == '') or
            flags.Tracking[f"{e}Pass"].storeSiSPSeededTracks ]
        result.merge(SiSPTSOS_CommonKernelCfg(
            flags, listOfExtensions = listOfExtensionsRequesting))
 
    if flags.Tracking.doTruth:
        #check if we want to add it for other passes
        listOfExtensionsRequesting = [
            e for e in _extensions_list if (e == '') or
            (flags.Tracking[f"{e}Pass"].storeSiSPSeededTracks and
             flags.Tracking[f"{e}Pass"].storeSeparateContainer) ]
        from InDetPhysValMonitoring.InDetPhysValDecorationConfig import (
            InDetPhysHitDecoratorAlgCfg)
        for extension in listOfExtensionsRequesting:
            result.merge(InDetPhysHitDecoratorAlgCfg(
                flags,
                name=f"InDetPhysHit{extension}DecoratorAlg",
                TrackParticleContainerName=f"InDet{extension}TrackParticles"))
 
    return result
 
 

◆ InDetCosmicsTrackRecoPreProcessingCfg()

InDetCosmicsTrackRecoPreProcessingCfg ( flags )

Definition at line 113 of file TrackRecoConfig.py.

def InDetCosmicsTrackRecoPreProcessingCfg(flags):
    result = ComponentAccumulator()
 
    from InDetConfig.TrackingSiPatternConfig import TrackingSiPatternCfg
    result.merge(TrackingSiPatternCfg(
        flags,
        InputCollections=[],
        ResolvedTrackCollectionKey="ResolvedTracks",
        SiSPSeededTrackCollectionKey="SiSPSeededTracks"))
 
    if flags.Detector.EnableTRT:
        from InDetConfig.TRTExtensionConfig import NewTrackingTRTExtensionPhaseCfg
        result.merge(NewTrackingTRTExtensionPhaseCfg(
            flags,
            SiTrackCollection="ResolvedTracks",
            ExtendedTrackCollection="ExtendedTracksPhase",
            ExtendedTracksMap="ExtendedTracksMapPhase"))
 
        from InDetConfig.TRTSegmentFindingConfig import TRTSegmentFinding_Phase_Cfg
        result.merge(TRTSegmentFinding_Phase_Cfg(flags))
 
        from InDetConfig.InDetTrackPRD_AssociationConfig import (
            InDetTrackPRD_AssociationCfg)
        result.merge(InDetTrackPRD_AssociationCfg(
            flags, name='InDetTRTonly_TrackPRD_AssociationPhase',
            AssociationMapName='InDetTRTonly_PRDtoTrackMapPhase',
            TracksName=[]))
 
        from InDetConfig.TRT_SegmentsToTrackConfig import (
            TRT_Cosmics_SegmentsToTrackCfg)
        result.merge(TRT_Cosmics_SegmentsToTrackCfg(
            flags, name='InDetTRT_Cosmics_SegmentsToTrack_Phase',
            InputSegmentsCollection="TRTSegments_Phase",
            OutputTrackCollection="TRT_Tracks_Phase"))
 
        from InDetConfig.InDetCosmicsEventPhaseConfig import (
            InDetCosmicsEventPhaseCfg)
        result.merge(InDetCosmicsEventPhaseCfg(
            flags,
            InputTracksNames=["TRT_Tracks_Phase"]))
 
        from InDetConfig.InDetPrepRawDataFormationConfig import (
            InDetTRT_Phase_RIO_MakerCfg)
        result.merge(InDetTRT_Phase_RIO_MakerCfg(flags))
 
    return result
 
 

◆ InDetPreProcessingCfg()

InDetPreProcessingCfg ( flags )

Definition at line 161 of file TrackRecoConfig.py.

def InDetPreProcessingCfg(flags):
    result = ComponentAccumulator()
 
    # Detector ByteStream pre-processing
    if flags.Input.Format is Format.BS:
        if flags.Detector.EnablePixel:
            from PixelRawDataByteStreamCnv.PixelRawDataByteStreamCnvConfig import (
                PixelRawDataProviderAlgCfg)
            result.merge(PixelRawDataProviderAlgCfg(flags))
 
        if flags.Detector.EnableSCT:
            from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConfig import (
                SCTRawDataProviderCfg, SCTEventFlagWriterCfg)
            result.merge(SCTRawDataProviderCfg(flags))
            result.merge(SCTEventFlagWriterCfg(flags))
 
        if flags.Detector.EnableTRT:
            from TRT_RawDataByteStreamCnv.TRT_RawDataByteStreamCnvConfig import (
                TRTRawDataProviderCfg)
            result.merge(TRTRawDataProviderCfg(flags))
 
    if flags.Detector.EnablePixel or flags.Detector.EnableSCT:
        from InDetConfig.SiliconPreProcessing import InDetRecPreProcessingSiliconCfg
        result.merge(InDetRecPreProcessingSiliconCfg(flags))
    if flags.Detector.EnableTRT:
        from InDetConfig.TRTPreProcessing import TRTPreProcessingCfg
        result.merge(TRTPreProcessingCfg(flags))
 
    return result
 

◆ InDetStatsCfg()

InDetStatsCfg	(	flags,
		StatTrackCollections = None,
		StatTrackTruthCollections = None )

Definition at line 737 of file TrackRecoConfig.py.

                  StatTrackTruthCollections=None):
    result = ComponentAccumulator()
 
    from InDetConfig.InDetRecStatisticsConfig import (
        InDetRecStatisticsAlgCfg)
    result.merge(InDetRecStatisticsAlgCfg(
        flags,
        TrackCollectionKeys=StatTrackCollections,
        TrackTruthCollectionKeys=(
            StatTrackTruthCollections if flags.Tracking.doTruth else [])))
 
    if flags.Tracking.doTruth:
        from InDetConfig.InDetTrackClusterAssValidationConfig import (
            InDetTrackClusterAssValidationCfg)
        result.merge(InDetTrackClusterAssValidationCfg(
            flags,
            TracksLocation=StatTrackCollections))
 
    return result
 
 

◆ InDetTrackRecoCfg()

InDetTrackRecoCfg ( flags )

Main ID tracking config #####################.

Definition at line 848 of file TrackRecoConfig.py.

def InDetTrackRecoCfg(flags):
 
    # Bypass to ITk config
    if flags.Detector.GeometryITk:
        from InDetConfig.ITkTrackRecoConfig import ITkTrackRecoCfg
        return ITkTrackRecoCfg(flags)
    # Bypass to ACTS Inner Detector config
    from TrkConfig.TrkConfigFlags import TrackingComponent
    if TrackingComponent.ActsChain in flags.Tracking.recoChain:
        from InDetConfig.ActsTrackRecoConfig import ActsTrackRecoCfg
        return ActsTrackRecoCfg(flags)
    """Configures complete ID tracking """
    result = ComponentAccumulator()
    result.merge(InDetPreProcessingCfg(flags))
 
    ClusterSplitProbContainer = ''
 
    # ------------------------------------------------------------
    #
    # ----------- Subdetector pattern from New Tracking
    #
    # ------------------------------------------------------------
 
    # Pixel track segment finding
    if flags.Tracking.doTrackSegmentsPixel:
        acc, ClusterSplitProbContainer = (
            SiSubDetTrackRecoCfg(flags, detector="Pixel",
                                 extensions_list=_extensions_list,
                                 ClusterSplitProbContainer=ClusterSplitProbContainer))
        result.merge(acc)
 
    # SCT track segment finding
    if flags.Tracking.doTrackSegmentsSCT:
        acc, ClusterSplitProbContainer = (
            SiSubDetTrackRecoCfg(flags, detector="SCT",
                                 extensions_list=_extensions_list,
                                 ClusterSplitProbContainer=ClusterSplitProbContainer))
        result.merge(acc)
 
    # TRT track segment finding
    if flags.Tracking.doTrackSegmentsTRT:
        result.merge(TRTTrackRecoCfg(flags, extensions_list=_extensions_list))
 
    flags_set = CombinedTrackingPassFlagSets(flags, resetCache=True)
 
    # Pre-processing for TRT phase in cosmics
    if flags.Beam.Type is BeamType.Cosmics:
        flagsCosmics = flags_set[0]
        result.merge(InDetCosmicsTrackRecoPreProcessingCfg(flagsCosmics))
 
    # ------------------------------------------------------------
    #
    # ----------- Main passes for standard reconstruction
    #
    # ------------------------------------------------------------
 
    # Tracks to be ultimately merged in InDetTrackParticle collection
    InputCombinedInDetTracks = []
    # Includes also tracks which end in standalone TrackParticle collections
    InputExtendedInDetTracks = []
    ClusterSplitProbContainer = ""
    StatTrackCollections = []  # To be passed to the InDetRecStatistics alg
    StatTrackTruthCollections = []
    isPrimaryPass = True
 
    printPrimaryConfig(flags)
 
    for current_flags in flags_set:
        printActiveConfig(current_flags)
 
        extension = (
            "" if isPrimaryPass else
            current_flags.Tracking.ActiveConfig.extension)
        _extensions_list.append(extension)
        
        # ---------------------------------------
        # ----   TRTStandalone pass
        # ---------------------------------------
 
        if flags.Tracking.doTRTStandalone and extension == "TRTStandalone":
            result.merge(TRTStandalonePassRecoCfg(
                current_flags,
                InputCombinedInDetTracks=InputCombinedInDetTracks,
                InputExtendedInDetTracks=InputExtendedInDetTracks,
                StatTrackCollections=StatTrackCollections,
                StatTrackTruthCollections=StatTrackTruthCollections))
 
            continue  # Skip rest of config for the TRTStandalone pass
 
        # ---------------------------------------
        # ----   All the passes but TRTStandalone
        # ---------------------------------------
 
        acc, ClusterSplitProbContainer = TrackRecoPassCfg(
            current_flags, extension=extension,
            doTrackingSiPattern=not(isPrimaryPass and
                                    flags.Beam.Type is BeamType.Cosmics),
            InputCombinedInDetTracks=InputCombinedInDetTracks,
            InputExtendedInDetTracks=InputExtendedInDetTracks,
            StatTrackCollections=StatTrackCollections,
            StatTrackTruthCollections=StatTrackTruthCollections,
            ClusterSplitProbContainer=ClusterSplitProbContainer)
        result.merge(acc)
 
        # ---------------------------------------
        # --- A few passes, only after primary pass
        # ---------------------------------------
 
        if isPrimaryPass:
 
            # ---------------------------------------
            # --- TRT Segments
            # ---------------------------------------
 
            if flags.Tracking.doTRTSegments:
                from InDetConfig.TRTSegmentFindingConfig import (
                    TRTSegmentFindingCfg)
                # With RoI-limited Si overlay the removed pileup tracks also mask their
                # hits for back-tracking
                RemovedTracks = TrackOverlayRoIRemovedTracksName(current_flags)
                result.merge(TRTSegmentFindingCfg(
                    current_flags,
                    InputCollections=InputCombinedInDetTracks,
                    ExtraAssociationTracks=[RemovedTracks] if RemovedTracks else None))
 
            # ---------------------------------------
            # --- BackTracking
            # ---------------------------------------
            
            if flags.Tracking.doBackTracking:
                acc, ClusterSplitProbContainer = BackTrackingRecoCfg(
                    current_flags,
                    InputCombinedInDetTracks=InputCombinedInDetTracks,
                    InputExtendedInDetTracks=InputExtendedInDetTracks,
                    StatTrackCollections=StatTrackCollections,
                    StatTrackTruthCollections=StatTrackTruthCollections,
                    ClusterSplitProbContainer=ClusterSplitProbContainer)
                result.merge(acc)
 
            # ---------------------------------------
            # --- PseudoTracking
            # ---------------------------------------
 
            if (flags.Tracking.doTruth and
                (flags.Tracking.doPseudoTracking or
                 flags.Tracking.doIdealPseudoTracking)):
 
                from TrkConfig.TrkTruthTrackAlgsConfig import TruthTrackingCfg
                result.merge(TruthTrackingCfg(current_flags))
 
            isPrimaryPass = False
 
    # ----------------------------------------------------
    # --- Loop over tracking passes is done, final configs
    # ----------------------------------------------------
 
    result.merge(
        TrackFinalCfg(flags,
                      InputCombinedInDetTracks=InputCombinedInDetTracks,
                      StatTrackCollections=StatTrackCollections,
                      StatTrackTruthCollections=StatTrackTruthCollections))
 
    if (flags.Tracking.doPseudoTracking or
        flags.Tracking.doIdealPseudoTracking):
        result.merge(PseudoTrackFinalCfg(flags))
 
    if flags.Tracking.doTIDE_AmbiTrackMonitoring:
        result.merge(ObserverTrackFinalCfg(flags))
 
    if flags.Tracking.doStoreTrackSeeds:
        result.merge(TrackSeedsFinalCfg(flags))
 
    if flags.Tracking.doStoreSiSPSeededTracks:
        result.merge(SiSPSeededTracksFinalCfg(flags))
 
    # ---------------------------------------
    # --- Primary vertexing
    # ---------------------------------------
 
    if flags.Tracking.doVertexFinding:
        from InDetConfig.InDetPriVxFinderConfig import primaryVertexFindingCfg
        result.merge(primaryVertexFindingCfg(flags))
 
    if flags.Tracking.doStats:
        result.merge(InDetStatsCfg(
            flags_set[0], # Use cuts from primary pass
            StatTrackCollections=StatTrackCollections,
            StatTrackTruthCollections=StatTrackTruthCollections))
 
    # ---------------------------------------
    # --- Extra optional decorations
    # ---------------------------------------
 
    if flags.Tracking.doV0Finder:
        from InDetConfig.InDetV0FinderConfig import InDetV0FinderCfg
        result.merge(InDetV0FinderCfg(flags))
 
    if (flags.Tracking.writeExtendedSi_PRDInfo or
        flags.Tracking.writeExtendedTRT_PRDInfo):
        result.merge(ExtendedPRDInfoCfg(flags))
 
    # output
    from InDetConfig.InDetTrackOutputConfig import InDetTrackRecoOutputCfg
    result.merge(InDetTrackRecoOutputCfg(flags, _extensions_list))
 
    # Special configuration for HI
    from TrkConfig.TrkConfigFlags import PrimaryPassConfig
    if flags.Tracking.PrimaryPassConfig is PrimaryPassConfig.HeavyIon and \
       flags.Tracking.doLowPt:
        from InDetConfig.InDetHeavyIonSpecialConfig import InDetHeavyIonSpecialCfg
        result.merge(InDetHeavyIonSpecialCfg(flags))
 
    result.printConfig(withDetails=False,
                       summariseProps=False)
    return result
 
# Run with python -m InDetConfig.TrackRecoConfig
# Works with Data RAW (Format.BS), MC RDO, and MC ESD

◆ ObserverTrackFinalCfg()

ObserverTrackFinalCfg ( flags )

Definition at line 652 of file TrackRecoConfig.py.

def ObserverTrackFinalCfg(flags):
    result = ComponentAccumulator()
 
    TrackContainer = "ObservedTracksCollection"
    if flags.Tracking.doTruth:
        from InDetConfig.TrackTruthConfig import InDetTrackTruthCfg
        result.merge(InDetTrackTruthCfg(
            flags,
            Tracks=TrackContainer,
            DetailedTruth=TrackContainer + "DetailedTruth",
            TracksTruth=TrackContainer + "TruthCollection"))
 
    from xAODTrackingCnv.xAODTrackingCnvConfig import (
        ObserverTrackParticleCnvAlgCfg)
    result.merge(ObserverTrackParticleCnvAlgCfg(
        flags,
        AssociationMapName = (
            "PRDtoTrackMapMerge_CombinedInDetTracks")))
 
    return result
 
 

◆ PseudoTrackFinalCfg()

PseudoTrackFinalCfg ( flags )

Definition at line 627 of file TrackRecoConfig.py.

def PseudoTrackFinalCfg(flags):
    result = ComponentAccumulator()
 
    TrackContainer = "InDetPseudoTracks"
    if flags.Tracking.doTruth:
        from InDetConfig.TrackTruthConfig import InDetTrackTruthCfg
        result.merge(InDetTrackTruthCfg(
            flags,
            Tracks=TrackContainer,
            DetailedTruth=TrackContainer + "DetailedTruth",
            TracksTruth=TrackContainer + "TruthCollection"))
 
    from xAODTrackingCnv.xAODTrackingCnvConfig import TrackParticleCnvAlgCfg
    result.merge(TrackParticleCnvAlgCfg(
        flags,
        name="PseudoTrackParticleCnvAlg",
        TrackContainerName=TrackContainer,
        xAODTrackParticlesFromTracksContainerName=(
            "InDetPseudoTrackParticles"),
        AssociationMapName=(
            "PRDtoTrackMapMerge_CombinedInDetTracks")))
 
    return result
 
 

◆ SiDetectorElementStatusCfg()

SiDetectorElementStatusCfg	(		flags,
			suffix = "" )

Definition at line 191 of file TrackRecoConfig.py.

def SiDetectorElementStatusCfg(flags, suffix="") :
    result = ComponentAccumulator()
    if flags.Detector.GeometryITk:
        if flags.Detector.EnableITkPixel:
            from PixelConditionsAlgorithms.ITkPixelConditionsConfig import (
                ITkPixelDetectorElementStatusAlgCfg)
            result.merge(ITkPixelDetectorElementStatusAlgCfg(flags,name=f"ITkPixelDetectorElementStatusAlg{suffix}"))
        if flags.Detector.EnableITkStrip:
            from SCT_ConditionsAlgorithms.ITkStripConditionsAlgorithmsConfig import  (
                ITkStripDetectorElementStatusAlgCfg)
            result.merge(ITkStripDetectorElementStatusAlgCfg(flags,name=f"ITkStripDetectorElementStatusAlg{suffix}"))
    return result
 
 
# Returns CA + ClusterSplitProbContainer

◆ SiSPSeededTracksFinalCfg()

SiSPSeededTracksFinalCfg ( flags )

Definition at line 706 of file TrackRecoConfig.py.

def SiSPSeededTracksFinalCfg(flags):
    result = ComponentAccumulator()
 
    primaryPassExtension = flags.Tracking[f"{flags.Tracking.PrimaryPassConfig.value}Pass"].extension
 
    # get list of extensions requesting track candidates.
    # Add always the Primary Pass.
    listOfExtensionsRequesting = [
        e for e in _extensions_list
        if (e=='' or flags.Tracking[f"{e}Pass"].storeSiSPSeededTracks) ]
 
    for extension in listOfExtensionsRequesting:
        AssociationMapNameKey="PRDtoTrackMapMerge_CombinedInDetTracks"
        if extension=='Disappearing':
            AssociationMapNameKey = "PRDtoTrackMapMerge_DisappearingTracks"
        elif not (extension == primaryPassExtension):
            AssociationMapNameKey = f"InDetPRDtoTrackMap{extension}"
 
        from xAODTrackingCnv.xAODTrackingCnvConfig import (
            TrackParticleCnvAlgNoPIDCfg)
        result.merge(TrackParticleCnvAlgNoPIDCfg(
            flags,
            name = f"SiSPSeededTracks{extension}CnvAlg",
            TrackContainerName = f"SiSPSeeded{extension}Tracks",
            xAODTrackParticlesFromTracksContainerName=(
                f"SiSPSeededTracks{extension}TrackParticles"),
            AssociationMapName=AssociationMapNameKey))
 
    return result
 
 

◆ SiSubDetTrackRecoCfg()

SiSubDetTrackRecoCfg	(	flags,
		detector = "",
		extensions_list = None,
		ClusterSplitProbContainer = "" )

Definition at line 206 of file TrackRecoConfig.py.

                         ClusterSplitProbContainer=""):
    result = ComponentAccumulator()
 
    if extensions_list is None:
        extensions_list = []
 
    flagsDet = flags.cloneAndReplace("Tracking.ActiveConfig",
                                     f"Tracking.{detector}Pass")
    TrackContainer = f"Resolved{detector}Tracks"
    extensions_list.append(flagsDet.Tracking.ActiveConfig.extension)
    printActiveConfig(flagsDet)
 
    from InDetConfig.TrackingSiPatternConfig import TrackingSiPatternCfg
    result.merge(TrackingSiPatternCfg(
        flagsDet,
        InputCollections=[],
        ResolvedTrackCollectionKey=TrackContainer,
        SiSPSeededTrackCollectionKey=f"SiSPSeeded{detector}Tracks",
        ClusterSplitProbContainer=ClusterSplitProbContainer))
 
    ClusterSplitProbContainer = (
        "InDetAmbiguityProcessorSplitProb" +
        flagsDet.Tracking.ActiveConfig.extension)
 
    if flags.Tracking.doTruth:
        from InDetConfig.TrackTruthConfig import InDetTrackTruthCfg
        result.merge(InDetTrackTruthCfg(
            flagsDet,
            Tracks=TrackContainer,
            DetailedTruth=TrackContainer+"DetailedTruth",
            TracksTruth=TrackContainer+"TruthCollection"))
 
    from xAODTrackingCnv.xAODTrackingCnvConfig import (
        TrackParticleCnvAlgPIDCheckCfg)
    result.merge(TrackParticleCnvAlgPIDCheckCfg(
        flagsDet,
        name=TrackContainer+"CnvAlg",
        TrackContainerName=TrackContainer,
        xAODTrackParticlesFromTracksContainerName=(
            f"InDet{detector}TrackParticles")))
 
    return result, ClusterSplitProbContainer
 
 

◆ StoreTrackSeparateContainerCfg()

StoreTrackSeparateContainerCfg	(	flags,
		TrackContainer = "",
		ClusterSplitProbContainer = "" )

Definition at line 312 of file TrackRecoConfig.py.

                                   ClusterSplitProbContainer=""):
    result = ComponentAccumulator()
    # Dummy Merger to fill additional info
    # for PRD-associated pixel tracklets
    # Can also run on all separate collections like R3LargeD0
    # but kept consistent with legacy config
    AssociationMapName = ""
    extension = flags.Tracking.ActiveConfig.extension
    
    # For track overlay: each pass owns its output container; merging of Sig/Bkg is handled earlier if needed
    # Always run the block for Disappearing extension to ensure containers are produced
    if extension == "Disappearing":
        InputTracks = [TrackContainer]
        # For TO, always use DisappearingTracks as the output container for downstream
        TrackContainer = extension + "Tracks"
        MergerOutputTracks = TrackContainer
 
        from TrkConfig.TrkTrackCollectionMergerConfig import (
            TrackCollectionMergerAlgCfg)
        result.merge(TrackCollectionMergerAlgCfg(
            flags,
            name = "TrackCollectionMergerAlgCfg" + extension,
            InputCombinedTracks=InputTracks,
            OutputCombinedTracks=MergerOutputTracks,
            AssociationMapName="PRDtoTrackMap" + TrackContainer))
 
    if flags.Tracking.doTruth:
        from InDetConfig.TrackTruthConfig import InDetTrackTruthCfg
        result.merge(InDetTrackTruthCfg(
            flags,
            Tracks=TrackContainer,
            DetailedTruth=TrackContainer+"DetailedTruth",
            TracksTruth=TrackContainer+"TruthCollection"))
 
    # Need specific handling with TrackParticles for R3LargeD0
    # not to break downstream configs
    xAODTrackParticlesName = (
        "InDetLargeD0TrackParticles" if "LargeD0" in extension else
        "InDet" + extension + "TrackParticles")
 
    from xAODTrackingCnv.xAODTrackingCnvConfig import (
        TrackParticleCnvAlgPIDCheckCfg)
    result.merge(TrackParticleCnvAlgPIDCheckCfg(
        flags,
        name = extension + "TrackParticleCnvAlg",
        TrackContainerName=TrackContainer,
        xAODTrackParticlesFromTracksContainerName=xAODTrackParticlesName,
        ClusterSplitProbabilityName=ClusterSplitProbContainer,
        AssociationMapName=AssociationMapName))
 
    return result, TrackContainer
 
 

◆ TrackFinalCfg()

TrackFinalCfg	(	flags,
		InputCombinedInDetTracks = None,
		StatTrackCollections = None,
		StatTrackTruthCollections = None )

Definition at line 576 of file TrackRecoConfig.py.

                  StatTrackTruthCollections=None):
    result = ComponentAccumulator()
    if InputCombinedInDetTracks is None:
        InputCombinedInDetTracks = []
    if StatTrackCollections is None:
        StatTrackCollections = []
    if StatTrackTruthCollections is None:
        StatTrackTruthCollections = []
 
    TrackContainer = "CombinedInDetTracks"
 
    from TrkConfig.TrkTrackCollectionMergerConfig import (
        TrackCollectionMergerAlgCfg)
    result.merge(TrackCollectionMergerAlgCfg(
        flags,
        InputCombinedTracks=InputCombinedInDetTracks,
        OutputCombinedTracks=TrackContainer,
        AssociationMapName=f"PRDtoTrackMapMerge_{TrackContainer}"))
 
    if flags.Tracking.doTruth:
        from InDetConfig.TrackTruthConfig import InDetTrackTruthCfg
        result.merge(InDetTrackTruthCfg(
            flags,
            Tracks=TrackContainer,
            DetailedTruth=f"{TrackContainer}DetailedTruth",
            TracksTruth=f"{TrackContainer}TruthCollection"))
 
    StatTrackCollections += [TrackContainer]
    StatTrackTruthCollections += [f"{TrackContainer}TruthCollection"]
 
    if flags.Tracking.doSlimming:
        from TrkConfig.TrkTrackSlimmerConfig import TrackSlimmerCfg
        result.merge(TrackSlimmerCfg(
            flags,
            TrackLocation=[TrackContainer]))
 
    if flags.Tracking.perigeeExpression in [
            PerigeeExpression.BeamLine, PerigeeExpression.Origin]:
        from xAODTrackingCnv.xAODTrackingCnvConfig import TrackParticleCnvAlgCfg
        result.merge(TrackParticleCnvAlgCfg(
            flags,
            ClusterSplitProbabilityName=ClusterSplitProbabilityContainerName(
                flags),
            AssociationMapName=f"PRDtoTrackMapMerge_{TrackContainer}"))
 
    return result
 
 

◆ TrackOverlayResolvedTracksName()

TrackOverlayResolvedTracksName ( flags )

Name of the ambiguity-resolved Si track collection of the track overlay primary pass

Definition at line 366 of file TrackRecoConfig.py.

def TrackOverlayResolvedTracksName(flags):
    """Name of the ambiguity-resolved Si track collection of the track overlay primary pass"""
    ResolvedTracks = "ResolvedTracks"
    # save resolved track name for final merged track collection
    if flags.Tracking.ActiveConfig.storeSeparateContainer:
        ResolvedTracks = flags.Overlay.SigPrefix + ResolvedTracks
    return ResolvedTracks
 
 

◆ TrackOverlayRoIRemovedTracksName()

TrackOverlayRoIRemovedTracksName ( flags )

Pileup tracks re-found by the track overlay primary pass inside the RoIs of the
RoI-limited Si overlay. They are not written out, but later passes treat their clusters
as used, as the corresponding pileup tracks do in MC overlay.

Definition at line 375 of file TrackRecoConfig.py.

def TrackOverlayRoIRemovedTracksName(flags):
    """Pileup tracks re-found by the track overlay primary pass inside the RoIs of the
    RoI-limited Si overlay. They are not written out, but later passes treat their clusters
    as used, as the corresponding pileup tracks do in MC overlay."""
    if not (flags.TrackOverlay.isTrackOverlaySeq and flags.TrackOverlay.doRoISiOverlay):
        return None
    return TrackOverlayResolvedTracksName(flags) + "RemovedPileup"
 
 
# Returns CA + ClusterSplitProbContainer

◆ TrackRecoConfigTest()

TrackRecoConfigTest ( flags = None )

Definition at line 1066 of file TrackRecoConfig.py.

def TrackRecoConfigTest(flags=None):
 
    store_config = False
    if flags is None:
        store_config = True
        from AthenaConfiguration.AllConfigFlags import initConfigFlags
        flags = initConfigFlags()
 
        # Disable calo for this test
        from InDetConfig.ConfigurationHelpers import OnlyTrackingPreInclude
        OnlyTrackingPreInclude(flags)
 
        from AthenaConfiguration.TestDefaults import defaultTestFiles, defaultConditionsTags
        flags.Input.Files = defaultTestFiles.RDO_RUN3
        flags.IOVDb.GlobalTag = defaultConditionsTags.RUN3_MC
        flags.Exec.MaxEvents = 1
 
        flags.fillFromArgs()
        flags.lock()
 
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg
    top_acc = MainServicesCfg(flags)
 
    if flags.Input.Format is not Format.BS:
        from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
        top_acc.merge(PoolReadCfg(flags))
 
    if flags.Detector.EnableCalo:
        if flags.Input.Format is Format.BS:
            from CaloRec.CaloRecoConfig import CaloRecoCfg
            top_acc.merge(CaloRecoCfg(flags)) 
        else:
            from CaloRec.CaloTopoClusterConfig import CaloTopoClusterCfg
            top_acc.merge(CaloTopoClusterCfg(flags))
 
    if flags.Input.Format is not Format.BS:
        # TODO find better way to determine RDO vs ESD input?
        if "PixelRDOs" in flags.Input.Collections:
            if "EventInfo" not in flags.Input.Collections:
                from xAODEventInfoCnv.xAODEventInfoCnvConfig import EventInfoCnvAlgCfg
                top_acc.merge(EventInfoCnvAlgCfg(flags))
 
            if flags.Input.isMC:
                from xAODTruthCnv.xAODTruthCnvConfig import GEN_AOD2xAODCfg
                top_acc.merge(GEN_AOD2xAODCfg(flags))
        else:
            if flags.Tracking.doTruth :
                from xAODTruthCnv.RedoTruthLinksConfig import RedoTruthLinksAlgCfg
                top_acc.merge( RedoTruthLinksAlgCfg(flags) )
 
    top_acc.merge(InDetTrackRecoCfg(flags))
 
    if store_config:
        from AthenaCommon.Constants import DEBUG
        top_acc.foreach_component("AthEventSeq/*").OutputLevel = DEBUG
        top_acc.printConfig(withDetails=True, summariseProps=True)
        top_acc.store(open("TrackRecoConfig.pkl", "wb"))
 
    import sys
    if "--norun" not in sys.argv:
        sc = top_acc.run()
        if sc.isFailure():
            sys.exit(-1)
 

◆ TrackRecoPassCfg()

TrackRecoPassCfg	(	flags,
		extension = "",
		doTrackingSiPattern = True,
		InputCombinedInDetTracks = None,
		InputExtendedInDetTracks = None,
		StatTrackCollections = None,
		StatTrackTruthCollections = None,
		ClusterSplitProbContainer = "" )

Definition at line 424 of file TrackRecoConfig.py.

                     ClusterSplitProbContainer=""):
    result = ComponentAccumulator()
    doTrackOverlay = flags.TrackOverlay.isTrackOverlaySeq
    if InputCombinedInDetTracks is None:
        InputCombinedInDetTracks = []
    if InputExtendedInDetTracks is None:
        InputExtendedInDetTracks = []
    if StatTrackCollections is None:
        StatTrackCollections = []
    if StatTrackTruthCollections is None:
        StatTrackTruthCollections = []
 
    ResolvedTracks = "Resolved" + extension + "Tracks"
    # for track overlay, save resolved track name for final merged track collection
    # Only add Sig_ prefix for primary pass (where we merge signal+pileup)
    # Non-primary passes process signal only, so no prefix needed
    if doTrackOverlay and extension == '':
        ResolvedTracks = TrackOverlayResolvedTracksName(flags)
 
    # Tweak to match old config key
    if "LargeD0" in extension:
        ResolvedTracks = "ResolvedLargeD0Tracks"
 
    # ---------------------------------------
    # --- Si pattern, if not done in the cosmic preprocessing
    # ---------------------------------------
 
    if doTrackingSiPattern:
        SiSPSeededTracks = "SiSPSeeded" + extension + "Tracks"
        
        from InDetConfig.TrackingSiPatternConfig import TrackingSiPatternCfg
        result.merge(TrackingSiPatternCfg(
            flags,
            InputCollections=InputExtendedInDetTracks,
            ResolvedTrackCollectionKey=ResolvedTracks,
            SiSPSeededTrackCollectionKey=SiSPSeededTracks,
            ClusterSplitProbContainer=ClusterSplitProbContainer))
        StatTrackCollections += [SiSPSeededTracks, ResolvedTracks]
        StatTrackTruthCollections += [SiSPSeededTracks+"TruthCollection",
                                      ResolvedTracks+"TruthCollection"]
 
    # ---------------------------------------
    # --- For track overlay main pass: merge signal Si tracks with pileup tracks BEFORE TRT extension
    # --- TRT extension needs to see ALL Si tracks (signal + pileup) to properly
    # --- associate TRT hits from the overlaid TRT_RDOs with both signal and pileup tracks
    # ---------------------------------------
    
    TrackContainer = ResolvedTracks
    
    # Track which Si tracks to use for TRT extension
    SiTracksForTRTExtension = ResolvedTracks
    
    # For track overlay: Merge signal + pileup Si tracks BEFORE TRT extension
    # First add TrackSummary to pileup tracks
    # Then merge and run TRT extension on combined collection
    if doTrackOverlay and extension == '':
        # Add TrackSummary to all pileup tracks
        from InDetConfig.AddTrackSummaryAlgConfig import AddTrackSummaryAlgCfg
        result.merge(AddTrackSummaryAlgCfg(
           flags,
           name="AddSummaryToPileupTracks",
           InputTrackCollection="Bkg_CombinedInDetTracks",
           OutputTrackCollection="Bkg_CombinedInDetTracksWithSummary",
        ))
        # Drop re-finds pileup particles as they are already counted in Bkg_CombinedInDetTracks
        SignalTracksForMerge = ResolvedTracks
        if flags.TrackOverlay.doRoISiOverlay:
            from TrackOverlayRec.TrackOverlayRoIConfig import (
                TrackOverlaySignalTrackFilterAlgCfg)
            SignalTracksForMerge = ResolvedTracks + "Filtered"
            RemovedTracks = TrackOverlayRoIRemovedTracksName(flags)
            result.merge(TrackOverlaySignalTrackFilterAlgCfg(
                flags,
                InputTracks=ResolvedTracks,
                OutputTracks=SignalTracksForMerge,
                RemovedTracks=RemovedTracks))
            # later Si passes treat their clusters as used
            InputExtendedInDetTracks += [RemovedTracks]
        # Merge signal + pileup Si tracks
        from TrkConfig.TrkTrackCollectionMergerConfig import TrackCollectionMergerAlgCfg
        result.merge(TrackCollectionMergerAlgCfg(
            flags,
            name="MergeSignalPileupBeforeTRTExtension",
            InputCombinedTracks=[SignalTracksForMerge, "Bkg_CombinedInDetTracksWithSummary"],
            OutputCombinedTracks="MergedSiTracks",
            AssociationMapName="PRDtoTrackMapMergedSiTracks"))
        
        # Use merged Si tracks as input for TRT extension
        SiTracksForTRTExtension = "MergedSiTracks"
        TrackContainer = "MergedSiTracks"
        
    elif (doTrackOverlay and
          flags.Tracking.ActiveConfig.storeSeparateContainer):
        #not doing the merge in non-primary passes, so the pass’s own output container
        TrackContainer = ResolvedTracks
 
    # ---------------------------------------
    # --- TRT extension
    # ---------------------------------------
 
    # For track overlay non-primary passes: process signal tracks normally
    # Primary pass (extension="") merges signal+pileup Si tracks before TRT extension (done above)
 
    if flags.Tracking.ActiveConfig.useTRTExtension:
        ExtendedTracks = "Extended" + extension + "Tracks"
        # Tweaks to match old config key
        if extension == "Disappearing":
            ExtendedTracks = "ExtendedTracksDisappearing"
        elif "LargeD0" in extension:
            ExtendedTracks = "ExtendedLargeD0Tracks"
            # In track overlay, LargeD0 pass only processes signal - no Sig_ prefix needed
        ExtendedTracksMap = "ExtendedTracksMap" + extension
        from InDetConfig.TRTExtensionConfig import NewTrackingTRTExtensionCfg
        result.merge(NewTrackingTRTExtensionCfg(
            flags,
            SiTrackCollection=SiTracksForTRTExtension,
            ExtendedTrackCollection=ExtendedTracks,
            ExtendedTracksMap=ExtendedTracksMap))
 
        TrackContainer = ExtendedTracks
        if doTrackOverlay and "LargeD0" in extension:
            TrackContainer = "ExtendedLargeD0Tracks"
        StatTrackCollections += [ExtendedTracks]
        StatTrackTruthCollections += [ExtendedTracks+"TruthCollection"]
 
    # ---------------------------------------
    # --- Store separate container if needed
    # ---------------------------------------
 
    if flags.Tracking.ActiveConfig.storeSeparateContainer:
        acc, TrackContainer = StoreTrackSeparateContainerCfg(
            flags,
            TrackContainer=TrackContainer,
            ClusterSplitProbContainer=ClusterSplitProbContainer)
        result.merge(acc)
 
    else:  # Do not store separate track container
        ClusterSplitProbContainer = (
            "InDetAmbiguityProcessorSplitProb" +
            flags.Tracking.ActiveConfig.extension)
        InputCombinedInDetTracks += [TrackContainer]
 
    InputExtendedInDetTracks += [TrackContainer]
    return result, ClusterSplitProbContainer
 
 

◆ TrackSeedsFinalCfg()

TrackSeedsFinalCfg ( flags )

Definition at line 674 of file TrackRecoConfig.py.

def TrackSeedsFinalCfg(flags):
    result = ComponentAccumulator()
 
    # get list of extensions requesting track seeds.
    # Add always the Primary Pass.
    listOfExtensionsRequesting = [
        e for e in _extensions_list
        if (e == '' or flags.Tracking[f"{e}Pass"].storeTrackSeeds) ]
 
    for extension in listOfExtensionsRequesting:
        TrackContainer = "SiSPSeedSegments"+extension
 
        if flags.Tracking.doTruth:
            from InDetConfig.TrackTruthConfig import InDetTrackTruthCfg
            result.merge(InDetTrackTruthCfg(
                flags,
                Tracks=TrackContainer,
                DetailedTruth=f"{TrackContainer}DetailedTruth",
                TracksTruth=f"{TrackContainer}TruthCollection"))
 
        from xAODTrackingCnv.xAODTrackingCnvConfig import (
            TrackParticleCnvAlgNoPIDCfg)
        result.merge(TrackParticleCnvAlgNoPIDCfg(
            flags,
            name=f"{TrackContainer}CnvAlg",
            TrackContainerName=TrackContainer,
            xAODTrackParticlesFromTracksContainerName=(
                f"{TrackContainer}TrackParticles")))
 
    return result
 
 

◆ TRTStandalonePassRecoCfg()

TRTStandalonePassRecoCfg	(	flags,
		InputCombinedInDetTracks = None,
		InputExtendedInDetTracks = None,
		StatTrackCollections = None,
		StatTrackTruthCollections = None )

Definition at line 273 of file TrackRecoConfig.py.

                             StatTrackTruthCollections=None):
    result = ComponentAccumulator()
 
    if InputCombinedInDetTracks is None:
        InputCombinedInDetTracks = []
    if InputExtendedInDetTracks is None:
        InputExtendedInDetTracks = []
    if StatTrackCollections is None:
        StatTrackCollections = []
    if StatTrackTruthCollections is None:
        StatTrackTruthCollections = []
 
    from InDetConfig.TRTStandaloneConfig import TRTStandaloneCfg
    result.merge(TRTStandaloneCfg(flags,
                                  InputCollections=InputCombinedInDetTracks))
 
    TRTTrackContainer = "TRTStandaloneTracks"
    InputCombinedInDetTracks += [TRTTrackContainer]
    InputExtendedInDetTracks += [TRTTrackContainer]
    StatTrackCollections += [TRTTrackContainer]
    StatTrackTruthCollections += [TRTTrackContainer+"TruthCollection"]
 
    if flags.Tracking.doTrackSegmentsTRT:
        from xAODTrackingCnv.xAODTrackingCnvConfig import (
            TrackParticleCnvAlgNoPIDCfg)
        result.merge(TrackParticleCnvAlgNoPIDCfg(
            flags, TRTTrackContainer+"CnvAlg",
            TrackContainerName=TRTTrackContainer,
            xAODTrackParticlesFromTracksContainerName=(
                "InDetTRTTrackParticles")))
 
    return result
 
 
# Return CA + TrackContainer

◆ TRTTrackRecoCfg()

TRTTrackRecoCfg	(		flags,
			extensions_list = None )

Definition at line 252 of file TrackRecoConfig.py.

def TRTTrackRecoCfg(flags, extensions_list=None):
    result = ComponentAccumulator()
 
    if extensions_list is None:
        extensions_list = []
 
    flagsTRT = flags.cloneAndReplace("Tracking.ActiveConfig",
                                     "Tracking.TRTPass")
    extensions_list.append(flagsTRT.Tracking.ActiveConfig.extension)
    printActiveConfig(flagsTRT)
 
    from InDetConfig.TRTSegmentFindingConfig import (
        TRTSegmentFinding_TrackSegments_Cfg)
    result.merge(TRTSegmentFinding_TrackSegments_Cfg(flagsTRT))
 
    from InDetConfig.TRTStandaloneConfig import TRT_TrackSegment_Cfg
    result.merge(TRT_TrackSegment_Cfg(flagsTRT))
 
    return result
 
 

Variable Documentation

◆ _extensions_list

list python.TrackRecoConfig._extensions_list = []

protected

Definition at line 9 of file TrackRecoConfig.py.

◆ _flags_set

list python.TrackRecoConfig._flags_set = []