sTGC_DigitizationConfig.py

Go to the documentation of this file.

"""Define methods to construct configured STGC Digitization tools and algorithms
 
Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
"""
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.Enums import ProductionStep
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
from MuonConfig.MuonByteStreamCnvTestConfig import STGC_DigitToRDOCfg
from DigitizationConfig.TruthDigitizationOutputConfig import TruthDigitizationOutputCfg
from DigitizationConfig.PileUpToolsConfig import PileUpToolsCfg
from DigitizationConfig.PileUpMergeSvcConfig import PileUpMergeSvcCfg, PileUpXingFolderCfg
 
 
# The earliest and last bunch crossing times for which interactions will be sent
# to the sTgcDigitizationTool.
def sTGC_FirstXing():
    return -100
 
 
def sTGC_LastXing():
    return 100
 
 
def sTGC_RangeCfg(flags, name="sTgcRange", **kwargs):
    """Return a PileUpXingFolder tool configured for sTGC"""
    kwargs.setdefault("FirstXing", sTGC_FirstXing())
    kwargs.setdefault("LastXing", sTGC_LastXing())
    kwargs.setdefault("CacheRefreshFrequency", 1.0)
    if flags.Muon.usePhaseIIGeoSetup:
        kwargs.setdefault("ItemList",  ["xAOD::MuonSimHitContainer#xStgcSimHits",
                                        "xAOD::MuonSimHitAuxContainer#xStgcSimHitsAux."])
    else:
        kwargs.setdefault("ItemList", ["sTGCSimHitCollection#sTGC_Hits"])
    return PileUpXingFolderCfg(flags, name, **kwargs)
 
def sTGC_DigitizationToolCfg(flags, name="sTgcDigitizationTool", **kwargs):
    result = ComponentAccumulator()
 
    from RngComps.RngCompsConfig import AthRNGSvcCfg
    kwargs.setdefault("RndmSvc", result.getPrimaryAndMerge(AthRNGSvcCfg(flags)))
 
 
    if flags.Digitization.PileUp:
        intervals = []
        if flags.Digitization.DoXingByXingPileUp:
            kwargs.setdefault("FirstXing", sTGC_FirstXing())
            kwargs.setdefault("LastXing", sTGC_LastXing())
        else:
            intervals += [result.popToolsAndMerge(sTGC_RangeCfg(flags))]
        kwargs.setdefault("PileUpMergeSvc", result.getPrimaryAndMerge(PileUpMergeSvcCfg(flags, Intervals=intervals)))
    else:
        kwargs.setdefault("PileUpMergeSvc", '')
    kwargs.setdefault("OnlyUseContainerName", flags.Digitization.PileUp)
 
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        kwargs.setdefault("OutputSDOName", flags.Overlay.BkgPrefix + "sTGC_SDO")
    else:
        kwargs.setdefault("OutputSDOName", "sTGC_SDO")
        kwargs.setdefault("OutputObjectName", "sTGC_DIGITS")
 
    the_tool = None
    if not flags.Muon.usePhaseIIGeoSetup:
        from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg, STgcCalibSmearingToolCfg
        kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
        kwargs.setdefault("SmearingTool", result.popToolsAndMerge(STgcCalibSmearingToolCfg(flags)))
        # sTGC VMM configurables
        kwargs.setdefault("doToFCorrection", True)
        kwargs.setdefault("InputObjectName", "sTGC_Hits")
        the_tool = CompFactory.sTgcDigitizationTool(name, **kwargs)
 
    elif flags.Muon.doFastsTGCDigitization:
        from ActsAlignmentAlgs.AlignmentAlgsConfig import ActsGeometryContextAlgCfg
        result.merge(ActsGeometryContextAlgCfg(flags))
        kwargs.setdefault("StreamName", "sTgcSimForklift")
        kwargs.setdefault("SimHitKey", "xStgcSimHits")
        kwargs.setdefault("EffiDataKey", "")    
        """
        from MuonConfig.MuonCondAlgConfig import sTgcDigitEffiCondAlgCfg
        result.merge(sTgcDigitEffiCondAlgCfg(flags,readFromJSON="EffMapsTGC.json"))
        kwargs.setdefault("EffiDataKey", "sTgcDigitEff")
        """
        from MuonConfig.MuonCalibrationConfig import NswErrorCalibDbAlgCfg
        result.merge(NswErrorCalibDbAlgCfg(flags))
        the_tool = CompFactory.MuonR4.sTgcFastDigiTool(name, **kwargs)
 
    else:
        from ActsAlignmentAlgs.AlignmentAlgsConfig import ActsGeometryContextAlgCfg
        result.merge(ActsGeometryContextAlgCfg(flags))
        kwargs.setdefault("StreamName", "sTgcSimForklift")
        kwargs.setdefault("SimHitKey", "xStgcSimHits")
        kwargs.setdefault("EffiDataKey", "")    
 
        from MuonConfig.MuonCalibrationConfig import NswErrorCalibDbAlgCfg, STgcCalibSmearingToolCfg
        kwargs.setdefault("doToFCorrection", True)
        kwargs.setdefault("SmearingTool", result.popToolsAndMerge(STgcCalibSmearingToolCfg(flags)))
        result.merge(NswErrorCalibDbAlgCfg(flags))
        the_tool = CompFactory.MuonR4.sTgcDigitizationTool(name, **kwargs)
 
    result.setPrivateTools(the_tool)
    return result
 
