METMakerConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 
from AthenaConfiguration.ComponentFactory import CompFactory
 
def getMETMaker(jetCollection, name="METMaker", **kwargs):
    kwargs.setdefault("DoPFlow", False)
    kwargs.setdefault("JetSelection", "Tight")
 
    if kwargs["JetSelection"]=="Tier0":
        kwargs.setdefault("JvtSelTool", None)
    elif kwargs["DoPFlow"]:
        kwargs.setdefault("JvtSelTool", CompFactory.CP.NNJvtSelectionTool(
            name="JvtSelTool",
            JetContainer=jetCollection,
            JvtMomentName="NNJvt",
            WorkingPoint="FixedEffPt",
            MaxPtForJvt=60e3))
    else:
        kwargs.setdefault("JvtSelTool", CompFactory.CP.JvtSelectionTool(
            name="JvtSelTool",
            JetContainer=jetCollection,
            JvtMomentName="Jvt",
            WorkingPoint=kwargs["JetSelection"],
            MaxPtForJvt=60e3,
            IsPFlow=False))
 
    return CompFactory.getComp("met::METMaker")(name, **kwargs)
 
def getMuonSelectionTool(name="MuonSelectionTool_METMakerAlg"):
    muonSel = CompFactory.getComp("CP::MuonSelectionTool")(name,
                                                           MuQuality=1, # Medium
                                                           TurnOffMomCorr= True,
                                                           MaxEta=2.4,
                                                           AllowSettingGeometryOnTheFly = True)
    return muonSel
 
def getEleSelLikelihood(name="EleSelLikelihood_METMakerAlg"):
    elecSelLH = CompFactory.AsgElectronLikelihoodTool(name,
                                                      WorkingPoint="MediumLHElectron")
    return elecSelLH
 
def getPhotonSelIsEM(name="PhotonSelIsEM_METMakerAlg"):
    photonSelIsEM = CompFactory.AsgPhotonIsEMSelector(name,
                                                      WorkingPoint="TightPhoton")
    return photonSelIsEM
 
def getTauSelectionTool(name="TauSelectionTool_METMakerAlg"):
    from ROOT import TauAnalysisTools
    SelectionCuts = TauAnalysisTools.SelectionCuts
 
    tauSel = CompFactory.getComp("TauAnalysisTools::TauSelectionTool")("TauSelectionTool_METMakerAlg",
                                                                       ConfigPath = "",
                                                                       SelectionCuts = int(SelectionCuts.CutPt | SelectionCuts.CutAbsEta | SelectionCuts.CutAbsCharge | SelectionCuts.CutNTrack | SelectionCuts.CutJetIDWP),
                                                                       PtMin = 20.0,
                                                                       JetIDWP = TauAnalysisTools.JETIDRNNMEDIUM,
                                                                       NTracks = (1, 3),
                                                                       AbsCharge = 1,
                                                                       AbsEtaRegion = (0.0, 1.37, 1.52, 2.5))
    return tauSel
 
def getMETMakerAlg(suffix,jetSelection="Tier0",jetColl="",**kwargs):
 
    print ("Generate METMaker and METMakerAlg for METAssoc_"+suffix)
 
    doPFlow = 'PFlow' in suffix
    doTruth = suffix.startswith('Truth')
    if jetColl=="":
        jetColl = suffix+'Jets'
        if doTruth:
            jetColl = suffix.split('_')[1]+'Jets'
 
    metMaker = getMETMaker(jetCollection=jetColl,
                           name='METMaker_'+suffix,
                           DoPFlow=doPFlow,
                           DoSoftTruth=doTruth,
                           JetSelection=jetSelection)
 
    muonSel = getMuonSelectionTool()
 
    elecSelLH = getEleSelLikelihood()
 
    photonSelIsEM = getPhotonSelIsEM()
 
    tauSel = getTauSelectionTool()
 
    makerAlg = CompFactory.getComp("met::METMakerAlg")('METMakerAlg_'+suffix,
                                       METMapName='METAssoc_'+suffix,
                                       METCoreName='MET_Core_'+suffix,
                                       METName='MET_Reference_'+suffix,
                                       InputJets=jetColl,
                                       Maker=metMaker,
                                       MuonSelectionTool=muonSel,
                                       ElectronLHSelectionTool=elecSelLH,
                                       PhotonIsEMSelectionTool=photonSelIsEM,
                                       TauSelectionTool=tauSel,
                                       **kwargs
                                       )
    return makerAlg
 
 
def main():
 
        # Config flags steer the job at various levels
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    flags = initConfigFlags()
    flags.fillFromArgs()
    flags.lock()
 
    # Get a ComponentAccumulator setting up the fundamental Athena job
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg 
    cfg=MainServicesCfg(flags) 
 
    # Add the components for reading in pool files
    from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
    cfg.merge(PoolReadCfg(flags))
 
    from AthenaCommon.Constants import VERBOSE
    cfg.addEventAlgo(
        getMETMakerAlg(
            suffix="AntiKt4EMPFlow",
            jetSelection="Tight",
            OutputLevel=VERBOSE
        )
    )
 
    cfg.run(10)
 
if __name__=="__main__":
    main()