PFHLTConfig Namespace Reference

Functions
	TrackingGeoCfg (inputFlags)
	CaloGeoAndNoiseCfg (inputFlags)
	PFTrackExtensionCfg (flags, tracktype, tracksin)
	MuonCaloTagCfg (flags, tracktype, tracksin, extcache, cellsin)
	MuonIsoTagCfg (flags, tracktype, tracksin, verticesin, extcache, clustersin)
	HLTPFTrackSelectorCfg (inputFlags, tracktype, tracksin, verticesin, clustersin, cellsin=None)
	getHLTPFMomentCalculatorTool (inputFlags)
	PFCfg (inputFlags, tracktype="", clustersin=None, calclustersin=None, tracksin=None, verticesin=None, cellsin=None)

Variables
	cfgFlags = initConfigFlags()
	Files
	addClusterMoments
	useClusterMoments
	Dynamic
	cfg = MainServicesCfg(cfgFlags)
	tccfg = CaloTopoClusterCfg(cfgFlags)
	tcalg = tccfg.getPrimary()
	ClustersOutputName
	sequenceName
list	outputlist
	histSvc = CompFactory.THistSvc(Output = ["EXPERT DATAFILE='expert-monitoring.root', OPT='RECREATE'"])
	Dump

Function Documentation

CaloGeoAndNoiseCfg()

PFHLTConfig.CaloGeoAndNoiseCfg

(

inputFlags

)

Definition at line 21 of file PFHLTConfig.py.

def CaloGeoAndNoiseCfg(inputFlags):
    result = ComponentAccumulator()
    from LArGeoAlgsNV.LArGMConfig import LArGMCfg
    from TileGeoModel.TileGMConfig import TileGMCfg
 
    result.merge(LArGMCfg(inputFlags))
    result.merge(TileGMCfg(inputFlags))
 
    from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
    # Schedule total noise cond alg
    result.merge(CaloNoiseCondAlgCfg(inputFlags,"totalNoise"))
 
    return result
 

getHLTPFMomentCalculatorTool()

PFHLTConfig.getHLTPFMomentCalculatorTool

(

inputFlags

)

Definition at line 207 of file PFHLTConfig.py.

def getHLTPFMomentCalculatorTool(inputFlags):
    result = ComponentAccumulator()
    from eflowRec.PFCfg import getPFMomentCalculatorTool
 
    if inputFlags.PF.useClusterMoments:
        MomentsNames = [
            "FIRST_PHI" 
            ,"FIRST_ETA"
            ,"SECOND_R" 
            ,"SECOND_LAMBDA"
            ,"DELTA_PHI"
            ,"DELTA_THETA"
            ,"DELTA_ALPHA" 
            ,"CENTER_X"
            ,"CENTER_Y"
            ,"CENTER_Z"
            ,"CENTER_MAG"
            ,"CENTER_LAMBDA"
            ,"LATERAL"
            ,"LONGITUDINAL"
            ,"FIRST_ENG_DENS" 
            ,"ENG_FRAC_EM" 
            ,"ENG_FRAC_MAX" 
            ,"ENG_FRAC_CORE" 
            ,"FIRST_ENG_DENS" 
            ,"SECOND_ENG_DENS"
            ,"ISOLATION"
            ,"EM_PROBABILITY"
            ,"ENG_POS"
            ,"ENG_BAD_CELLS"
            ,"N_BAD_CELLS"
            ,"BADLARQ_FRAC"
            ,"AVG_LAR_Q"
            ,"AVG_TILE_Q"
            ,"SIGNIFICANCE"
        ]
    else:
        MomentsNames = ["CENTER_MAG"]
    PFMomentCalculatorTool = result.popToolsAndMerge(getPFMomentCalculatorTool(inputFlags,MomentsNames))
    result.setPrivateTools(PFMomentCalculatorTool)
    return result
 

HLTPFTrackSelectorCfg()

PFHLTConfig.HLTPFTrackSelectorCfg	(		inputFlags,
			tracktype,
			tracksin,
			verticesin,
			clustersin,
			cellsin = None )

