python.HLT.Tau.TauMenuSequences Namespace Reference

Functions
MenuSequence	tauCaloMVASequenceGenCfg (AthConfigFlags flags, bool is_probe_leg=False)
MenuSequence	tauCaloHitsSequenceGenCfg (AthConfigFlags orig_flags, str seq_name, str precision_seq_name, tuple[str, float]|None hitz_config=None, bool is_probe_leg=False)
MenuSequence	tauFTFCoreSequenceGenCfg (AthConfigFlags orig_flags, str|None calohits_seq_name=None, bool do_lrt=False, bool is_probe_leg=False)
	tauFTFIsoSequenceGenCfg (AthConfigFlags orig_flags, str|None calohits_seq_name=None, bool is_probe_leg=False)
MenuSequence	tauPrecTrackSequenceGenCfg (AthConfigFlags orig_flags, str|None calohits_seq_name=None, bool do_lrt=False, bool is_probe_leg=False)
MenuSequence	tauPrecisionSequenceGenCfg (AthConfigFlags orig_flags, str seq_name, str|None calohits_seq_name=None, str|None output_name=None, bool do_lrt=False, bool is_probe_leg=False)

Variables
	log = logging.getLogger(__name__)

Function Documentation

tauCaloHitsSequenceGenCfg()

MenuSequence tauCaloHitsSequenceGenCfg	(	AthConfigFlags	orig_flags,
		str	seq_name,
		str	precision_seq_name,
		tuple[str, float] | None	hitz_config = None,
		bool	is_probe_leg = False )

Calorimeter+Hits RoI updating and preselection hypothesis

Definition at line 87 of file TauMenuSequences.py.

