egammaForwardBuilderConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 
from ElectronPhotonSelectorTools.EgammaPIDdefs import egammaPID
from egammaTools.EMTrackMatchBuilderConfig import EMTrackMatchBuilderCfg
from ElectronPhotonSelectorTools.AsgForwardElectronIsEMSelectorsConfig import (
    AsgForwardElectronIsEMSelectorCfg)
from ElectronPhotonSelectorTools.ForwardElectronSelectorConfig import (
    AsgForwardElectronSelectorToolCfg, AsgForwardElectronCalibrationToolCfg)
from AthenaCommon.Logging import logging
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from egammaTools.egammaOQFlagsBuilderConfig import egammaOQFlagsBuilderCfg
 
 
def egammaForwardBuilderCfg(flags, name='egammaForwardElectron', **kwargs):
 
    acc = ComponentAccumulator()
    extraInputs = []
 
    if flags.Detector.GeometryITk:
        kwargs["doTrackMatching"] = True
        kwargs["doCookieCutting"] = True
        if flags.Reco.EnableHGTDExtension:
            if "forwardelectronNNselectors" not in kwargs:
                LooseFwdElectronSelector_NN = AsgForwardElectronSelectorToolCfg(
                    flags,
                    "LooseForwardNNElectronSelector",
                    "Loose")
                MediumFwdElectronSelector_NN = AsgForwardElectronSelectorToolCfg(
                    flags,
                    "MediumForwardNNElectronSelector",
                    "Medium")
                TightFwdElectronSelector_NN = AsgForwardElectronSelectorToolCfg(
                    flags,
                    "TightForwardNNElectronSelector",
                    "Tight")
                
                kwargs["dofwdDNN"] = True
                kwargs.setdefault("forwardelectronNNselectors",
                                  [LooseFwdElectronSelector_NN.popPrivateTools(),
                                   MediumFwdElectronSelector_NN.popPrivateTools(),
                                   TightFwdElectronSelector_NN.popPrivateTools()])
                kwargs.setdefault(
                    "forwardelectronNNselectorResultNames",
                    ["Loose", "Medium", "Tight"])
                acc.merge(LooseFwdElectronSelector_NN)
                acc.merge(MediumFwdElectronSelector_NN)
                acc.merge(TightFwdElectronSelector_NN)
        
            kwargs["dopTCal"] = True
            forward_elecpTCalib = AsgForwardElectronCalibrationToolCfg (flags,
                                                                    "forwardelectronNNpTCalib")
            kwargs.setdefault("forwardelectronNNCalib",forward_elecpTCalib.popPrivateTools())
        kwargs.setdefault("ExtraInputs", extraInputs)
        kwargs.setdefault("TrackMatchBuilderTool", acc.popToolsAndMerge(EMTrackMatchBuilderCfg(flags)))
        
 
    if "forwardelectronIsEMselectors" not in kwargs:
        LooseFwdElectronSelector = AsgForwardElectronIsEMSelectorCfg(
            flags,
            "LooseForwardElectronSelector",
            egammaPID.ForwardElectronIDLoose)
        MediumFwdElectronSelector = AsgForwardElectronIsEMSelectorCfg(
            flags,
            "MediumForwardElectronSelector",
            egammaPID.ForwardElectronIDMedium)
        TightFwdElectronSelector = AsgForwardElectronIsEMSelectorCfg(
            flags,
            "TightForwardElectronSelector",
            egammaPID.ForwardElectronIDTight)
 
        kwargs.setdefault("forwardelectronIsEMselectors",
                          [LooseFwdElectronSelector.popPrivateTools(),
                           MediumFwdElectronSelector.popPrivateTools(),
                           TightFwdElectronSelector.popPrivateTools()])
        kwargs.setdefault(
            "forwardelectronIsEMselectorResultNames",
            ["Loose", "Medium", "Tight"])
 
        acc.merge(LooseFwdElectronSelector)
        acc.merge(MediumFwdElectronSelector)
        acc.merge(TightFwdElectronSelector)
 
 
 
    if "ObjectQualityTool" not in kwargs and not flags.Common.isOnline:
        egOQ = egammaOQFlagsBuilderCfg(flags)
        kwargs["ObjectQualityTool"] = egOQ.popPrivateTools()
        acc.merge(egOQ)
 
    if flags.Egamma.doForwardCalib:
        kwargs["doEnergyCal"] = True
        kwargs["PrimaryVerticesContainerKey"] = "PrimaryVertices"
        kwargs["EventInfoKey"] = "EventInfo"
        from egammaMVACalib.egammaMVACalibConfig import egammaMVASvcCfg
        kwargs["MVACalibSvc"] = acc.getPrimaryAndMerge(egammaMVASvcCfg(flags))
 
    kwargs.setdefault("ElectronOutputName",
                      flags.Egamma.Keys.Output.ForwardElectrons)
    kwargs.setdefault("TopoClusterName",
                      flags.Egamma.Keys.Internal.ForwardTopoClusters)
    kwargs.setdefault("ClusterContainerName",
                      flags.Egamma.Keys.Output.ForwardClusters)
    fwdAlg = CompFactory.egammaForwardBuilder(name, **kwargs)
 
    acc.addEventAlgo(fwdAlg)
    return acc
 
 
if __name__ == "__main__":
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    from AthenaConfiguration.TestDefaults import defaultTestFiles
    from AthenaConfiguration.ComponentAccumulator import printProperties
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg
    flags = initConfigFlags()
    flags.Input.Files = defaultTestFiles.RDO_RUN2
    flags.lock()
 
    acc = MainServicesCfg(flags)
    mlog = logging.getLogger("egammaForwardBuilderConfigTest")
    mlog.info("Configuring  egammaForwardBuilder: ")
    acc.merge(egammaForwardBuilderCfg(flags))
    printProperties(mlog,
                    acc.getEventAlgo("egammaForwardElectron"),
                    nestLevel=1,
                    printDefaults=True)
    with open("egammaforwardbuilder.pkl", "wb") as f:
        acc.store(f)