Definition at line 149 of file PFHLTConfig.py.

def HLTPFTrackSelectorCfg(inputFlags,tracktype,tracksin,verticesin,clustersin,cellsin=None):
    result = ComponentAccumulator()
 
    muon_mode = inputFlags.Trigger.FSHad.PFOMuonRemoval
    if muon_mode == "None":
        tracks = tracksin
        extension_cache=""
    else:
        ext_acc, pretracks, extension_cache = PFTrackExtensionCfg(
            inputFlags, tracktype, tracksin
        )
        result.merge(ext_acc)
        if muon_mode == "Calo":
            if cellsin is None:
                raise ValueError("Cells must be provided for the 'Calo' muon mode!")
            tag_acc, tracks = MuonCaloTagCfg(
                inputFlags, tracktype, pretracks, extension_cache, cellsin
            )
        elif muon_mode == "Iso":
            tag_acc, tracks = MuonIsoTagCfg(
                inputFlags, tracktype, pretracks, verticesin, extension_cache, clustersin
            )
        else:
            raise ValueError(f"Invalid muon removal mode '{muon_mode}'")
        result.merge(tag_acc)
 
    from InDetTrackSelectionTool.InDetTrackSelectionToolConfig import (
        PFTrackSelectionToolCfg)
    from TrackToCalo.TrackToCaloConfig import HLTPF_ParticleCaloExtensionToolCfg
 
 
    from eflowRec import PFOnlineMon
    monTool_extrapolator = PFOnlineMon.getMonTool_eflowTrackCaloExtensionTool(inputFlags)
    monTool_extrapolator.HistPath = 'TrackExtrapolator'
 
    result.addEventAlgo(
        CompFactory.PFTrackSelector(
            f"PFTrackSelector_{tracktype}",
            trackExtrapolatorTool = CompFactory.eflowTrackCaloExtensionTool(
                "HLTPF_eflowTrkCaloExt",
                TrackCaloExtensionTool=result.popToolsAndMerge(
                    HLTPF_ParticleCaloExtensionToolCfg(inputFlags)),
                PFParticleCache = extension_cache,
                MonTool_TrackCaloExtension = monTool_extrapolator
            ),
            trackSelectionTool = result.popToolsAndMerge(PFTrackSelectionToolCfg(inputFlags)),
            electronsName="",
            muonsName="",
            tracksName=tracks,
            VertexContainer=verticesin,
            eflowRecTracksOutputName=f"eflowRecTracks_{tracktype}",
            MonTool = PFOnlineMon.getMonTool_PFTrackSelector(inputFlags),
        ),
        primary=True,
    )
 
    return result
 

MuonCaloTagCfg()

PFHLTConfig.MuonCaloTagCfg	(		flags,
			tracktype,
			tracksin,
			extcache,
			cellsin )

 Create the muon calo tagging configuration

Return the component accumulator and the tracks with muons removed

Definition at line 68 of file PFHLTConfig.py.

def MuonCaloTagCfg(flags, tracktype, tracksin, extcache, cellsin):
    """ Create the muon calo tagging configuration
    
    Return the component accumulator and the tracks with muons removed
    """
    from TrkConfig.AtlasExtrapolatorConfig import TrigPFlowExtrapolatorCfg
    result = ComponentAccumulator()
    extrapolator = result.popToolsAndMerge(TrigPFlowExtrapolatorCfg(flags))
    output_tracks = f"PFMuonCaloTagTracks_{tracktype}"
 
    from TrackToCalo.TrackToCaloConfig import (
        HLTPF_ParticleCaloExtensionToolCfg,
        HLTPF_ParticleCaloCellAssociationToolCfg)
 
    caloext = result.popToolsAndMerge(HLTPF_ParticleCaloExtensionToolCfg(flags))
    calocellassoc = result.popToolsAndMerge(HLTPF_ParticleCaloCellAssociationToolCfg(
        flags,
        ParticleCaloExtensionTool=caloext,
        CaloCellContainer="",
    ))
 
    result.addEventAlgo(
        CompFactory.PFTrackMuonCaloTaggingAlg(
            f"PFTrackMuonCaloTaggingAlg_{tracktype}",
            InputTracks = tracksin,
            InputCaloExtension = extcache,
            InputCells = cellsin,
            OutputTracks = output_tracks,
            MinPt = flags.Trigger.FSHad.PFOMuonRemovalMinPt,
            MuonScoreTool = CompFactory.CaloMuonScoreTool(
                CaloMuonEtaCut=3,
                ParticleCaloCellAssociationTool = calocellassoc
            ),
            LooseTagTool=CompFactory.CaloMuonTag("LooseCaloMuonTag", TagMode="Loose"),
            TightTagTool=CompFactory.CaloMuonTag("TightCaloMuonTag", TagMode="Tight"),
            DepositInCaloTool=CompFactory.TrackDepositInCaloTool(
                ExtrapolatorHandle=extrapolator,
                ParticleCaloCellAssociationTool = calocellassoc,
                ParticleCaloExtensionTool = caloext
            )
        ),
        primary=True,
    )
    return result, output_tracks
 

