def getTRTOverlay(name="TRTOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
from Digitization.DigitizationFlags import digitizationFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "TRT_RDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "TRT_RDOs")
kwargs.setdefault("OutputKey", "TRT_RDOs")
kwargs.setdefault("SignalInputSDOKey",
overlayFlags.sigPrefix() + "TRT_SDO_Map")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+TRT_RDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+TRT_RDOs")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+TRT_RDOs")
kwargs.setdefault("SignalInputSDOKey",
overlayFlags.evtStore() + "+TRT_SDO_Map")
kwargs.setdefault("TRT_LocalOccupancyTool", "TRT_LocalOccupancy")
# HT hit correction fraction
kwargs.setdefault("TRT_HT_OccupancyCorrectionBarrel", 0.110)
kwargs.setdefault("TRT_HT_OccupancyCorrectionEndcap", 0.090)
kwargs.setdefault("TRT_HT_OccupancyCorrectionBarrelNoE", 0.060)
kwargs.setdefault("TRT_HT_OccupancyCorrectionEndcapNoE", 0.050)
return CfgMgr.TRTOverlay(name, **kwargs)
def BCM_OverlayDigitizationTool(name="BCM_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
# Disable the noise
kwargs.setdefault("ModNoise", [0., 0., 0., 0., 0., 0., 0., 0.])
return BCM_DigitizationTool(name, **kwargs)
def getTTL1Overlay(name="OverlayTTL1", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgEmTTL1Key", overlayFlags.bkgPrefix() + "LArTTL1EM")
kwargs.setdefault("SignalEmTTL1Key", overlayFlags.sigPrefix() + "LArTTL1EM")
kwargs.setdefault("OutputEmTTL1Key", "LArTTL1EM")
kwargs.setdefault("BkgHadTTL1Key", overlayFlags.bkgPrefix() + "LArTTL1HAD")
kwargs.setdefault("SignalHadTTL1Key", overlayFlags.sigPrefix() + "LArTTL1HAD")
kwargs.setdefault("OutputHadTTL1Key", "LArTTL1HAD")
kwargs.setdefault("BkgTileTTL1Key", overlayFlags.bkgPrefix() + "TileTTL1Cnt")
kwargs.setdefault("SignalTileTTL1Key", overlayFlags.sigPrefix() + "TileTTL1Cnt")
kwargs.setdefault("OutputTileTTL1Key", "TileTTL1Cnt")
kwargs.setdefault("BkgTileMBTSTTL1Key", overlayFlags.bkgPrefix() + "TileTTL1MBTS")
kwargs.setdefault("SignalTileMBTSTTL1Key", overlayFlags.sigPrefix() + "TileTTL1MBTS")
kwargs.setdefault("OutputTileMBTSTTL1Key", "TileTTL1MBTS")
else:
kwargs.setdefault("BkgEmTTL1Key", overlayFlags.dataStore() + "+LArTTL1EM")
kwargs.setdefault("SignalEmTTL1Key", overlayFlags.evtStore() + "+LArTTL1EM")
kwargs.setdefault("OutputEmTTL1Key", overlayFlags.outputStore() + "+LArTTL1EM")
kwargs.setdefault("BkgHadTTL1Key", overlayFlags.dataStore() + "+LArTTL1HAD")
kwargs.setdefault("SignalHadTTL1Key", overlayFlags.evtStore() + "+LArTTL1HAD")
kwargs.setdefault("OutputHadTTL1Key", overlayFlags.outputStore() + "+LArTTL1HAD")
kwargs.setdefault("BkgTileTTL1Key", overlayFlags.dataStore() + "+TileTTL1Cnt")
kwargs.setdefault("SignalTileTTL1Key", overlayFlags.evtStore() + "+TileTTL1Cnt")
kwargs.setdefault("OutputTileTTL1Key", overlayFlags.outputStore() + "+TileTTL1Cnt")
kwargs.setdefault("BkgTileMBTSTTL1Key", overlayFlags.dataStore() + "+TileTTL1MBTS")
kwargs.setdefault("SignalTileMBTSTTL1Key", overlayFlags.evtStore() + "+TileTTL1MBTS")
kwargs.setdefault("OutputTileMBTSTTL1Key", overlayFlags.outputStore() + "+TileTTL1MBTS")
return CfgMgr.LVL1__OverlayTTL1(name, **kwargs)
def MdtRawDataProviderTool(name="MdtRawDataProviderTool", **kwargs):
kwargs.setdefault("Decoder", "MdtROD_Decoder")
if DetFlags.overlay.MDT_on() and overlayFlags.isDataOverlay():
if overlayFlags.isOverlayMT():
kwargs.setdefault("RdoLocation",
overlayFlags.bkgPrefix() + "MDTCSM")
else:
kwargs.setdefault("RdoLocation",
overlayFlags.dataStore() + "+MDTCSM")
return CfgMgr.Muon__MDT_RawDataProviderToolMT(name, **kwargs)
def CscRawDataProviderTool(name="CscRawDataProviderTool", **kwargs):
kwargs.setdefault("Decoder", "CscROD_Decoder")
if DetFlags.overlay.CSC_on() and overlayFlags.isDataOverlay():
if overlayFlags.isOverlayMT():
kwargs.setdefault("RdoLocation",
overlayFlags.bkgPrefix() + "CSCRDO")
else:
kwargs.setdefault("RdoLocation",
overlayFlags.dataStore() + "+CSCRDO")
return CfgMgr.Muon__CSC_RawDataProviderToolMT(name, **kwargs)
def BCM_DigitizationTool(name="BCM_DigitizationTool", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
kwargs.setdefault("HitCollName", "BCMHits")
if not digitizationFlags.doInDetNoise.get_Value():
kwargs.setdefault("ModNoise", [0., 0., 0., 0., 0., 0., 0., 0.])
else:
kwargs.setdefault(
"ModNoise",
[90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82])
kwargs.setdefault("ModSignal",
[450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0])
kwargs.setdefault("NinoThr",
[330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0])
kwargs.setdefault("EffDistanceParam", 4.0)
kwargs.setdefault("EffSharpnessParam", 0.11)
kwargs.setdefault("TimeDelay", 9.0)
kwargs.setdefault("MIPDeposit", 0.33) # BCM with diamond
#kwargs.setdefault("MIPDeposit", 0.25) # BCM with graphite
if digitizationFlags.doXingByXingPileUp():
kwargs.setdefault("FirstXing", BCM_FirstXing())
kwargs.setdefault("LastXing", BCM_LastXing())
from AthenaCommon.GlobalFlags import globalflags
if globalflags.isOverlay():
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputRDOKey",
overlayFlags.sigPrefix() + "BCM_RDOs")
kwargs.setdefault("OutputSDOKey",
overlayFlags.sigPrefix() + "BCM_SDO_Map")
else:
kwargs.setdefault("OutputRDOKey",
overlayFlags.evtStore() + "+BCM_RDOs")
kwargs.setdefault("OutputSDOKey",
overlayFlags.evtStore() + "+BCM_SDO_Map")
else:
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("OutputRDOKey",
overlayFlags.bkgPrefix() + "BCM_RDOs")
kwargs.setdefault("OutputSDOKey",
overlayFlags.bkgPrefix() + "BCM_SDO_Map")
else:
kwargs.setdefault("OutputRDOKey", "BCM_RDOs")
kwargs.setdefault("OutputSDOKey", "BCM_SDO_Map")
from AthenaCommon import CfgMgr
return CfgMgr.BCM_DigitizationTool(name, **kwargs)
def getMM_RdoToDigitAlg(name="MM_RdoToDigitAlg", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("MmRdoContainer", overlayFlags.bkgPrefix() + "MMRDO")
kwargs.setdefault("MmDigitContainer",
overlayFlags.bkgPrefix() + "MM_DIGITS")
else:
kwargs.setdefault("EvtStore", overlayFlags.dataStore())
kwargs.setdefault("MmRdoContainer",
overlayFlags.dataStore() + "+MMRDO")
kwargs.setdefault("MmDigitContainer",
overlayFlags.dataStore() + "+MM_DIGITS")
return CfgMgr.MM_RdoToDigit(name, **kwargs)
def getRpcRdoToRpcDigitAlg(name="RpcRdoToRpcDigitAlg", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("RpcRdoContainer",
overlayFlags.bkgPrefix() + "RPCPAD")
kwargs.setdefault("RpcDigitContainer",
overlayFlags.bkgPrefix() + "RPC_DIGITS")
else:
kwargs.setdefault("EvtStore", overlayFlags.dataStore())
kwargs.setdefault("RpcRdoContainer",
overlayFlags.dataStore() + "+RPCPAD")
kwargs.setdefault("RpcDigitContainer",
overlayFlags.dataStore() + "+RPC_DIGITS")
return CfgMgr.RpcRdoToRpcDigit(name, **kwargs)
def getTgcRdoToTgcDigitAlg(name="TgcRdoToTgcDigitAlg", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("TgcRdoContainer",
overlayFlags.bkgPrefix() + "TGCRDO")
kwargs.setdefault("TgcDigitContainer",
overlayFlags.bkgPrefix() + "TGC_DIGITS")
else:
kwargs.setdefault("EvtStore", overlayFlags.dataStore())
kwargs.setdefault("TgcRdoContainer",
overlayFlags.dataStore() + "+TGCRDO")
kwargs.setdefault("TgcDigitContainer",
overlayFlags.dataStore() + "+TGC_DIGITS")
return CfgMgr.TgcRdoToTgcDigit(name, **kwargs)
def MM_OverlayDigitizationTool(name="MM_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "MM_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "MM_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+MM_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+MM_SDO")
return MM_DigitizationTool(name, **kwargs)
def CscDigitToCscRDOTool4(name, **kwargs):
kwargs.setdefault("NumSamples", 4)
kwargs.setdefault("addNoise", False)
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("InputObjectName",
overlayFlags.sigPrefix() + "CSC_DIGITS")
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "CSCRDO")
else:
kwargs.setdefault("InputObjectName",
overlayFlags.evtStore() + "+CSC_DIGITS")
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+CSCRDO")
return BaseCscDigitToCscRDOTool(name, **kwargs)
def getTgcTruthOverlay(name="TgcTruthOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isDataOverlay():
kwargs.setdefault("BkgInputKey", "")
else:
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "TGC_SDO")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+TGC_SDO")
if overlayFlags.isOverlayMT():
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "TGC_SDO")
kwargs.setdefault("OutputKey", "TGC_SDO")
else:
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+TGC_SDO")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+TGC_SDO")
return CfgMgr.MuonSimDataOverlay(name, **kwargs)
def getCscOverlay(name="CscOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey", overlayFlags.bkgPrefix() + "CSCRDO")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "CSCRDO")
kwargs.setdefault("OutputKey", "CSCRDO")
else:
kwargs.setdefault("BkgInputKey", overlayFlags.dataStore() + "+CSCRDO")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+CSCRDO")
kwargs.setdefault("OutputKey", "StoreGateSvc+CSCRDO")
kwargs.setdefault("isDataOverlay", overlayFlags.isDataOverlay())
from AthenaCommon import CfgMgr
return CfgMgr.CscOverlay(name, **kwargs)
def SCT_OverlayDigitizationTool(name="SCT_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "SCT_RDOs")
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "SCT_SDO_Map")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+SCT_RDOs")
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+SCT_SDO_Map")
kwargs.setdefault("HardScatterSplittingMode", 0)
return commonSCT_DigitizationConfig(name, **kwargs)
def getCscOverlayDigitizationTool(name="CscOverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "CSC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("CSCSimDataCollectionOutputName",
overlayFlags.sigPrefix() + "CSC_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+CSC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("CSCSimDataCollectionOutputName",
overlayFlags.evtStore() + "+CSC_SDO")
return getCscDigitizationToolBase(name, **kwargs)
def Tgc_OverlayDigitizationTool(name="Tgc_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "TGC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "TGC_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+TGC_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+TGC_SDO")
return TgcDigitizationTool(name, **kwargs)
def PixelOverlayDigitizationTool(name="PixelOverlayDigitizationTool",
**kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("RDOCollName",
overlayFlags.sigPrefix() + "PixelRDOs")
kwargs.setdefault("SDOCollName",
overlayFlags.sigPrefix() + "PixelSDO_Map")
else:
kwargs.setdefault("RDOCollName",
overlayFlags.evtStore() + "+PixelRDOs")
kwargs.setdefault("SDOCollName",
overlayFlags.evtStore() + "+PixelSDO_Map")
kwargs.setdefault("HardScatterSplittingMode", 0)
return BasicPixelDigitizationTool(name, **kwargs)
def getSCTSDOOverlay(name="SCTSDOOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
# We do not need background SCT SDOs
kwargs.setdefault("BkgInputKey", "")
if overlayFlags.isOverlayMT():
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "SCT_SDO_Map")
kwargs.setdefault("OutputKey", "SCT_SDO_Map")
else:
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+SCT_SDO_Map")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+SCT_SDO_Map")
return CfgMgr.InDetSDOOverlay(name, **kwargs)
def Mdt_OverlayDigitizationTool(name="Mdt_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "MDT_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "MDT_SDO")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+MDT_DIGITS")
if not overlayFlags.isDataOverlay():
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+MDT_SDO")
kwargs.setdefault("GetT0FromBD", overlayFlags.isDataOverlay())
return MdtDigitizationTool(name, **kwargs)
def getRpcOverlay(name="RpcOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "RPC_DIGITS")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "RPC_DIGITS")
kwargs.setdefault("OutputKey", "RPC_DIGITS")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+RPC_DIGITS")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+RPC_DIGITS")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+RPC_DIGITS")
return CfgMgr.RpcOverlay(name, **kwargs)
def getPixelOverlay(name="PixelOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "PixelRDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "PixelRDOs")
kwargs.setdefault("OutputKey", "PixelRDOs")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+PixelRDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+PixelRDOs")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+PixelRDOs")
return CfgMgr.PixelOverlay(name, **kwargs)
def TRT_OverlayDigitizationTool(name="TRT_OverlayDigitizationTool", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault("OutputObjectName",
overlayFlags.sigPrefix() + "TRT_RDOs")
kwargs.setdefault("OutputSDOName",
overlayFlags.sigPrefix() + "TRT_SDO_Map")
else:
kwargs.setdefault("OutputObjectName",
overlayFlags.evtStore() + "+TRT_RDOs")
kwargs.setdefault("OutputSDOName",
overlayFlags.evtStore() + "+TRT_SDO_Map")
kwargs.setdefault("HardScatterSplittingMode", 0)
kwargs.setdefault("Override_getT0FromData", 0)
kwargs.setdefault("Override_noiseInSimhits", 0)
kwargs.setdefault("Override_noiseInUnhitStraws", 0)
kwargs.setdefault("Override_isOverlay", 1)
return BasicTRTDigitizationTool(name, **kwargs)
def getBCMOverlay(name="BCMOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("isDataOverlay", overlayFlags.isDataOverlay())
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "BCM_RDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "BCM_RDOs")
kwargs.setdefault("OutputKey", "BCM_RDOs")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+BCM_RDOs")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+BCM_RDOs")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+BCM_RDOs")
return CfgMgr.BCMOverlay(name, **kwargs)
def getMM_Overlay(name="MM_Overlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "MM_DIGITS")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "MM_DIGITS")
kwargs.setdefault("OutputKey", "MM_DIGITS")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+MM_DIGITS")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+MM_DIGITS")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+MM_DIGITS")
kwargs.setdefault("IntegrationWindow", 30) # in ns
return CfgMgr.MM_Overlay(name, **kwargs)
def getTRTSDOOverlay(name="TRTSDOOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
if overlayFlags.isDataOverlay():
kwargs.setdefault("BkgInputKey", "")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "TRT_SDO_Map")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "TRT_SDO_Map")
kwargs.setdefault("OutputKey", "TRT_SDO_Map")
else:
if overlayFlags.isDataOverlay():
kwargs.setdefault("BkgInputKey", "")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+TRT_SDO_Map")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+TRT_SDO_Map")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+TRT_SDO_Map")
return CfgMgr.InDetSDOOverlay(name, **kwargs)
def getLArPileUpTool(
name='LArPileUpTool',
**kwargs
): ## useLArFloat()=True,isOverlay()=False,outputKey='LArDigitContainer_MC'):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
from AthenaCommon.Logging import logging
mlog = logging.getLogger('LArPileUpToolDefault:')
mlog.info(" ---- in getLArPileUpTool ")
# the LAr and Calo detector description package
## FIXME includes to be replaced by confGetter configuration.
if not isOverlay():
from AthenaCommon.Resilience import protectedInclude
protectedInclude(
"CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py")
protectedInclude("LArDetDescr/LArDetDescr_joboptions.py")
protectedInclude(
"LArConditionsCommon/LArConditionsCommon_MC_jobOptions.py")
else:
if overlayFlags.isDataOverlay():
#Shape taken from real-data DB has a different SG key
kwargs.setdefault('ShapeKey', "LArShape")
from Digitization.DigitizationFlags import digitizationFlags
kwargs.setdefault('NoiseOnOff', digitizationFlags.doCaloNoise.get_Value())
kwargs.setdefault('DoDigiTruthReconstruction',
digitizationFlags.doDigiTruth())
if digitizationFlags.doXingByXingPileUp():
kwargs.setdefault('FirstXing', -751)
kwargs.setdefault('LastXing', 101)
from LArDigitization.LArDigitizationFlags import jobproperties
# check if using high gain for Fcal or not
if (not jobproperties.LArDigitizationFlags.useFcalHighGain()) and (
not isOverlay()):
mlog.info("do not use high gain in Fcal digitization ")
kwargs.setdefault('HighGainThreshFCAL', 0)
else:
mlog.info("use high gain in Fcal digitization or overlay job")
# check if using high gain for EMEC IW or not
if (not jobproperties.LArDigitizationFlags.useEmecIwHighGain()) and (
not isOverlay()):
mlog.info("do not use high gain in EMEC IW digitization ")
kwargs.setdefault('HighGainThreshEMECIW', 0)
kwargs.setdefault('RndmEvtOverlay', isOverlay())
if useLArFloat():
kwargs.setdefault("LArHitContainers", [])
else:
kwargs.setdefault("LArHitFloatContainers", [])
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault('DigitContainer',
overlayFlags.bkgPrefix() + 'LArDigitContainer_MC')
else:
kwargs.setdefault(
'DigitContainer',
'LArDigitContainer_MC') ##FIXME - should not be hard-coded
# if doing MC+MC overlay
from AthenaCommon.GlobalFlags import globalflags
if isOverlay() and globalflags.DataSource() == 'geant4':
kwargs.setdefault('isMcOverlay', True)
from LArROD.LArRODFlags import larRODFlags
kwargs.setdefault('Nsamples', larRODFlags.nSamples())
kwargs.setdefault('firstSample', larRODFlags.firstSample())
if isOverlay():
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("OnlyUseContainerName", False)
kwargs.setdefault(
'InputDigitContainer',
overlayFlags.bkgPrefix() + 'LArDigitContainer_MC')
else:
kwargs.setdefault('InputDigitContainer', 'LArDigitContainer_MC')
# ADC2MeVCondAlgo
from LArRecUtils.LArADC2MeVCondAlgDefault import LArADC2MeVCondAlgDefault
LArADC2MeVCondAlgDefault()
# AutoCorrNoiseCondAlgo
if not isOverlay():
from LArRecUtils.LArAutoCorrNoiseCondAlgDefault import LArAutoCorrNoiseCondAlgDefault
LArAutoCorrNoiseCondAlgDefault()
# bad channel masking
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker = LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.DoMasking = True
theLArRCBMasker.ProblemsToMask = ["deadReadout", "deadPhys"]
kwargs.setdefault('MaskingTool', theLArRCBMasker)
# CosmicTriggerTimeTool for cosmics digitization
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType == "cosmics":
from CommissionUtils.CommissionUtilsConf import CosmicTriggerTimeTool
from AthenaCommon.AppMgr import ToolSvc
theTriggerTimeTool = CosmicTriggerTimeTool()
ToolSvc += theTriggerTimeTool
kwargs.setdefault('UseTriggerTime', True)
kwargs.setdefault('TriggerTimeToolName', theTriggerTimeTool)
# pileup configuration "algorithm" way
if not digitizationFlags.doXingByXingPileUp():
from AthenaCommon.DetFlags import DetFlags
if DetFlags.pileup.LAr_on() or isOverlay():
kwargs.setdefault('PileUp', True)
kwargs.setdefault('useLArFloat', useLArFloat())
if useLArFloat():
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from SGComps.SGCompsConf import AddressRemappingSvc
AddressRemappingSvc = AddressRemappingSvc()
svcMgr += AddressRemappingSvc
from AthenaCommon.ConfigurableDb import getConfigurable
svcMgr += getConfigurable("ProxyProviderSvc")()
svcMgr.ProxyProviderSvc.ProviderNames += ["AddressRemappingSvc"]
svcMgr.AddressRemappingSvc.TypeKeyOverwriteMaps = [
"LArHitContainer#LArHitEMB->LArHitFloatContainer#LArHitEMB",
"LArHitContainer#LArHitEMEC->LArHitFloatContainer#LArHitEMEC",
"LArHitContainer#LArHitHEC->LArHitFloatContainer#LArHitHEC",
"LArHitContainer#LArHitFCAL->LArHitFloatContainer#LArHitFCAL"
]
svcMgr.AddressRemappingSvc.ProxyDict = "ActiveStoreSvc"
return CfgMgr.LArPileUpTool(name, **kwargs)
if DetFlags.overlay.LAr_on():
# FIXME this is for doing Overlay with MC RDO + MC hits
# real data RDO will require some changes in the setup for proper db acces
#include( "LArDetDescr/LArDetDescr_joboptions.py" )
#include( "LArAthenaPool/LArAthenaPool_joboptions.py" )
# We also need the conditions svc for MC constants:
if overlayFlags.isDataOverlay():
from LArROD.LArRODFlags import larRODFlags
larRODFlags.keepDSPRaw = False
from LArByteStream.LArByteStreamConf import LArRawDataReadingAlg
try:
#inhibit the reading of LArawChanels, they are created offline from the overlaid LArDigits:
job.LArRawDataReadingAlg.LArRawChannelKey = ""
#Configure the reading of the background digits from ByteStream
if overlayFlags.isOverlayMT():
job.LArRawDataReadingAlg.LArDigitKey = "FREE"
else:
job.LArRawDataReadingAlg.LArDigitKey = overlayFlags.dataStore(
) + "+FREE"
except AttributeError:
#in case the LArRawDataReadingAlg was not set up by someone:
if overlayFlags.isOverlayMT():
job += LArRawDataReadingAlg(LArRawChannelKey="",
LArDigitKey="FREE")
else:
job += LArRawDataReadingAlg(
LArRawChannelKey="",
LArDigitKey=overlayFlags.dataStore() + "+FREE")
pass
ServiceMgr.ByteStreamAddressProviderSvc.TypeNames += [
"MuCTPI_RDO/MUCTPI_RDO", "L2Result/L2Result", "CTP_RDO/CTP_RDO",
"ROIB::RecRoIBResult/RecRoIBResult", "MuCTPI_RIO/MUCTPI_RIO",
"CTP_RIO/CTP_RIO"
]
if DetFlags.simulateLVL1.LAr_on():
include("LArL1Sim/LArL1Sim_G4_jobOptions.py")
# Noise
if not digitizationFlags.doCaloNoise.get_Value():
job.LArTTL1Maker.NoiseOnOff = False #(default:True)
# PileUp
job.LArTTL1Maker.PileUp = True
# If we are doing MC overlay
if not overlayFlags.isDataOverlay():
if overlayFlags.isOverlayMT():
job.LArTTL1Maker.EmTTL1ContainerName = overlayFlags.sigPrefix(
) + "LArTTL1EM"
job.LArTTL1Maker.HadTTL1ContainerName = overlayFlags.sigPrefix(
) + "LArTTL1HAD"
else:
job.LArTTL1Maker.EmTTL1ContainerName = overlayFlags.evtStore(
) + "+LArTTL1EM"
job.LArTTL1Maker.HadTTL1ContainerName = overlayFlags.evtStore(
) + "+LArTTL1HAD"
if DetFlags.simulateLVL1.Tile_on():
include("TileSimAlgs/TileTTL1_jobOptions.py")
# If we are doing MC overlay
if not overlayFlags.isDataOverlay():
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
# Always schedule beam spot conditions for digi
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
if not hasattr(condSeq, "BeamSpotCondAlg"):
from IOVDbSvc.CondDB import conddb
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/Beampos", "/Indet/Beampos", className="AthenaAttributeList")
from BeamSpotConditions.BeamSpotConditionsConf import BeamSpotCondAlg
condSeq += BeamSpotCondAlg("BeamSpotCondAlg")
# Add beam spot fixer
from AthenaCommon import CfgGetter
from AthenaCommon.DetFlags import DetFlags
from AthenaCommon.GlobalFlags import globalflags
from Digitization.DigitizationFlags import digitizationFlags
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if (DetFlags.pileup.any_on() or digitizationFlags.doXingByXingPileUp()) or (globalflags.isOverlay() and not overlayFlags.isOverlayMT()):
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
job += CfgGetter.getAlgorithm("BeamSpotFixerAlg")
