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 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 PixelDigitizationTool(name="PixelDigitizationTool", **kwargs):
kwargs.setdefault("HardScatterSplittingMode", 0)
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("RDOCollName",
overlayFlags.bkgPrefix() + "PixelRDOs")
kwargs.setdefault("SDOCollName",
overlayFlags.bkgPrefix() + "PixelSDO_Map")
else:
kwargs.setdefault("RDOCollName", "PixelRDOs")
kwargs.setdefault("SDOCollName", "PixelSDO_Map")
return BasicPixelDigitizationTool(name, **kwargs)
def TRTDigitizationTool(name="TRTDigitizationTool", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("OutputObjectName",
overlayFlags.bkgPrefix() + "TRT_RDOs")
kwargs.setdefault("OutputSDOName",
overlayFlags.bkgPrefix() + "TRT_SDO_Map")
else:
kwargs.setdefault("OutputObjectName", "TRT_RDOs")
kwargs.setdefault("OutputSDOName", "TRT_SDO_Map")
kwargs.setdefault("HardScatterSplittingMode", 0)
return BasicTRTDigitizationTool(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 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 getLArRawChannelBuilder(name="LArRawChannelBuilder" , **kwargs):
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault('LArRawChannelKey', "LArRawChannels")
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi():
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault('LArDigitKey', overlayFlags.bkgPrefix() + 'LArDigitContainer_MC')
else:
kwargs.setdefault('LArDigitKey', 'LArDigitContainer_MC')
#Call required Cond-Algos:
from LArRecUtils.LArAutoCorrTotalCondAlgDefault import LArAutoCorrTotalCondAlgDefault
from LArRecUtils.LArOFCCondAlgDefault import LArOFCCondAlgDefault
from LArRecUtils.LArADC2MeVCondAlgDefault import LArADC2MeVCondAlgDefault
#The order matters when running w/o MT
LArADC2MeVCondAlgDefault()
LArAutoCorrTotalCondAlgDefault()
LArOFCCondAlgDefault()
kwargs.setdefault("ShapeKey","LArShapeSym")
from LArROD.LArRODFlags import larRODFlags
kwargs.setdefault('firstSample',larRODFlags.firstSample())
return CfgMgr.LArRawChannelBuilderAlg(name, **kwargs)
def configure(self):
mlog = logging.getLogger( 'TileL2FromRawChGetter::configure:' )
mlog.info ('entering')
# get handle to upstream object
try:
from TileL2Algs.TileL2FromRawChGetter import TileL2FromRawChGetter
theTileL2FromRawChGetter=TileL2FromRawChGetter()
except Exception:
mlog.error("could not get handle to TileL2FromRawChGetter Quit")
traceback.print_exc()
return False
if not theTileL2FromRawChGetter.usable():
if not self.ignoreConfigError():
mlog.error("TileL2FromRawChGetter unusable. Quit.")
return False
else:
mlog.error("TileL2FromRawChGetter unusable. Continue nevertheless")
# Instantiation of the C++ algorithm
try:
from TileL2Algs.TileL2AlgsConf import TileRawChannelToL2
except Exception:
mlog.error("could not import TileL2Algs.TileRawChannelToL2")
traceback.print_exc()
return False
theTileRawChannelToL2=TileRawChannelToL2()
self._TileRawChannelToL2Handle = theTileRawChannelToL2
# sets output key
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi():
from OverlayCommonAlgs.OverlayFlags import overlayFlags
theTileRawChannelToL2.TileL2Container = overlayFlags.bkgPrefix() + self.outputKey()
else:
theTileRawChannelToL2.TileL2Container = self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(),self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding to topSequence")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theTileRawChannelToL2
return True
def CscDigitToCscRDOTool(name, **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("OutputObjectName",
overlayFlags.bkgPrefix() + "CSCRDO")
else:
kwargs.setdefault("OutputObjectName", "CSCRDO")
return BaseCscDigitToCscRDOTool(name, **kwargs)
def getRpcDigitToRpcRDO(name="RpcDigitToRpcRDO", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("OutputObjectName",
overlayFlags.bkgPrefix() + "RPCPAD")
else:
kwargs.setdefault("OutputObjectName", "RPCPAD")
return CfgMgr.RpcDigitToRpcRDO(name, **kwargs)
def getEventInfoOverlay(name="EventInfoOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("BkgInputKey", overlayFlags.bkgPrefix() + "EventInfo")
kwargs.setdefault("SignalInputKey", overlayFlags.sigPrefix() + "EventInfo")
kwargs.setdefault("OutputKey", "EventInfo")
kwargs.setdefault("DataOverlay", overlayFlags.isDataOverlay())
return CfgMgr.xAODMaker__EventInfoOverlay(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 MergeMuonExitLayerTool(name="MergeMuonExitLayerTool", **kwargs):
kwargs.setdefault("TrackRecordCollKey", "MuonExitLayer")
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("TrackRecordCollOutputKey",
overlayFlags.bkgPrefix() + "MuonExitLayer")
else:
kwargs.setdefault("TrackRecordCollOutputKey", "MuonExitLayer")
return MergeTrackRecordCollTool(name, **kwargs)
def getMergeTruthJetsTool(name="MergeTruthJetsTool", **kwargs):
if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
kwargs.setdefault("FirstXing", TruthJet_FirstXing())
kwargs.setdefault("LastXing", TruthJet_LastXing())
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("InTimeOutputTruthJetCollKey",
overlayFlags.bkgPrefix() + "InTimeAntiKt4TruthJets")
kwargs.setdefault(
"OutOfTimeTruthJetCollKey",
overlayFlags.bkgPrefix() + "OutOfTimeAntiKt4TruthJets")
else:
kwargs.setdefault("InTimeOutputTruthJetCollKey",
"InTimeAntiKt4TruthJets")
kwargs.setdefault("OutOfTimeTruthJetCollKey",
"OutOfTimeAntiKt4TruthJets")
return CfgMgr.MergeTruthJetsTool(name, **kwargs)
def getCscDigitizationTool(name="CscDigitizationTool", **kwargs):
kwargs.setdefault("InputObjectName", "CSC_Hits")
kwargs.setdefault("OutputObjectName", "CSC_DIGITS")
if jobproperties.Digitization.PileUpPremixing and 'OverlayMT' in jobproperties.Digitization.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("CSCSimDataCollectionOutputName",
overlayFlags.bkgPrefix() + "CSC_SDO")
else:
kwargs.setdefault("CSCSimDataCollectionOutputName", "CSC_SDO")
return getCscDigitizationToolBase(name, **kwargs)
def getInTimeOnlyNewMergeMcEventCollTool_HaloGas(
name="InTimeOnlyNewMergeMcEventCollTool_HaloGas", **kwargs):
from Digitization import PileUpEventType
kwargs.setdefault("PileUpType", PileUpEventType.HaloGas)
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("TruthCollOutputKey",
overlayFlags.bkgPrefix() + "TruthEvent_HaloGas")
else:
kwargs.setdefault("TruthCollOutputKey", "TruthEvent_HaloGas")
return getInTimeOnlyNewMergeMcEventCollTool_Base(name, **kwargs)
def getBeamSpotFixerAlg(name="BeamSpotFixerAlg", **kwargs):
kwargs.setdefault('InputKey', 'Input_EventInfo')
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault('OutputKey', overlayFlags.bkgPrefix() + 'EventInfo')
else:
kwargs.setdefault('OutputKey', 'EventInfo')
return CfgMgr.Simulation__BeamSpotFixerAlg(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 MergeRecoTimingObjTool(name="MergeRecoTimingObjTool", **kwargs):
if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
kwargs.setdefault("FirstXing", TimingObj_FirstXing())
kwargs.setdefault("LastXing", TimingObj_LastXing())
kwargs.setdefault("RecoTimingObjInputKey", "EVNTtoHITS_timings")
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("RecoTimingObjOutputKey",
overlayFlags.bkgPrefix() + "EVNTtoHITS_timings")
else:
kwargs.setdefault("RecoTimingObjOutputKey", "EVNTtoHITS_timings")
return CfgMgr.MergeRecoTimingObjTool(name, **kwargs)
def getStandardPileUpToolsAlg(name="StandardPileUpToolsAlg", **kwargs):
kwargs.setdefault('PileUpTools', getStandardPileUpToolsList())
kwargs.setdefault('ExtraInputs', [('xAOD::EventInfo', 'EventInfo')])
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.doXingByXingPileUp():
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault('EventInfoKey',
overlayFlags.bkgPrefix() + 'EventInfo')
else:
kwargs.setdefault('EventInfoKey', 'EventInfo')
return CfgMgr.PileUpToolsAlg(name, **kwargs)
else:
return CfgMgr.DigitizationAlg(name, **kwargs)
def TgcDigitizationTool(name="TgcDigitizationTool", **kwargs):
if jobproperties.Digitization.doXingByXingPileUp(): # PileUpTool approach
# This should match the range for the TGC in Simulation/Digitization/share/MuonDigitization.py
kwargs.setdefault("FirstXing", TGC_FirstXing())
kwargs.setdefault("LastXing", TGC_LastXing())
kwargs.setdefault("OutputObjectName", "TGC_DIGITS")
if jobproperties.Digitization.PileUpPremixing and 'OverlayMT' in jobproperties.Digitization.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("OutputSDOName",
overlayFlags.bkgPrefix() + "TGC_SDO")
else:
kwargs.setdefault("OutputSDOName", "TGC_SDO")
return CfgMgr.TgcDigitizationTool(name, **kwargs)
def getNewMergeMcEventCollTool_Base(name="NewMergeMcEventCollTool_Base",
**kwargs):
if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
kwargs.setdefault("FirstXing", -30000)
kwargs.setdefault("LastXing", 30000)
if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("TruthCollOutputKey",
overlayFlags.bkgPrefix() + "TruthEvent")
else:
kwargs.setdefault("TruthCollOutputKey", "TruthEvent")
kwargs.setdefault("TruthCollInputKey", "TruthEvent")
if not digitizationFlags.doXingByXingPileUp(): # Algorithm approach
kwargs.setdefault("PileUpMergeSvc", "PileUpMergeSvc")
# Default `PileUpType` to "Unknown"
kwargs.setdefault("PileUpType", -1)
return CfgMgr.NewMergeMcEventCollTool(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 getTgcOverlay(name="TgcOverlay", **kwargs):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.isOverlayMT():
kwargs.setdefault("BkgInputKey",
overlayFlags.bkgPrefix() + "TGC_DIGITS")
kwargs.setdefault("SignalInputKey",
overlayFlags.sigPrefix() + "TGC_DIGITS")
kwargs.setdefault("OutputKey", "TGC_DIGITS")
else:
kwargs.setdefault("BkgInputKey",
overlayFlags.dataStore() + "+TGC_DIGITS")
kwargs.setdefault("SignalInputKey",
overlayFlags.evtStore() + "+TGC_DIGITS")
kwargs.setdefault("OutputKey",
overlayFlags.outputStore() + "+TGC_DIGITS")
return CfgMgr.TgcOverlay(name, **kwargs)
def MdtDigitizationTool(name="MdtDigitizationTool", **kwargs):
import MuonCondAlg.MdtCondDbAlgConfig # MT-safe conditions access
kwargs.setdefault("MaskedStations", [])
kwargs.setdefault("UseDeadChamberSvc", True)
kwargs.setdefault("DiscardEarlyHits", True)
kwargs.setdefault("UseTof", jobproperties.Beam.beamType != "cosmics")
if 'RT_Relation_DB_DigiTool' in jobproperties.Digitization.experimentalDigi(
):
kwargs.setdefault("DigitizationTool", "RT_Relation_DB_DigiTool")
else:
kwargs.setdefault("DigitizationTool", "MDT_Response_DigiTool")
if jobproperties.Digitization.specialConfiguration.statusOn:
specialConfigDict = jobproperties.Digitization.specialConfiguration.get_Value(
)
if 'MDT_QballConfig' in specialConfigDict.keys():
kwargs.setdefault("DoQballCharge",
(specialConfigDict['MDT_QballConfig'] == 'True'))
else:
kwargs.setdefault("DoQballCharge", False)
else:
kwargs.setdefault("DoQballCharge", False)
if jobproperties.Digitization.doXingByXingPileUp():
kwargs.setdefault(
"FirstXing", MDT_FirstXing()
) # this should match the range for the MDT in Digitization/share/MuonDigitization.py
kwargs.setdefault(
"LastXing", MDT_LastXing()
) # this should match the range for the MDT in Digitization/share/MuonDigitization.py
kwargs.setdefault("OutputObjectName", "MDT_DIGITS")
if jobproperties.Digitization.PileUpPremixing and 'OverlayMT' in jobproperties.Digitization.experimentalDigi(
):
from OverlayCommonAlgs.OverlayFlags import overlayFlags
kwargs.setdefault("OutputSDOName",
overlayFlags.bkgPrefix() + "MDT_SDO")
else:
kwargs.setdefault("OutputSDOName", "MDT_SDO")
return CfgMgr.MdtDigitizationTool(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)