MuonIsoTagCfg()

PFHLTConfig.MuonIsoTagCfg	(		flags,
			tracktype,
			tracksin,
			verticesin,
			extcache,
			clustersin )

 Create the muon iso tagging configuration

Return the component accumulator and the tracks with muons removed

Definition at line 113 of file PFHLTConfig.py.

def MuonIsoTagCfg(flags, tracktype, tracksin, verticesin, extcache, clustersin):
    """ Create the muon iso tagging configuration
    
    Return the component accumulator and the tracks with muons removed
    """
    result = ComponentAccumulator()
    output_tracks = f"PFMuonIsoTagTracks_{tracktype}"
 
    from TrackToCalo.TrackToCaloConfig import HLTPF_ParticleCaloExtensionToolCfg
 
    result.addEventAlgo(
        CompFactory.PFTrackMuonIsoTaggingAlg(
            f"PFTrackMuonIsoTaggingalg_{tracktype}",
            InputTracks = tracksin,
            InputClusters = clustersin,
            InputVertices = verticesin,
            OutputTracks = output_tracks,
            MinPt = flags.Trigger.FSHad.PFOMuonRemovalMinPt,
            TrackIsoTool = CompFactory.xAOD.TrackIsolationTool(
                TrackParticleLocation=tracksin,
                VertexLocation="",
            ),
            CaloIsoTool = CompFactory.xAOD.CaloIsolationTool(
                ParticleCaloExtensionTool=result.popToolsAndMerge(
                    HLTPF_ParticleCaloExtensionToolCfg(flags)),
                InputCaloExtension=extcache,
                ParticleCaloCellAssociationTool="",
                saveOnlyRequestedCorrections=True,
            )
        ),
        primary=True,
    )
    return result, output_tracks
 
#---------------------------------------------------------------------------------#
# PFlow track selection

PFCfg()

PFHLTConfig.PFCfg	(		inputFlags,
			tracktype = "",
			clustersin = None,
			calclustersin = None,
			tracksin = None,
			verticesin = None,
			cellsin = None )

Definition at line 249 of file PFHLTConfig.py.