def tauCaloHitsSequenceGenCfg(orig_flags: AthConfigFlags, seq_name: str, precision_seq_name: str, hitz_config: tuple[str, float] | None = None, is_probe_leg: bool = False) -> MenuSequence:
    '''Calorimeter+Hits RoI updating and preselection hypothesis'''
 
    tracking_cfg = f'tauHits{seq_name}'
    next_tracking_cfg = f'tauCore{seq_name}'
 
    flags = getFlagsForActiveConfig(orig_flags, tracking_cfg, log)
 
    # Create new RoIs from 'UpdatedCaloRoI', resized to the HitZ RoI before running the HitZ and other inference algorithms
    newRoITool = CompFactory.ViewCreatorFetchFromViewROITool(
        RoisWriteHandleKey=recordable(flags.Tracking.ActiveConfig.roi),
        InViewRoIs='UpdatedCaloRoI',
        doResize=True,
        RoIEtaWidth=flags.Tracking.ActiveConfig.etaHalfWidth,
        RoIPhiWidth=flags.Tracking.ActiveConfig.phiHalfWidth,
        RoIZedWidth=flags.Tracking.ActiveConfig.zedHalfWidth,
    )
 
 
    # Reconstruction sequence CA (parOR), executting all reco algorithms within the View (from the RoI)
    # in parallel whenever possible, according to their data dependencies.
    # Create the EventViews from the resized RoIs, based on the 'UpdatedCaloRoI' created in the CaloMVA step
    recoAcc = InViewRecoCA(
        name=f'tauCaloHits_{seq_name}',
        RoITool=newRoITool,
        ViewFallThrough=True,
        RequireParentView=True,
        mergeUsingFeature=True,
        isProbe=is_probe_leg
    )
    RoIs = recoAcc.inputMaker().InViewRoIs
 
 
    # VDV with all the required collections/objects in the View
    # (the VDV checks are disabled unless running with -l DEBUG)
    recoAcc.addRecoAlgo(CompFactory.AthViews.ViewDataVerifier(
        name=f'{recoAcc.name}RecoVDV',
        DataObjects={
            ('TrigRoiDescriptorCollection', f'StoreGateSvc+{RoIs}'),
            ('xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
            ('xAOD::TauJetContainer', 'StoreGateSvc+HLT_TrigTauRecMerged_CaloMVAOnly'),
            ('xAOD::TauTrackContainer', 'StoreGateSvc+HLT_tautrack_dummy'),
        }
    ))
 
 
    # Reconstruction tools/algorithms:
 
    # Construct ID space-points in the View
    from TrigInDetConfig.TrigInDetConfig import trigInDetSPFormationCfg
    recoAcc.mergeReco(trigInDetSPFormationCfg(flags, roisKey=RoIs, signatureName=tracking_cfg))
 
    # Create the high-level xAOD::TrackParticleValidation container from the SPs
    if flags.Detector.GeometryITk:
        from InDetConfig.InDetPrepRawDataToxAODConfig import ITkPixelPrepDataToxAODCfg as PixelPrepDataToxAODCfg
        pixel_cluster_container = 'ITkTrigPixelClusters'
    else:
        from InDetConfig.InDetPrepRawDataToxAODConfig import InDetPixelPrepDataToxAODCfg as PixelPrepDataToxAODCfg
        pixel_cluster_container = 'PixelTrigClusters'
 
    recoAcc.mergeReco(PixelPrepDataToxAODCfg(
        flags,
        SiClusterContainer=pixel_cluster_container, # From the FTF SP reco
        OutputClusterContainer='PixelClusters', # Output xAOD::TrackParticleValidation container
        WriteNNinformation=False,
        UseTruthInfo=False,
    ))
 
    # Get the BeamSpot from the conditions database
    from BeamSpotConditions.BeamSpotConditionsConfig import BeamSpotCondAlgCfg
    recoAcc.mergeReco(BeamSpotCondAlgCfg(flags))
 
    # Construct the calo+hits TauJet, and run the HitZ inference algorithms
    from TrigTauRec.TrigTauRecConfig import trigTauRecMergedCaloHitsCfg
    from .TauConfigurationTools import getHitZAlgs, getCaloHitsPreselAlgs
    recoAcc.mergeReco(trigTauRecMergedCaloHitsCfg(
        flags,
        seq_name,
        hitz_algs=getHitZAlgs(flags, f'{precision_seq_name}_{seq_name}', precision_seq_name),
        presel_algs=getCaloHitsPreselAlgs(flags, f'{precision_seq_name}_{seq_name}', precision_seq_name),
        input_rois=RoIs,
    ))
 
 
    if hitz_config:
        # Create new RoIs with an updated position, based on the central axis of the clusters
        from TrigTauRec.TrigTauRoIToolsConfig import tauHitZRoiUpdaterCfg
        recoAcc.mergeReco(tauHitZRoiUpdaterCfg(
            flags, 
            inputRoIs=RoIs, 
            outputRoIs=f'UpdatedCaloHits{seq_name}RoI',
            taus='HLT_TrigTauRecMerged_CaloHits',
            hitz_alg=hitz_config[0],
            max_pt=1000e3,
            max_sigma=hitz_config[1],
            tracking_cfg=next_tracking_cfg,
        ))
 
 
    # Selection sequence CA (seqAND), executing the recoAcc view creation alg. first,
    # the reco CA (with all the reco algs) second, and the Hypo alg. at last
    selAcc = SelectionCA(f'tauCaloHits_{seq_name}', isProbe=is_probe_leg)
    selAcc.mergeReco(recoAcc)
 
 
    # Hypothesis:
    # The Hypotools in the Hypo algorithm will execute the BRT-calibrated Tau pT cut
    selAcc.addHypoAlgo(CompFactory.TrigTauJetHypoAlg(f'TauCaloHitsHypoAlg_{seq_name}', TauJetsKey='HLT_TrigTauRecMerged_CaloHits'))
 
 
    # Menu sequence, connecting everything internally for the step, and configuring the tools for the Hypo alg.
    # based on the partDict for each chain tau leg
    from TrigTauHypo.TrigTauHypoTool import TrigTauCaloHitsHypoToolFromDict
    menuSeq = MenuSequence(flags, selAcc, HypoToolGen=TrigTauCaloHitsHypoToolFromDict)
 
    return menuSeq
 
 
 
#================================================================
# 1st FTF step: FTFCore / FTFLRT
#================================================================
 
@AccumulatorCache

tauCaloMVASequenceGenCfg()

MenuSequence tauCaloMVASequenceGenCfg	(	AthConfigFlags	flags,
		bool	is_probe_leg = False )

Calorimeter-only reconstruction and hypothesis (BRT-calibrated pT cut)

Definition at line 22 of file TauMenuSequences.py.

def tauCaloMVASequenceGenCfg(flags: AthConfigFlags, is_probe_leg: bool = False) -> MenuSequence:
    '''Calorimeter-only reconstruction and hypothesis (BRT-calibrated pT cut)'''
 
    # Reconstruction sequence CA (parOR), executting all reco algorithms within the View (from the RoI)
    # in parallel whenever possible, according to their data dependencies.
    # Create the EventViews based on the HLTSeeding RoIs (from the input L1 TOBs)
    recoAcc = InViewRecoCA(name='tauCaloMVA', InViewRoIs='CaloMVA_RoIs', isProbe=is_probe_leg)
    RoIs = recoAcc.inputMaker().InViewRoIs
 
 
    # VDV with all the required collections/objects in the View
    # (the VDV checks are disabled unless running with -l DEBUG)
    Objects={
            ('TrigRoiDescriptorCollection', f'StoreGateSvc+{RoIs}'),
            ('xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
            ('SG::AuxElement', 'StoreGateSvc+EventInfo.actualInteractionsPerCrossing'),
            ('SG::AuxElement', 'StoreGateSvc+EventInfo.averageInteractionsPerCrossing'),
            ('CaloBCIDAverage', 'StoreGateSvc+CaloBCIDAverage')
    }
    if ( not flags.Input.isMC ):
        Objects.add( ('LArDeadOTXFromSC' , 'StoreGateSvc+DeadOTXFromSC' ) )
    recoAcc.addRecoAlgo(CompFactory.AthViews.ViewDataVerifier(
        name=f'{recoAcc.name}RecoVDV',
        DataObjects=Objects
    ))
 
 
    # Reconstruction tools/algorithms:
 
    # Topo-clustering
    from TrigCaloRec.TrigCaloRecConfig import tauTopoClusteringCfg
    recoAcc.mergeReco(tauTopoClusteringCfg(flags, RoIs=RoIs))
 
    # Create new RoIs with an updated position, based on the central axis of the clusters
    from TrigTauRec.TrigTauRoIToolsConfig import tauCaloRoiUpdaterCfg
    recoAcc.mergeReco(tauCaloRoiUpdaterCfg(flags, inputRoIs=RoIs, clusters='HLT_TopoCaloClustersLC'))
 
    # Construct the calo-only TauJet (with BRT calibration)
    from TrigTauRec.TrigTauRecConfig import trigTauRecMergedCaloMVACfg
    recoAcc.mergeReco(trigTauRecMergedCaloMVACfg(flags))
 
    # Selection sequence CA (seqAND), executing the recoAcc view creation alg. first,
    # the reco CA (with all the reco algs) second, and the Hypo alg. at last
    selAcc = SelectionCA('tauCalo', isProbe=is_probe_leg)
    selAcc.mergeReco(recoAcc)
 
 
    # Hypothesis:
    # The Hypotools in the Hypo algorithm will execute the BRT-calibrated Tau pT cut
    selAcc.addHypoAlgo(CompFactory.TrigTauJetHypoAlg('TauCaloMVAHypoAlg', TauJetsKey='HLT_TrigTauRecMerged_CaloMVAOnly'))
 
 
    # Menu sequence, connecting everything internally for the step, and configuring the tools for the Hypo alg.
    # based on the partDict for each chain tau leg
    from TrigTauHypo.TrigTauHypoTool import TrigTauCaloMVAHypoToolFromDict
    menuSeq = MenuSequence(flags, selAcc, HypoToolGen=TrigTauCaloMVAHypoToolFromDict)
 
    return menuSeq
 
 
 
#================================================================
# Calo + Hits step: HitZ + Calo+Hits preselection
#================================================================
@AccumulatorCache

tauFTFCoreSequenceGenCfg()

MenuSequence tauFTFCoreSequenceGenCfg	(	AthConfigFlags	orig_flags,
		str | None	calohits_seq_name = None,
		bool	do_lrt = False,
		bool	is_probe_leg = False )

1st FTF step sequence, for both the tauCore(Hits) and tauLRT RoIs

Definition at line 211 of file TauMenuSequences.py.

def tauFTFCoreSequenceGenCfg(orig_flags: AthConfigFlags, calohits_seq_name: str | None = None, do_lrt: bool = False, is_probe_leg: bool = False) -> MenuSequence:
    '''1st FTF step sequence, for both the tauCore(Hits) and tauLRT RoIs'''
 
    if do_lrt:
        name = 'LRT'
        tracking_cfg = next_tracking_cfg = 'tauLRT'
        output_rois = 'UpdatedTrackLRTRoI'
    else:
        name = 'Core'
        tracking_cfg = 'tauCore'
        next_tracking_cfg = 'tauIso'
        output_rois = 'UpdatedTrackRoI'
 
    if calohits_seq_name:
        tracking_cfg += calohits_seq_name
        next_tracking_cfg += calohits_seq_name
 
    # Retrieve tracking configuration
    flags = getFlagsForActiveConfig(orig_flags, tracking_cfg, log)
 
    # Source-dependent configuration
    if calohits_seq_name:
        name += f'_{calohits_seq_name}'
        input_rois = f'UpdatedCaloHits{calohits_seq_name}RoI'
        output_rois = f'{output_rois[:-3]}{calohits_seq_name}RoI'
    else:
        input_rois = 'UpdatedCaloRoI'
 
 
    # Create new RoIs from 'UpdatedCaloRoI' or 'UpdatedCaloHitsRoI, resized to 'tauCore/LRT' 
    # before running the FTF algorithms.
    newRoITool = CompFactory.ViewCreatorFetchFromViewROITool(
        RoisWriteHandleKey=recordable(flags.Tracking.ActiveConfig.roi),
        InViewRoIs=input_rois,
        doResize=not calohits_seq_name, # Do not resize if we're using the CaloHits RoI, which is already resized to the correct size for the FTF step
        RoIEtaWidth=flags.Tracking.ActiveConfig.etaHalfWidth,
        RoIPhiWidth=flags.Tracking.ActiveConfig.phiHalfWidth,
        RoIZedWidth=flags.Tracking.ActiveConfig.zedHalfWidth,
    )
 
 
    # Reconstruction sequence CA (parOR), executting all reco algorithms within the View (from the RoI)
    # in parallel whenever possible, according to their data dependencies.
    # Create the EventViews from the resized RoIs, based on the upstream RoI created in the CaloMVA or CaloHits steps
    recoAcc = InViewRecoCA(
        f'tauFastTrack{name}',
        RoITool=newRoITool,
        ViewFallThrough=True,
        RequireParentView=True,
        mergeUsingFeature=True,
        isProbe=is_probe_leg
    )
    RoIs = recoAcc.inputMaker().InViewRoIs
 
 
    # VDV with all the required collections/objects in the View
    # (the VDV checks are disabled unless running with -l DEBUG)
    recoAcc.addRecoAlgo(CompFactory.AthViews.ViewDataVerifier(
        name=f'{recoAcc.name}RecoVDV',
        DataObjects={
            ('TrigRoiDescriptorCollection', f'StoreGateSvc+{RoIs}'),
        }
    ))
 
    
    # Reconstruction tools/algorithms:
 
    # Fast Track Finder (FTF) sequence (the main point of this step)
    from TrigInDetConfig.TrigInDetConfig import trigInDetFastTrackingCfg
    recoAcc.mergeReco(trigInDetFastTrackingCfg(flags, roisKey=RoIs, signatureName=tracking_cfg))
 
    # Create new RoIs for the next tracking steps (FTFIso and PrecTrack), based on the found tracks
    TrackCollection = flags.Tracking.ActiveConfig.tracks_FTF
    
 
    from TrigTauRec.TrigTauRoIToolsConfig import tauTrackRoiUpdaterCfg
    recoAcc.mergeReco(tauTrackRoiUpdaterCfg(
        flags,
        inputRoIs=RoIs,
        outputRoIs=output_rois,
        tracks=TrackCollection,
 
        # Only pass the next tracking config if it's different from the current one (ActiveConfig),
        tracking_cfg=next_tracking_cfg if next_tracking_cfg != tracking_cfg else None,
    ))
 
 
    # Selection sequence CA (seqAND), executing the recoAcc view creation alg. first,
    # the reco CA (with all the reco algs) second, and the Hypo alg. at last
    selAcc = SelectionCA(f'tauFTF{name}', isProbe=is_probe_leg)
    selAcc.mergeReco(recoAcc)
 
 
    # Hypothesis:
    # The hypothesis algorithm/tool does not perform any action (online monitoring of tracks only)
    selAcc.addHypoAlgo(CompFactory.TrigTauTrackingHypoAlg(
        f'TauFastTrackHypoAlg_PassBy{name}',
        RoIKey='UpdatedTrackLRTRoI' if do_lrt else '',
        TracksKey=TrackCollection,
    ))
 
 
    # Menu sequence, connecting everything internally for the step, and configuring the tools for the Hypo alg.
    # based on the partDict for each chain tau leg
    from TrigTauHypo.TrigTauHypoTool import TrigTauTrackingHypoToolFromDict
    menuSeq = MenuSequence(flags, selAcc, HypoToolGen=TrigTauTrackingHypoToolFromDict)
 
    return menuSeq
 
 
 
#================================================================
# 2nd FTF step: FTFIso
#================================================================
 
@AccumulatorCache

tauFTFIsoSequenceGenCfg()

tauFTFIsoSequenceGenCfg	(	AthConfigFlags	orig_flags,
		str | None	calohits_seq_name = None,
		bool	is_probe_leg = False )

2nd FTF step sequence, for the tauIso RoI

Definition at line 327 of file TauMenuSequences.py.

def tauFTFIsoSequenceGenCfg(orig_flags: AthConfigFlags, calohits_seq_name: str | None = None, is_probe_leg: bool = False):
    '''2nd FTF step sequence, for the tauIso RoI'''
 
    name = 'Iso'
 
    # Retrieve tracking configuration
    previous_tracking_cfg = 'tauCore'
    tracking_cfg = 'tauIso'
    if calohits_seq_name:
        tracking_cfg += calohits_seq_name
        previous_tracking_cfg += calohits_seq_name
 
    flags = getFlagsForActiveConfig(orig_flags, tracking_cfg, log)
 
 
    # Source-dependent configuration
    if calohits_seq_name:
        name += f'_{calohits_seq_name}'
        input_rois = f'UpdatedTrack{calohits_seq_name}RoI'
    else:
        input_rois = 'UpdatedTrackRoI'
 
 
    # Create new RoIs from , resized to 'tauCore/LRT' before running the FTF algorithms
    newRoITool = CompFactory.ViewCreatorFetchFromViewROITool(
        RoisWriteHandleKey=recordable(flags.Tracking.ActiveConfig.roi),
        InViewRoIs=input_rois,
    )
 
 
    # Reconstruction sequence CA (parOR), executting all reco algorithms within the View (from the RoI)
    # in parallel whenever possible, according to their data dependencies.
    # Create the EventViews based on the RoIs created in the previous step
    recoAcc = InViewRecoCA(
        f'tauFastTrack{name}', 
        RoITool=newRoITool, 
        RequireParentView=True, 
        ViewFallThrough=True, 
        isProbe=is_probe_leg
    )
    RoIs = recoAcc.inputMaker().InViewRoIs
 
 
    # VDV with all the required collections/objects in the View
    # (the VDV checks are disabled unless running with -l DEBUG)
    previous_step_flags = getFlagsForActiveConfig(orig_flags, previous_tracking_cfg, log)
    recoAcc.addRecoAlgo(CompFactory.AthViews.ViewDataVerifier(
        name=f'{recoAcc.name}RecoVDV',
        DataObjects={
            ('TrigRoiDescriptorCollection', f'StoreGateSvc+{RoIs}'),
            ('xAOD::TrackParticleContainer', f'StoreGateSvc+{previous_step_flags.Tracking.ActiveConfig.tracks_FTF}'),
        }
    ))
 
    
    # Reconstruction tools/algorithms:
 
    # Fast Track Finder (FTF) sequence (the main point of this step)
    from TrigInDetConfig.TrigInDetConfig import trigInDetFastTrackingCfg
    recoAcc.mergeReco(trigInDetFastTrackingCfg(flags, roisKey=RoIs, signatureName=tracking_cfg))
 
    # Selection sequence CA (seqAND), executing the recoAcc view creation alg. first,
    # the reco CA (with all the reco algs) second, and the Hypo alg. at last
    selAcc = SelectionCA(f'tauFTF{name}', isProbe=is_probe_leg)
    selAcc.mergeReco(recoAcc)
 
 
    # Hypothesis:
    # The hypothesis algorithm/tool does not perform any action (debug logging of number of tracks only)
    selAcc.addHypoAlgo(CompFactory.TrigTauTrackingHypoAlg(
        f'TauFastTrackHypoAlg_PassBy{name}',
        TracksKey=flags.Tracking.ActiveConfig.tracks_FTF,
    ))
 
 
    # Menu sequence, connecting everything internally for the step, and configuring the tools for the Hypo alg.
    # based on the partDict for each chain tau leg
    from TrigTauHypo.TrigTauHypoTool import TrigTauTrackingHypoToolFromDict
    menuSeq = MenuSequence(flags, selAcc, HypoToolGen=TrigTauTrackingHypoToolFromDict)
 
    return menuSeq
 
 
 
#================================================================
# Precision Tracking step
#================================================================
 
@AccumulatorCache

tauPrecisionSequenceGenCfg()

MenuSequence tauPrecisionSequenceGenCfg	(	AthConfigFlags	orig_flags,
		str	seq_name,
		str | None	calohits_seq_name = None,
		str | None	output_name = None,
		bool	do_lrt = False,
		bool	is_probe_leg = False )

Precision Tau step sequence, for all ID and reconstruction settings

Definition at line 501 of file TauMenuSequences.py.

def tauPrecisionSequenceGenCfg(orig_flags: AthConfigFlags, seq_name: str, calohits_seq_name: str | None = None, output_name: str | None = None, do_lrt: bool = False, is_probe_leg: bool = False) -> MenuSequence:
    '''Precision Tau step sequence, for all ID and reconstruction settings'''
 
    orig_seq_name = seq_name
    if output_name is None: output_name = orig_seq_name
 
    if do_lrt:
        tracking_cfg = 'tauLRT'
        input_rois = 'tauFastTrackLRT'
    else:
        tracking_cfg = 'tauIso'
        input_rois = 'tauFastTrackIso'
 
    if calohits_seq_name:
        seq_name += f'_{calohits_seq_name}'
        tracking_cfg += calohits_seq_name
        input_rois += f'_{calohits_seq_name}'
        input_taus = 'HLT_TrigTauRecMerged_CaloHits'
        input_tau_tracks = 'HLT_tautrack_CaloHits_dummy'
    else:
        input_taus = 'HLT_TrigTauRecMerged_CaloMVAOnly'
        input_tau_tracks = 'HLT_tautrack_dummy'
 
    # Retrieve tracking configuration
    flags = getFlagsForActiveConfig(orig_flags, tracking_cfg, log)
 
 
    # Get the list of TauIDs to execute
    from TriggerMenuMT.HLT.Tau.TauConfigurationTools import getPrecisionSequenceTauIDs
    tau_ids = getPrecisionSequenceTauIDs(flags, seq_name, orig_seq_name)
 
 
    # Get the list of the decorated variables from the previous step taus to be copied to the new precision taus
    decors_to_copy = []
    from .TauConfigurationTools import getHitZAlgs, getHitZVariables, getCaloHitsPreselAlgs, getTauIDScoreVariables
    if calohits_seq_name:
        decors_to_copy += [var for alg in getHitZAlgs(flags, seq_name, orig_seq_name) for var in getHitZVariables(alg)]
        decors_to_copy += [var for alg in getCaloHitsPreselAlgs(flags, seq_name, orig_seq_name) for var in getTauIDScoreVariables(alg)]
 
 
    # Reconstruction sequence CA (parOR), executting all reco algorithms within the View (from the RoI)
    # in parallel whenever possible, according to their data dependencies.
    # Create the EventViews based on the RoIs created in the previous steps (tauIso and tauLRT)
    recoAcc = InViewRecoCA(
        name=f'tauPrecisionReco_{seq_name}', 
        RoITool=CompFactory.ViewCreatorPreviousROITool(),
        InViewRoIs=input_rois,
        RequireParentView=True,
        ViewFallThrough=True,
        isProbe=is_probe_leg,
    )
    RoIs = recoAcc.inputMaker().InViewRoIs
 
 
    # VDV with all the required collections/objects in the View
    # (the VDV checks are disabled unless running with -l DEBUG)
    recoAcc.addRecoAlgo(CompFactory.AthViews.ViewDataVerifier(
        name=f'{recoAcc.name}RecoVDV',
        DataObjects={
            ('TrigRoiDescriptorCollection', f'StoreGateSvc+{RoIs}'),
            ('SG::AuxElement', 'StoreGateSvc+EventInfo.averageInteractionsPerCrossing'),
            ('xAOD::VertexContainer', f'StoreGateSvc+{flags.Tracking.ActiveConfig.vertex}'),
            ('xAOD::TrackParticleContainer', f'StoreGateSvc+{flags.Tracking.ActiveConfig.tracks_IDTrig}'),
            ('xAOD::TauTrackContainer', f'StoreGateSvc+{input_tau_tracks}'),
            ('xAOD::TauJetContainer', f'StoreGateSvc+{input_taus}'),
        } | {
            ('xAOD::TauJetContainer', f'StoreGateSvc+{input_taus}.{var}')
            for var in decors_to_copy
        }
    ))
 
 
    # Reconstruction tools/algorithms:
 
    # Precision TauJet reconstruction sequence
    from TrigTauRec.TrigTauRecConfig import trigTauRecMergedPrecisionMVACfg
    recoAcc.mergeReco(trigTauRecMergedPrecisionMVACfg(
        flags,
        seq_name,
        tau_ids=tau_ids,
        input_rois=RoIs,
        input_tracks=flags.Tracking.ActiveConfig.tracks_IDTrig,
        input_taus=input_taus,
        input_tau_tracks=input_tau_tracks,
        output_name=output_name,
        decors_to_copy=decors_to_copy,
    ))
 
 
    # Selection sequence CA (seqAND), executing the recoAcc view creation alg. first,
    # the reco CA (with all the reco algs) after, and the Hypo alg. at last
    selAcc = SelectionCA(f'tauPrecision_{seq_name}', isProbe=is_probe_leg)
    selAcc.mergeReco(recoAcc)
 
 
    # Hypothesis:
    # The Hypotools in the Hypo algorithm will execute the calibrated Tau pT cut,
    # NTrack cut, NWideTrack cut, and ID WP selections (or meson variable cuts)
    selAcc.addHypoAlgo(CompFactory.TrigTauJetHypoAlg(
        f'TauPrecisionHypoAlg_{seq_name}',
        TauJetsKey=f'HLT_TrigTauRecMerged_{output_name}'
    ))
 
 
    # Menu sequence, connecting everything internally for the step, and configuring the tools for the Hypo alg.
    # based on the partDict for each chain tau leg
    from TrigTauHypo.TrigTauHypoTool import TrigTauPrecisionHypoToolFromDict
    menuSeq = MenuSequence(flags, selAcc, HypoToolGen=TrigTauPrecisionHypoToolFromDict)
 
    return menuSeq

tauPrecTrackSequenceGenCfg()

MenuSequence tauPrecTrackSequenceGenCfg	(	AthConfigFlags	orig_flags,
		str | None	calohits_seq_name = None,
		bool	do_lrt = False,
		bool	is_probe_leg = False )

Precision Tracking step sequence, for both the tauIso and tauLRT RoIs

Definition at line 416 of file TauMenuSequences.py.

def tauPrecTrackSequenceGenCfg(orig_flags: AthConfigFlags, calohits_seq_name: str | None = None, do_lrt: bool = False, is_probe_leg: bool = False) -> MenuSequence:
    '''Precision Tracking step sequence, for both the tauIso and tauLRT RoIs'''
 
    if do_lrt:
        name = 'LRT'
        tracking_cfg = 'tauLRT'
    else:
        name = 'Iso'
        tracking_cfg = 'tauIso'
 
    if calohits_seq_name:
        name += f'_{calohits_seq_name}'
        tracking_cfg += calohits_seq_name
        input_rois = f'tauFastTrack{name}_{calohits_seq_name}'
    else:
        input_rois = f'tauFastTrack{name}'
 
    # Retrieve tracking configuration
    flags = getFlagsForActiveConfig(orig_flags, tracking_cfg, log)
 
 
    # Reconstruction sequence CA (parOR), executting all reco algorithms within the View (from the RoI)
    # in parallel whenever possible, according to their data dependencies.
    # Create the EventViews based on the RoIs created in the previous steps (tauIso and tauLRT)
    recoAcc = InViewRecoCA(
        name=f'tauPrecTrack{name}', 
        RoITool=CompFactory.ViewCreatorPreviousROITool(),
        InViewRoIs=input_rois,
        RequireParentView=True,
        ViewFallThrough=True,                           
        isProbe=is_probe_leg,
    )
    RoIs = recoAcc.inputMaker().InViewRoIs
 
 
    # VDV with all the required collections/objects in the View
    # (the VDV checks are disabled unless running with -l DEBUG)
    recoAcc.addRecoAlgo(CompFactory.AthViews.ViewDataVerifier(
        name=f'{recoAcc.name}RecoVDV',
        DataObjects={
            ('TrigRoiDescriptorCollection', f'StoreGateSvc+{RoIs}'),
            ('SG::AuxElement', 'StoreGateSvc+EventInfo.averageInteractionsPerCrossing'),
        }
    ))
 
 
    # Reconstruction tools/algorithms:
 
    # Precision Tracking sequence (track extension to the TRT and refitting)
    from TrigInDetConfig.TrigInDetConfig import trigInDetPrecisionTrackingCfg
    recoAcc.mergeReco(trigInDetPrecisionTrackingCfg(flags, rois=RoIs, signatureName=tracking_cfg))
 
    # Vertexing sequence
    from TrigInDetConfig.TrigInDetConfig import trigInDetVertexingCfg
    recoAcc.mergeReco(trigInDetVertexingCfg(flags, flags.Tracking.ActiveConfig.tracks_IDTrig, flags.Tracking.ActiveConfig.vertex))
 
 
    # Selection sequence CA (seqAND), executing the recoAcc view creation alg. first,
    # the reco CA (with all the reco algs) after, and the Hypo alg. at last
    selAcc = SelectionCA(f'tauPT{name}', isProbe=is_probe_leg)
    selAcc.mergeReco(recoAcc)
 
 
    # Hypothesis:
    # The hypothesis algorithm/tool does not perform any action (debug logging of number of tracks only)
    selAcc.addHypoAlgo(CompFactory.TrigTauTrackingHypoAlg(
        f'TauPrecTrackHypoAlg_PassBy{name}',
        TracksKey=flags.Tracking.ActiveConfig.tracks_IDTrig, 
    ))
 
 
    # Menu sequence, connecting everything internally for the step, and configuring the tools for the Hypo alg.
    # based on the partDict for each chain tau leg
    from TrigTauHypo.TrigTauHypoTool import TrigTauTrackingHypoToolFromDict
    menuSeq = MenuSequence(flags, selAcc, HypoToolGen=TrigTauTrackingHypoToolFromDict)
 
    return menuSeq
 
 
 
#================================================================
# Precision Tau step
#================================================================
 
@AccumulatorCache

Variable Documentation

log

python.HLT.Tau.TauMenuSequences.log = logging.getLogger(__name__)

Definition at line 11 of file TauMenuSequences.py.