def __init__(self, name='L1Decoder', *args, **kwargs):
super(L1Decoder, self).__init__(name, *args, **kwargs)
from TriggerJobOpts.TriggerFlags import TriggerFlags
# CTP unpacker
ctpUnpacker = CompFactory.CTPUnpackingTool()
self.ctpUnpacker = ctpUnpacker
from TrigEDMConfig.TriggerEDMRun3 import recordable
self.roiUnpackers += [ CompFactory.FSRoIsUnpackingTool("FSRoIsUnpackingTool",
Decisions=mapThresholdToL1DecisionCollection("FSNOSEED"),
OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("FSNOSEED") )) ]
# EM unpacker
if TriggerFlags.doID() or TriggerFlags.doCalo():
unpackers, rerunUnpackers = createCaloRoIUnpackers()
self.roiUnpackers += unpackers
self.rerunRoiUnpackers += rerunUnpackers
# MU unpacker
if TriggerFlags.doMuon():
unpackers, rerunUnpackers = createMuonRoIUnpackers()
self.roiUnpackers += unpackers
self.rerunRoiUnpackers += rerunUnpackers
self.prescaler = createPrescalingTool()
from AthenaConfiguration.AllConfigFlags import ConfigFlags as flags
self.DoCostMonitoring = flags.Trigger.CostMonitoring.doCostMonitoring
self.CostMonitoringChain = flags.Trigger.CostMonitoring.chain
self.L1DecoderSummaryKey = "L1DecoderSummary"
def setDefaults(self, handle):
from TriggerJobOpts.TriggerFlags import TriggerFlags
handle.DoCalo = TriggerFlags.doCalo()
handle.DoMuon = TriggerFlags.doMuon()
handle.DoBCM = TriggerFlags.doBcm()
handle.DoLUCID = TriggerFlags.doLucid()
handle.DoZDC = TriggerFlags.doZdc()
def __init__(self, name='L1EmulationTest', *args, **kwargs):
super(L1EmulationTest, self).__init__(name, *args, **kwargs)
from TriggerJobOpts.TriggerFlags import TriggerFlags
from L1Decoder.L1DecoderConf import CTPUnpackingEmulationTool, RoIsUnpackingEmulationTool
self.RoIBResult = ""
data = {}
data['CTPEmulation'] = [
'HLT_e3 HLT_g5 HLT_e7 HLT_2e3 HLT_mu6 HLT_2mu6 HLT_mu6idperf HLT_e15mu4',
'HLT_e3 HLT_g5 HLT_mu6 HLT_2mu6 HLT_mu6idperf HLT_e15mu4',
'HLT_e3 HLT_g5 HLT_e7 HLT_2e3 HLT_mu6 HLT_2mu6',
'HLT_mu6 HLT_2mu6 HLT_mu6idperf HLT_e15mu4',
] # just to see some change
data['RoIEmulation'] = [
'1.3,2.9,2704088841,EM3,EM7; 1.2,3.1,2972524297,EM3,EM7,EM10,EM15; -3.2,-2.0,3103727387,MU0,MU4,MU6,MU8',
'1.2,1.9,2733969453,MU0,MU4,MU6,MU8,MU10;2.2,1.0,2733969453,MU0,MU4,MU6',
'-3.2,3.0,2704088841,MU0,MU4,MU6,MU8;3.0,1.6,2972524297,MU0,MU4',
'1.3,1.9,3103727387,MU0,MU10;1.2,2.6,2733969453,MU6;-1.1,2.6,2972524297,MU6; -1.2,2.6,2704088842,MU20'
]
writeEmulationFiles(data)
ctpUnpacker = CTPUnpackingEmulationTool(
OutputLevel=self.getDefaultProperty("OutputLevel"),
ForceEnableAllChains=True)
self.ctpUnpacker = ctpUnpacker
self += ctpUnpacker
from L1Decoder.L1DecoderConfig import mapThresholdToL1RoICollection
# EM unpacker
if TriggerFlags.doID() or TriggerFlags.doCalo():
emUnpacker = RoIsUnpackingEmulationTool(
"EMRoIsUnpackingTool",
Decisions="EMRoIDecisions",
OutputTrigRoIs=mapThresholdToL1RoICollection("EM"),
OutputLevel=self.getDefaultProperty("OutputLevel"))
self.roiUnpackers += [emUnpacker]
print(emUnpacker)
# MU unpacker
if TriggerFlags.doMuon():
muUnpacker = RoIsUnpackingEmulationTool(
"MURoIsUnpackingTool",
Decisions="MURoIDecisions",
OutputTrigRoIs=mapThresholdToL1RoICollection("MU"),
OutputLevel=self.getDefaultProperty("OutputLevel"))
self.roiUnpackers += [muUnpacker]
self.L1DecoderSummaryKey = "L1DecoderSummary"
#-------------------------------------------------------------
# Setting DetFlags
#-------------------------------------------------------------
from AthenaCommon.DetFlags import DetFlags
if TriggerFlags.doLVL1():
DetFlags.detdescr.all_setOn()
if TriggerFlags.doID():
DetFlags.detdescr.ID_setOn()
DetFlags.makeRIO.ID_setOn()
else:
DetFlags.ID_setOff()
if TriggerFlags.doMuon():
DetFlags.detdescr.Muon_setOn()
DetFlags.makeRIO.all_setOn()
if TriggerFlags.doCalo():
DetFlags.detdescr.Calo_setOn()
from LArConditionsCommon.LArCondFlags import larCondFlags
larCondFlags.LoadElecCalib.set_Value_and_Lock(False)
else:
DetFlags.Calo_setOff()
# Always enable AtlasFieldSvc
if hasattr(DetFlags, 'BField_on'):
DetFlags.BField_setOn()
# Setup IOVDbSvc
from IOVDbSvc.CondDB import conddb # noqa: F401 configuration by import, old Run-2 job options
svcMgr.IOVDbSvc.GlobalTag = globalflags.ConditionsTag()
# ----------------------------------------------------------------
def configure(self):
log = logging.getLogger("HLTTriggergetter.py")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
# If no xAOD::EventInfo is found in a POOL file, schedule conversion from old EventInfo
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat.is_pool():
from RecExConfig.ObjKeyStore import objKeyStore
from PyUtils.MetaReaderPeeker import convert_itemList
objKeyStore.addManyTypesInputFile(convert_itemList(layout='#join'))
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
if (not objKeyStore.isInInput("xAOD::EventInfo")) and (not hasattr(
condSeq, "xAODMaker::EventInfoCnvAlg")):
from xAODEventInfoCnv.xAODEventInfoCnvAlgDefault import xAODEventInfoCnvAlgDefault
xAODEventInfoCnvAlgDefault(sequence=condSeq)
if jobproperties.Global.InputFormat() == 'bytestream':
# Decode ROIB::RoIBResult from ByteStream
from TrigT1ResultByteStream.TrigT1ResultByteStreamConfig import L1ByteStreamDecodersRecExSetup
L1ByteStreamDecodersRecExSetup()
log.info("Loading RegionSelector")
from AthenaCommon.AppMgr import ServiceMgr
from RegionSelector.RegSelSvcDefault import RegSelSvcDefault
ServiceMgr += RegSelSvcDefault()
# Configure the Data Preparation for Calo
if TriggerFlags.doCalo():
try:
from TrigT2CaloCommon.TrigT2CaloCommonConfig import TrigDataAccess
ServiceMgr.ToolSvc += TrigDataAccess()
except ImportError:
include('TrigT2CaloCommon/TrigDataAccessConfigured.py')
if TriggerFlags.doFTK():
# FTK algorithm inclusions
# TrigFTK_DataProviderSvc moved to TrigFTK_RecExample
pass
if TriggerFlags.doHLT():
log.info("configuring HLT Steering")
from TrigSteering.TrigSteeringConfig import TrigSteer_HLT, ReruningTrigSteer_HLT
if TriggerFlags.doFEX():
# schedule the conversion of the L1Calo ROIB data to topo simulation input
# this ROIB converter should only be scheduled if
# - we run on data
# - L1Calo simulation has not been scheduled
# - and ROIB converter has not been scheduled yet before
if globalflags.DataSource()=='data' \
and not hasattr( topSequence, 'CPCMX' ) \
and not hasattr( topSequence, 'RoiB2TopoInputDataCnv' ):
log.info("Setting up RoiB2TopoInputDataCnv")
from L1TopoSimulation.L1TopoSimulationConfig import RoiB2TopoInputDataCnv
roib2Topo = RoiB2TopoInputDataCnv()
topSequence += roib2Topo
log.info(
"configuring HLT merged system, for normal running (FEX + Hypo)"
)
TrigSteer_HLT = TrigSteer_HLT(
'TrigSteer_HLT',
hltFile=TriggerFlags.inputHLTconfigFile(),
lvl1File=TriggerFlags.inputLVL1configFile())
TrigSteer_HLT.doHypo = TriggerFlags.doHypo()
if not TriggerFlags.doFEX() and TriggerFlags.doHypo():
log.info("configuring merged HLT for re-running (Hypo only)")
TrigSteer_HLT = ReruningTrigSteer_HLT(
'TrigSteer_HLT',
hltFile=TriggerFlags.inputHLTconfigFile(),
lvl1File=TriggerFlags.inputLVL1configFile())
# TrigSteer_HLT.doL1TopoSimulation = TriggerFlags.doL1Topo() # this later needs to be extented to also run when we take data with L1Topo
TrigSteer_HLT.doL1TopoSimulation = True # always needs to run if the HLT is simulated
if hasattr(TrigSteer_HLT.LvlTopoConverter, 'MuonInputProvider'):
try: # this is temporary until TrigT1Muctpi-00-06-29 is in the release
from TrigT1Muctpi.TrigT1MuctpiConfig import L1MuctpiTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += L1MuctpiTool()
TrigSteer_HLT.LvlTopoConverter.MuonInputProvider.MuctpiSimTool = L1MuctpiTool(
)
except ImportError:
pass
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() != 'data':
log.info(
"Muon eta/phi encoding with reduced granularity for MC (L1Topo emulation for HLT seeding)"
)
TrigSteer_HLT.LvlTopoConverter.MuonInputProvider.MuonEncoding = 1 # reduced granularity muon input
else:
log.info(
"Muon eta/phi encoding with full granularity for data (L1Topo emulation for HLT seeding) - should be faced out"
)
TrigSteer_HLT.LvlTopoConverter.MuonInputProvider.MuonEncoding = 0 # full granularity muon input - should be faced out
from TrigEDMConfig.TriggerEDM import getHLTPreregistrationList, getEDMLibraries
TrigSteer_HLT.Navigation.ClassesToPreregister = getHLTPreregistrationList(
)
TrigSteer_HLT.Navigation.Dlls = getEDMLibraries()
monitoringTools(TrigSteer_HLT)
topSequence += TrigSteer_HLT
if TriggerFlags.writeBS():
# declare objects to go to BS (from the lists above)
## if TriggerFlags.doLVL2():
## from TrigEDMConfig.TriggerEDM import getL2BSList
## TrigSteer_L2.Navigation.ClassesToPayload = getL2BSList()
## TrigSteer_L2.Navigation.ClassesToPreregister = []
##
## if TriggerFlags.doEF():
## from TrigEDMConfig.TriggerEDM import getEFBSList
## TrigSteer_EF.Navigation.ClassesToPayload = getEFBSList()
## TrigSteer_EF.Navigation.ClassesToPreregister = []
## try:
## from TrigEDMConfig.TriggerEDM import getEFDSList
## TrigSteer_EF.Navigation.ClassesToPayload_DSonly = getEFDSList()
## except ImportError:
## log.warning("DataScouting not available in this release")
if TriggerFlags.doHLT():
from TrigEDMConfig.TriggerEDM import getHLTBSList
TrigSteer_HLT.Navigation.ClassesToPayload = getHLTBSList()
TrigSteer_HLT.Navigation.ClassesToPreregister = []
try:
from TrigEDMConfig.TriggerEDM import getHLTDSList
TrigSteer_HLT.Navigation.ClassesToPayload_DSonly = getHLTDSList(
)
except ImportError:
log.warning("DataScouting not available in this release")
#configure tools for serialization
from TrigSerializeTP.TrigSerializeTPConf import TrigSerTPTool
TrigSerToolTP = TrigSerTPTool('TrigSerTPTool')
from TrigEDMConfig.TriggerEDM import getTPList
TrigSerToolTP.TPMap = getTPList(TriggerFlags.doHLT())
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += TrigSerToolTP
from TrigSerializeCnvSvc.TrigSerializeCnvSvcConf import TrigSerializeConvHelper
TrigSerializeConvHelper = TrigSerializeConvHelper(doTP=True)
ToolSvc += TrigSerializeConvHelper
#do not activate T/P of EF classes at L2
## if TriggerFlags.doLVL2():
## from TrigEDMConfig.TriggerEDM import getL2BSTypeList
## TrigSerToolTP.ActiveClasses = getL2BSTypeList()
## if TriggerFlags.doEF():
## from TrigEDMConfig.TriggerEDM import getL2BSTypeList, getEFBSTypeList
## TrigSerToolTP.ActiveClasses = getL2BSTypeList() + getEFBSTypeList()
if TriggerFlags.doHLT():
from TrigEDMConfig.TriggerEDM import getHLTBSTypeList
TrigSerToolTP.ActiveClasses = getHLTBSTypeList()
from TriggerJobOpts.HLTTriggerResultGetter import HLTTriggerResultGetter
result = HLTTriggerResultGetter() # noqa: F841
return True
def configure(self):
log = logging.getLogger("Lvl1SimulationGetter")
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
if (not TriggerFlags.fakeLVL1()) and TriggerFlags.doLVL1():
if TriggerFlags.doCalo():
from CaloRec.CaloCellFlags import jobproperties
if TriggerFlags.useCaloTTL(
) and not jobproperties.CaloCellFlags.doFastCaloSim():
import re
if re.search("pp_v[5-9]|HI_v[3-9]|LS1_v[1-9]|DC14",
TriggerFlags.triggerMenuSetup()):
log.info("Using L1Calo Run 2 simulation")
include(
"TrigT1CaloSim/TrigT1CaloSimJobOptions_Run2.py")
else:
if TriggerFlags.doCosmicSim():
include(
"TrigT1CaloSim/TrigT1CaloSimJobOptions_TTL1_cosmic.py"
)
elif TriggerFlags.useL1CaloCalibration():
include(
"TrigT1CaloSim/TrigT1CaloSimJobOptions_TTL1.py"
)
elif 'pp_v4' in TriggerFlags.triggerMenuSetup(
): #temporary should be steered by run configuration
include(
"TrigT1CaloSim/TrigT1CaloSimJobOptions_TTL1_2012.py"
)
else:
include(
"TrigT1CaloSim/TrigT1CaloSimJobOptions_TTL1_NoCalib.py"
)
else:
include("TrigT1CaloSim/TrigT1CaloSimJobOptions_Cell.py")
log.info("adding MBTS simulation to the topSequence")
from TrigT1MBTS.TrigT1MBTSConf import LVL1__TrigT1MBTS
topSequence += LVL1__TrigT1MBTS()
# schedule simulation
if TriggerFlags.doMuon() and (not DetFlags.readRIOPool.LVL1_on()):
from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool
MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool(
DecodeMdtRDO=False,
DecodeRpcRDO=True,
DecodeTgcRDO=True,
DecodeCscRDO=False,
DecodeSTGC_RDO=False,
DecodeMM_RDO=False,
# for those subdetectors where the decoding is turned off, no need to create a RDO_Decoder ToolHandle
mdtRdoDecoderTool="",
cscRdoDecoderTool="",
stgcRdoDecoderTool="",
mmRdoDecoderTool="")
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += MuonRdoToMuonDigitTool
from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigit
topSequence += MuonRdoToMuonDigit(
"MuonRdoToMuonDigit",
MuonRdoToMuonDigitTool=ToolSvc.MuonRdoToMuonDigitTool)
import TrigT1RPCRecRoiSvc.TrigT1RPCRecRoiConfig # noqa: F401
import TrigT1TGCRecRoiSvc.TrigT1TGCRecRoiConfig # noqa: F401
import TrigT1RPCsteering.TrigT1RPCsteeringConfig # noqa: F401
import TrigT1TGC.TrigT1TGCConfig # noqa: F401
from TrigT1Muctpi.TrigT1MuctpiConfig import L1Muctpi
topSequence += L1Muctpi()
if TriggerFlags.doBcm():
from TrigT1BCM.TrigT1BCMConf import LVL1__TrigT1BCM
alg = LVL1__TrigT1BCM()
try:
sgKey = alg.BcmL1ContainerName
except AttributeError:
sgKey = alg.getDefaultProperty('BcmL1ContainerName')
if keyInInputFile(sgKey):
log.info("adding BCM simulation to the topSequence")
topSequence += alg
else:
log.warning(
"%s input (%s) missing, not adding to the topSequence",
alg.getName(), sgKey)
TriggerFlags.doBcm.set_Value(False)
if TriggerFlags.doTrt():
from TrigT1TRT.TrigT1TRTConf import LVL1__TrigT1TRT
alg = LVL1__TrigT1TRT()
try:
sgKey = alg.TRTL1ContainerName
except AttributeError:
sgKey = alg.getDefaultProperty('TRTL1ContainerName')
if keyInInputFile(sgKey):
log.info("adding TRTfast simulation to the topSequence")
topSequence += alg
else:
log.warning(
"%s input (%s) missing, not adding to the topSequence",
alg.getName(), sgKey)
TriggerFlags.doTrt.set_Value(False)
if TriggerFlags.doZdc():
from TrigT1ZDC.TrigT1ZDCConf import LVL1__TrigT1ZDC
alg = LVL1__TrigT1ZDC()
# ZDC simulation is using truth information at the moment, so do not do any fancy configuration
log.info("adding ZDC simulation to the topSequence")
topSequence += alg
if TriggerFlags.doLucid():
from TrigT1Lucid.TrigT1LucidConf import LVL1__TrigT1Lucid
alg = LVL1__TrigT1Lucid()
try:
sgKey = alg.LVL1T1ContainerName
except AttributeError:
sgKey = alg.getDefaultProperty('LVL1T1ContainerName')
if keyInInputFile(sgKey):
log.info("adding Lucid simulation to the topSequence")
topSequence += alg
else:
log.warning(
"%s input (%s) missing, not adding to the topSequence",
alg.getName(), sgKey)
TriggerFlags.doLucid.set_Value(False)
if TriggerFlags.doL1Topo():
log.info("Enabling L1Topo simulation")
from L1TopoSimulation.L1TopoSimulationConfig import L1TopoSimulation
topSequence += L1TopoSimulation()
try: # this is temporary until TrigT1Muctpi-00-06-29 is in the release
from TrigT1Muctpi.TrigT1MuctpiConfig import L1MuctpiTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += L1MuctpiTool()
topSequence.L1TopoSimulation.MuonInputProvider.MuctpiSimTool = L1MuctpiTool(
)
except ImportError:
pass
# enable the reduced (coarse) granularity topo simulation
# currently only for MC
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() != 'data':
log.info(
"Muon eta/phi encoding with reduced granularity for MC (L1 Simulation)"
)
topSequence.L1TopoSimulation.MuonInputProvider.MuonEncoding = 1
else:
log.info(
"Muon eta/phi encoding with full granularity for data (L1 Simulation) - should be faced out"
)
topSequence.L1TopoSimulation.MuonInputProvider.MuonEncoding = 0
log.info("adding ctp simulation to the topSequence")
from TrigT1CTP.TrigT1CTPConfig import CTPSimulationInReco
topSequence += CTPSimulationInReco("CTPSimulation")
log.info("adding ROIB simulation to the topSequence")
from TrigT1RoIB.TrigT1RoIBConfig import RoIBuilder
topSequence += RoIBuilder("RoIBuilder")
# monitoring
LVL1MonitoringTools()
#jtb if not TriggerFlags.fakeLVL1():
# LVL1
#jtb theApp.Dlls += [ "TrigT1ResultByteStream" ]
if not (TriggerFlags.fakeLVL1() or TriggerFlags.doLVL1()):
DetFlags.readRIOPool.LVL1_setOn()
# need to following when reading LVL1 to o/p to AOD
# RoI reconstruction svc
# if ( doWriteESD or readESD) or ( doWriteAOD or readAOD) or doWriteRDO :
# include("TrigT1EventAthenaPool/TrigT1EventAthenaPool_joboptions.py")
# if (doWriteESD or doWriteAOD):
# Pool convertors for LVL1
# include("AnalysisTriggerEventAthenaPool/AnalysisTriggerEventAthenaPool_joboptions.py")
# --------------------------------------------------------------
# digitize the muon detector first if needed
# --------------------------------------------------------------
if TriggerFlags.doMuon() and DetFlags.digitize.Muon_on():
# configure Pileup
theApp.Dlls += ["PileUpTools"]
# RPC Digitization
include("RPC_Digitization/RPC_Digitization_jobOptions.py")
# MDT Digitization
include("MDT_Digitization/MDT_Digitization_jobOptions.py")
# CSC Digitization
include("CSC_Digitization/CSC_Digitization_jobOptions.py")
# TGC Digitization
include("TGC_Digitization/TGC_Digitization_jobOptions.py")
include("MuonByteStreamCnvTest/MuonRdoDigit_jobOptions.py")
# from TriggerJobOpts.Lvl1ResultBuilderGetter import Lvl1ResultBuilderGetter
# result = Lvl1ResultBuilderGetter()
# ***Temp : needed to enable required combination of thresholds
# mu4,mu6,mu10,mu11,mu20,mu40
# Will be replaced by config. from Lvl1ConfigSvc
if hasattr(ServiceMgr, 'RPCcablingSimSvc'):
ServiceMgr.RPCcablingSimSvc.HackFor1031 = True
from AthenaCommon.GlobalFlags import jobproperties
if jobproperties.Global.InputFormat() != 'bytestream':
if TriggerFlags.doCalo() and DetFlags.writeBS.Calo_on():
from AthenaCommon.AppMgr import ToolSvc
from LArByteStream.LArByteStreamConfig import LArRawDataContByteStreamToolConfig
ToolSvc += LArRawDataContByteStreamToolConfig(
InitializeForWriting=True)
# if jobproperties.Global.InputFormat() == 'bytestream':
# theApp.Dlls += [ "TrigT1Calo" ]
# include("TrigT1CaloByteStream/ReadLVL1CaloBS_jobOptions.py")
# from RecExConfig.RecFlags import rec
# if (rec.doESD() or rec.doAOD()) and (not(rec.readAOD() or rec.readESD())): #fix for bug 64345
# from AnalysisTriggerAlgs.AnalysisTriggerAlgsConfig import RoIBResultToAOD
# topSequence += RoIBResultToAOD("RoIBResultToAOD")
# from RecExConfig.ObjKeyStore import objKeyStore
# from TrigEDMConfig.TriggerEDM import getLvl1ESDList
# objKeyStore.addManyTypesStreamESD(getLvl1ESDList())
# from TrigEDMConfig.TriggerEDM import getLvl1AODList
# objKeyStore.addManyTypesStreamAOD(getLvl1AODList())
return True
if test_g10 or test_e10 or test_mu or test_mu_noIdScan:
TriggerFlags.doCalo = True
### Fixme Now photon also need ID because of egammaGetter!
if test_g10 or test_e10 or test_e10_ID or test_mu or test_mu_noCalo or test_mu_IDTRT_noCalo or test_e10_ID:
TriggerFlags.doID = True
TriggerFlags.MuonSlice.doSiTrack = False
if test_mu_IDTRT_noCalo:
TriggerFlags.MuonSlice.doTRTProp = True
if test_mu_noIdScan_noCalo or test_mu_noIdScan:
TriggerFlags.doID = True
TriggerFlags.MuonSlice.doIdScan = False
if test_mu or test_mu_noID_noCalo or test_mu_noIdScan or test_mu_noIdScan_noCalo or test_mu_noCalo or test_mu_IDTRT_noCalo:
TriggerFlags.doMuon = True
TriggerFlags.MuonSlice.doL2ID = TriggerFlags.doID()
TriggerFlags.MuonSlice.doL2Calo = TriggerFlags.doCalo()
TriggerFlags.MuonSlice.doEFID = TriggerFlags.doID()
TriggerFlags.MuonSlice.doMuonCalibrationStream = isOnline
if alwaysAccept:
def addAlwaysAcceptChain():
TriggerFlags.MinBiasSlice.enableSignature("always")
from TriggerMenuPython.GenerateMenu import GenerateMenu
GenerateMenu.overwriteSignaturesWith(addAlwaysAcceptChain)
if noBPhysics: #temporary method - incompatible with alwaysAccept
def removeBPhysicsSlice():
TriggerFlags.BphysicsSlice.signatures = []
) == "pool" and DetFlags.detdescr.ID_on():
DetFlags.makeRIO.ID_setOn()
DetFlags.readRIOBS.ID_setOn()
DetFlags.writeBS.ID_setOn()
if not trtEnabled:
DetFlags.makeRIO.TRT_setOff()
DetFlags.readRIOBS.TRT_setOff()
DetFlags.writeBS.TRT_setOff()
if (not rec.readESD()) and jobproperties.Global.InputFormat(
) == "pool" and DetFlags.detdescr.Calo_on():
DetFlags.detdescr.ID_setOn() # needed for RegionSelectorLUT
if not trtEnabled:
DetFlags.detdescr.TRT_setOff()
DetFlags.makeRIO.Calo_setOn()
DetFlags.readRIOBS.Calo_setOn()
DetFlags.writeBS.Calo_setOn()
#if (not rec.readESD()) and GlobalFlags.InputFormat.is_pool() and DetFlags.detdescr.Muon_on():
# DetFlags.makeRIO.Muon_setOn()
# DetFlags.readRIOBS.Muon_setOn()
# DetFlags.writeBS.Muon_setOn()
#
# Switch off direct formation of Cells from hits
#
if not rec.readESD() and TriggerFlags.doCalo():
include("CaloRec/CaloCellMaker_config.py")
CaloCellMakerFlags.doLArHitToCellDirect = False
CaloCellMakerFlags.doTileHitToRawChannelDirect = False