def PFCfg(inputFlags, tracktype="", clustersin=None, calclustersin=None, tracksin=None, verticesin=None, cellsin=None):
 
    result=ComponentAccumulator()
    seqname = f'HLTPFlow_{tracktype}'
    result.addSequence(parOR(seqname))
 
    # Set defaults for the inputs
    if clustersin is None:
        clustersin=inputFlags.eflowRec.RawClusterColl
    if calclustersin is None:
        calclustersin=inputFlags.eflowRec.CalClusterColl
    if tracksin is None:
        tracksin = inputFlags.eflowRec.TrackColl
    if verticesin is None:
        verticesin = inputFlags.eflowRec.VertexColl
 
    result.merge(TrackingGeoCfg(inputFlags))
    calogeocfg = CaloGeoAndNoiseCfg(inputFlags)
    result.merge(calogeocfg)
 
    selcfg = HLTPFTrackSelectorCfg(inputFlags, tracktype, tracksin, verticesin, clustersin, cellsin)
    PFTrackSelector = selcfg.getPrimary()
 
    # Add monitoring tool
    monTool = PFOnlineMon.getMonTool_PFTrackSelector(inputFlags)
    PFTrackSelector.MonTool = monTool
 
    result.merge( selcfg, seqname )
 
    #---------------------------------------------------------------------------------#
    # PFlowAlgorithm -- subtraction steps
 
 
    from eflowRec.PFCfg import getPFClusterSelectorTool
    from eflowRec.PFCfg import getPFCellLevelSubtractionTool,getPFRecoverSplitShowersTool
 
    PFTrackClusterMatchingTool_1 = CompFactory.PFTrackClusterMatchingTool("CalObjBldMatchingTool")
    monTool_matching = PFOnlineMon.getMonTool_PFTrackClusterMatching(inputFlags)
    monTool_matching.HistPath = 'PFTrackClusterMatchingTool_1'
    PFTrackClusterMatchingTool_1.MonTool_ClusterMatching = monTool_matching
 
    cellSubtractionTool = getPFCellLevelSubtractionTool(
        inputFlags,
        "PFCellLevelSubtractionTool",
    )
    cellSubtractionTool.PFTrackClusterMatchingTool=PFTrackClusterMatchingTool_1
 
    recoverSplitShowersTool = getPFRecoverSplitShowersTool(
        inputFlags,
        "PFRecoverSplitShowersTool",
    )
    recoverSplitShowersTool.PFTrackClusterMatchingTool = PFTrackClusterMatchingTool_1
 
    result.addEventAlgo(
        CompFactory.PFAlgorithm(
            f"PFAlgorithm_{tracktype}",
            PFClusterSelectorTool = getPFClusterSelectorTool(
                inputFlags,
                clustersin,
                calclustersin,
                "PFClusterSelectorTool",
            ),
            SubtractionToolList = [
                cellSubtractionTool,
                recoverSplitShowersTool,
            ],
            BaseToolList = [
                result.popToolsAndMerge(getHLTPFMomentCalculatorTool(inputFlags)),
            ],
            MonTool = PFOnlineMon.getMonTool_PFAlgorithm(inputFlags),
            eflowRecTracksInputName = PFTrackSelector.eflowRecTracksOutputName,
            eflowRecClustersOutputName = f"eflowRecClusters_{tracktype}",
            PFCaloClustersOutputName = f"PFCaloCluster_{tracktype}",
            eflowCaloObjectsOutputName = f"eflowCaloObjects_{tracktype}",
        ),
        seqname
    )
 
    #---------------------------------------------------------------------------------#
    # PFO creators here
 
    chargedPFOArgs = dict(
            inputFlags=inputFlags,
            nameSuffix=f"_{tracktype}",
            chargedFlowElementOutputName=recordable(f"HLT_{tracktype}ChargedParticleFlowObjects"),
            eflowCaloObjectContainerName=f"eflowCaloObjects_{tracktype}"
    )
    neutralPFOArgs = dict(
            inputFlags=inputFlags,
            nameSuffix=f"_{tracktype}",
            neutralFlowElementOutputName=recordable(f"HLT_{tracktype}NeutralParticleFlowObjects"),
            eflowCaloObjectContainerName=f"eflowCaloObjects_{tracktype}"
    )
    from eflowRec.PFCfg import getChargedFlowElementCreatorAlgorithm,getNeutralFlowElementCreatorAlgorithm
    result.addEventAlgo(getNeutralFlowElementCreatorAlgorithm(**neutralPFOArgs), seqname)
    result.addEventAlgo(getChargedFlowElementCreatorAlgorithm(**chargedPFOArgs), seqname)
 
    
    return result
 

PFTrackExtensionCfg()

PFHLTConfig.PFTrackExtensionCfg	(		flags,
			tracktype,
			tracksin )

 Get the track-to-calo extension after a preselection

Returns the component accumulator, the preselected track collection and the extension cache

Definition at line 35 of file PFHLTConfig.py.

