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")