def sTGC_OverlayDigitizationToolCfg(flags, name="STGC_OverlayDigitizationTool", **kwargs):
    """Return ComponentAccumulator with TgcDigitizationTool configured for Overlay"""
    acc = ComponentAccumulator()
    kwargs.setdefault("PileUpMergeSvc", '')
    kwargs.setdefault("OnlyUseContainerName", False)
    kwargs.setdefault("OutputObjectName", flags.Overlay.SigPrefix + "sTGC_DIGITS")
    kwargs.setdefault("OutputSDOName", flags.Overlay.SigPrefix + "sTGC_SDO")
    the_tool = acc.popToolsAndMerge(sTGC_DigitizationToolCfg(flags, name=name, **kwargs))
    acc.setPrivateTools(the_tool)
    return acc
 
 
def sTGC_OutputCfg(flags):
    """Return ComponentAccumulator with Output for sTGC. Not standalone."""
    acc = ComponentAccumulator()
    if flags.Output.doWriteRDO:
        ItemList = ["Muon::STGC_RawDataContainer#*"]
        if flags.Digitization.EnableTruth:
            ItemList += ["MuonSimDataCollection#*"]
            ItemList += ["xAOD::MuonSimHitContainer#*STGC_SDO",
                         "xAOD::MuonSimHitAuxContainer#*STGC_SDOAux."]
 
            acc.merge(TruthDigitizationOutputCfg(flags))
        acc.merge(OutputStreamCfg(flags, "RDO", ItemList))
    return acc
 
 
def sTGC_DigitizationBasicCfg(flags, **kwargs):
    """Return ComponentAccumulator for sTGC digitization"""
    acc = MuonGeoModelCfg(flags)
    if "PileUpTools" not in kwargs:
        PileUpTools = acc.popToolsAndMerge(sTGC_DigitizationToolCfg(flags))
        kwargs["PileUpTools"] = PileUpTools
    acc.merge(PileUpToolsCfg(flags, **kwargs))
    return acc
 
 
def sTGC_OverlayDigitizationBasicCfg(flags, **kwargs):
    """Return ComponentAccumulator with sTGC Overlay digitization"""
    acc = MuonGeoModelCfg(flags)
    if flags.Common.ProductionStep != ProductionStep.FastChain:
        from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
        if flags.Muon.usePhaseIIGeoSetup:
            acc.merge(SGInputLoaderCfg(flags, ["xAOD::MuonSimHitContainer#xStgcSimHits",
                                               "xAOD::MuonSimHitAuxContainer#xStgcSimHitsAux."]))
        else:
            acc.merge(SGInputLoaderCfg(flags, ["sTGCSimHitCollection#sTGC_Hits"]))
    kwargs.setdefault("DigitizationTool", acc.popToolsAndMerge(sTGC_OverlayDigitizationToolCfg(flags)))
 
    if flags.Concurrency.NumThreads > 0:
        kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
 
    # Set common overlay extra inputs
    kwargs.setdefault("ExtraInputs", flags.Overlay.ExtraInputs)
 
    the_alg = CompFactory.MuonDigitizer(name="STGC_OverlayDigitizer", **kwargs)
    acc.addEventAlgo(the_alg)
    return acc
 
 
# with output defaults
def sTGC_DigitizationCfg(flags, **kwargs):
    """Return ComponentAccumulator for sTGC digitization and Output"""
    acc = sTGC_DigitizationBasicCfg(flags, **kwargs)
    acc.merge(sTGC_OutputCfg(flags))
    return acc
 
 
def sTGC_DigitizationDigitToRDOCfg(flags):
    """Return ComponentAccumulator with sTGC digitization and Digit to TGCRDO"""
    acc = sTGC_DigitizationCfg(flags)
    acc.merge(STGC_DigitToRDOCfg(flags))
    return acc