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