def PFTrackExtensionCfg(flags, tracktype, tracksin):
    """ Get the track-to-calo extension after a preselection
 
    Returns the component accumulator, the preselected track collection and the extension cache
    """
    result = ComponentAccumulator()
    pretracks_name = f"HLTPFPreselTracks_{tracktype}"
    cache_name = f"HLTPFTrackExtensionCache_{tracktype}"
 
    from InDetTrackSelectionTool.InDetTrackSelectionToolConfig import (
        PFTrackSelectionToolCfg)
    result.addEventAlgo(CompFactory.PFTrackPreselAlg(
        f"HLTPFTrackPresel_{tracktype}",
        InputTracks=tracksin,
        OutputTracks=pretracks_name,
        TrackSelTool=result.popToolsAndMerge(PFTrackSelectionToolCfg(flags))
    ))
 
 
    monTool_trackExtrap = PFOnlineMon.getMonTool_ParticleCaloExtensionTool(flags)
    monTool_trackExtrap.HistPath = 'TrackCaloExtrapolation_general'
 
    from TrackToCalo.TrackToCaloConfig import HLTPF_ParticleCaloExtensionToolCfg
    result.addEventAlgo(CompFactory.Trk.PreselCaloExtensionBuilderAlg(
        f"HLTPFTrackExtension_{tracktype}",
        ParticleCaloExtensionTool=result.popToolsAndMerge(
            HLTPF_ParticleCaloExtensionToolCfg(flags, MonTool=monTool_trackExtrap)),
        InputTracks=pretracks_name,
        OutputCache=cache_name,
    ))
 
    return result, pretracks_name, cache_name
 

TrackingGeoCfg()

PFHLTConfig.TrackingGeoCfg

(

inputFlags

)

Definition at line 11 of file PFHLTConfig.py.

def TrackingGeoCfg(inputFlags):
    result = ComponentAccumulator()
 
    from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
    result.merge(AtlasFieldCacheCondAlgCfg(inputFlags))
 
    return result
 
#---------------------------------------------------------------------------------#
# Calo geometry & conditions

Variable Documentation

addClusterMoments

PFHLTConfig.addClusterMoments

Definition at line 362 of file PFHLTConfig.py.

cfg

PFHLTConfig.cfg = MainServicesCfg(cfgFlags)

Definition at line 372 of file PFHLTConfig.py.

cfgFlags

PFHLTConfig.cfgFlags = initConfigFlags()

Definition at line 352 of file PFHLTConfig.py.

ClustersOutputName

PFHLTConfig.ClustersOutputName

Definition at line 377 of file PFHLTConfig.py.

Dump

PFHLTConfig.Dump

Definition at line 402 of file PFHLTConfig.py.

Dynamic

PFHLTConfig.Dynamic

Definition at line 367 of file PFHLTConfig.py.

Files

PFHLTConfig.Files

Definition at line 354 of file PFHLTConfig.py.

histSvc

PFHLTConfig.histSvc = CompFactory.THistSvc(Output = ["EXPERT DATAFILE='expert-monitoring.root', OPT='RECREATE'"])

Definition at line 399 of file PFHLTConfig.py.

outputlist

list PFHLTConfig.outputlist

Initial value:

=  [
        "xAOD::CaloClusterContainer#CaloCalTopoClusters*",
        "xAOD::CaloClusterAuxContainer#*CaloCalTopoClusters*Aux.",
        "xAOD::PFOContainer#*ParticleFlowObjects",
        "xAOD::PFOAuxContainer#*ParticleFlowObjectsAux."
        ]

Definition at line 388 of file PFHLTConfig.py.

sequenceName

PFHLTConfig.sequenceName

Definition at line 379 of file PFHLTConfig.py.

tcalg

PFHLTConfig.tcalg = tccfg.getPrimary()

Definition at line 376 of file PFHLTConfig.py.

tccfg

PFHLTConfig.tccfg = CaloTopoClusterCfg(cfgFlags)

Definition at line 375 of file PFHLTConfig.py.

useClusterMoments

PFHLTConfig.useClusterMoments

Definition at line 363 of file PFHLTConfig.py.