def get_monitoring_mode(self): self.__logger.info("TrigTauMonToolBuilder.get_monitoring_mode()") self.data_type = dqflags.monManDataType() if self.data_type == 'monteCarlo': self.mc_mode = True return True elif self.data_type == 'collisions': self.pp_mode = True return True elif self.data_type == 'cosmics': self.cosmic_mode = True return True else: return False
def get_monitoring_mode(self): self.data_type = dqflags.monManDataType() if self.data_type == 'monteCarlo': self.mc_mode = True return True elif self.data_type == 'collisions': self.pp_mode = True return True elif self.data_type == 'heavyioncollisions': self.HI_mode = True self.pPb_mode = True return True elif self.data_type == 'cosmics': self.cosmic_mode = True return True else: return False
def get_monitoring_mode(self): log_trigeg.info("TrigEgammaMonToolBuilder.get_monitoring_mode()") self.data_type = dqflags.monManDataType() if self.data_type == 'monteCarlo': self.mc_mode = True return True elif self.data_type == 'collisions': self.pp_mode = True return True elif self.data_type == 'heavyioncollisions': self.HI_mode = True self.pPb_mode = True return True elif self.data_type == 'cosmics': self.cosmic_mode = True return True else: return False
def get_monitoring_mode(self): # Set monitoring mode self.data_type = DQMonFlags.monManDataType() if self.data_type == 'monteCarlo': self.mc_mode = True return True elif self.data_type == 'collisions': #singlebeam is included in collisions self.pp_mode = True return True elif self.data_type == 'heavyioncollisions': #heavy ion is pPb or PbPb self.HI_mode = True return True elif self.data_type == 'cosmics': self.cosmic_mode = True return True else: return False
if (InDetFlags.doPrintConfigurables()): print InDetAlignMonBeamSpot ToolSvc += InDetAlignMonPVBiases if (InDetFlags.doPrintConfigurables()): print InDetAlignMonPVBiases ToolSvc += InDetAlignMonSivsTRT if (InDetFlags.doPrintConfigurables()): print InDetAlignMonSivsTRT ## add an AthenaMonManager algorithm to the list of algorithms to be ran #from DataQualityTools.DQMonFlags import DQMonFlags from AthenaMonitoring.DQMonFlags import DQMonFlags from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager InDetAlignMonManager = AthenaMonManager( name="InDetAlignMonManager", FileKey=DQMonFlags.monManFileKey(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType(), Environment=DQMonFlags.monManEnvironment(), ManualRunLBSetup=DQMonFlags.monManManualRunLBSetup(), Run=DQMonFlags.monManRun(), LumiBlock=DQMonFlags.monManLumiBlock()) if jobproperties.Beam.beamType() == 'cosmics': InDetAlignMonManager.DataType = "cosmics" for i in range(5): InDetAlignMonManager.AthenaMonTools += [m_trackSegmentsUpLow[i]] for i in range(2): InDetAlignMonManager.AthenaMonTools += [m_trackSegments_Sub[i]]
#svcMgr.DSConfigSvc.readLVL1Thr=True #svcMgr.DSConfigSvc.readLVL1BG=True from TrigT1Muctpi.TrigT1MuctpiConfig import L1Muctpi_on_Data topSequence += L1Muctpi_on_Data() from TrigT1CTMonitoring.TrigT1CTMonitoringConf import TrigT1CTMonitoring__DeriveSimulationInputs as DeriveSimulationInputs topSequence += DeriveSimulationInputs(do_MuCTPI_input=True, do_L1Calo_sim=False) from TrigT1CTP.TrigT1CTPConfig import CTPSimulationOnData topSequence += CTPSimulationOnData("CTPSimulation") # configure simulation histogram output directory from AthenaMonitoring.DQMonFlags import DQMonFlags histbase = "/" + DQMonFlags.monManFileKey() + "/" if DQMonFlags.monManRun(): from RecExConfig.AutoConfiguration import GetRunNumber histbase += "run_%i/L1" % GetRunNumber() else: histbase += "L1Simulation" try: topSequence.CTPSimulation.HistPath = histbase except AttributeError as ex: printfunc(ex, " ignore for now") import traceback traceback.print_exc() ## add an AthenaMonManager algorithm to the list of algorithms to be run monMan = AthenaMonManager( name="CTMonManager",
## @file TrigT1CaloMonitoring_forRecExCommission_cpu.py # # For testing purposes only - runs each monitoring tool in a separate manager # so can see their individual cpu usage. # # @author Peter Faulkner # if not 'DQMonFlags' in dir(): print "TrigT1CaloMonitoring_forRecExCommission.py: DQMonFlags not yet imported - I import them now" from AthenaMonitoring.DQMonFlags import DQMonFlags # On Tier0 select monitoring tools according to processing step if DQMonFlags.monManEnvironment() == 'tier0Raw': # Tier0 RAWtoESD step l1caloRawMon=True l1caloESDMon=False elif DQMonFlags.monManEnvironment() == 'tier0ESD': # Tier0 ESDtoAOD step l1caloRawMon=False l1caloESDMon=True else: # Anything else l1caloRawMon=True l1caloESDMon=True if l1caloRawMon: Offline = not athenaCommonFlags.isOnline isData = (globalflags.DataSource() == "data") isCalo = (rec.doCalo() and rec.doLArg() and rec.doTile()) triggerConfigService = "TrigConf::TrigConfigSvc/TrigConfigSvc"
#monMan.Run = 1 #monMan.LumiBlock = 1 # list of the algorithms to be executed at run time from InDetVertexMonitoring.InDetVertexMonitoringConf import InDetVertexMonitoring myVx = InDetVertexMonitoring() myVx.DoControlPlots = False myVx.OutputLevel = WARNING if not 'DQMonFlags' in dir(): print "DQMonFlags not yet imported - I import them now" from AthenaMonitoring.DQMonFlags import DQMonFlags #DQMonFlags.useTrigger = False if DQMonFlags.useTrigger(): if not 'rec' in dir(): from RecExConfig.RecFlags import rec if rec.readESD() and (DQMonFlags.monManEnvironment=='tier0ESD'): # for ESD->AOD use trigger config stored as in-file meta-data, if not 'TriggerFlags' in dir(): from TriggerJobOpts.TriggerFlags import TriggerFlags TriggerFlags.configurationSourceList = ['ds'] # set up trigger config service if not 'TriggerConfigGetter' in dir(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter() if not hasattr(ToolSvc, DQMonFlags.nameTrigDecTool()):
# if not 'HLTMonFlags' in dir(): # from TrigHLTMonitoring.HLTMonFlags import HLTMonFlags # if not 'DQMonFlags' in dir(): from AthenaMonitoring.DQMonFlags import DQMonFlags ################ Mon Tools ################# # Bphys - Running JpsiFinder if HLTMonFlags.doMonTier0: if HLTMonFlags.doBphys and rec.doInDet: include("TrigBphysMonitoring/RunJpsiFinder.py") topSequence += AthenaMonManager("HLTMonManager", Run=DQMonFlags.monManRun(), DataType=DQMonFlags.monManDataType(), Environment=DQMonFlags.monManEnvironment()) HLTMonManager = topSequence.HLTMonManager #Global HLTMonTool if HLTMonFlags.doGeneral: try: from TrigHLTMonitoring.TrigHLTMonitoringConfig import HLTGeneralTool HLTMonManager.AthenaMonTools += HLTGeneralTool() except: log.info("Problems with the general HLTMonTool, tool not enabled") if HLTMonFlags.doMonTier0: # HLTEgammaMonTool - Calculates basic efficiencies if HLTMonFlags.doEgamma:
if DQMonFlags.monManEnvironment() == 'tier0ESD': from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager from AthenaMonitoring.DQMonFlags import DQMonFlags try: monManEgamma = AthenaMonManager( name="EgammaMonManager", FileKey=DQMonFlags.monManFileKey(), Environment=DQMonFlags.monManEnvironment(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType()) topSequence += monManEgamma from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool monbadlb = GetLArBadLBFilterTool() egammaMonOutputLevel = INFO ### Setup which objects will be monitored if not ('egammaMonitorPhotons' in dir()): egammaMonitorPhotons = True if not ('egammaMonitorElectrons' in dir()): egammaMonitorElectrons = True if not ('egammaMonitorFwdEg' in dir()): egammaMonitorFwdEg = True
SCTMonMan = topSequence.SCTMonManager #SCTMonMan.FileKey = "GLOBAL" #SCTMonMan.ManualDataTypeSetup = True #SCTMonMan.DataType= "monteCarlo" #SCTMonMan.Environment = "user" #SCTMonMan.ManualRunLBSetup = True #SCTMonMan.Run = 1 #SCTMonMan.LumiBlock = 1 #Changed at the insistence of [email protected] #from DataQualityTools.DQMonFlags import DQMonFlags from AthenaMonitoring.DQMonFlags import DQMonFlags SCTMonMan.FileKey = DQMonFlags.monManFileKey() SCTMonMan.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup() SCTMonMan.ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup() SCTMonMan.DataType = DQMonFlags.monManDataType() SCTMonMan.Environment = DQMonFlags.monManEnvironment() SCTMonMan.Run = DQMonFlags.monManRun() SCTMonMan.LumiBlock = DQMonFlags.monManLumiBlock() #Currently this takes the latest/default tag of the db #Check with Shaun as to which one we need for first data, and for M6. #twiki somewhere ? #include("SCT_Monitoring/SCT_Monitoring_ConditionsAccess.py") ######################################################################## # Conditions access # These lines were previously in SCT_Monitoring_ConditionsAccess.py ########################################################################
doAside = True, # obsolete doCside = True, # obsolete doStraws = True, doChips = True, doShift = True, doDiagnostic = True, # obsolete EventBurstCut = eventBurstCut, # default = 200 DoRDOsMon = True, DoGeoMon = False, DoTracksMon = True, doExpert = athenaCommonFlags.isOnline(), IsCosmics = InDetFlags.doCosmics(), InDetTRT_DAQ_ConditionsSvc = InDetTRT_DAQ_ConditionsSvc, doEfficiency = False, # ME: turn off TRT hole search, it fails Tier-0 every_xth_track = 25, whatdatatype = DQMonFlags.monManDataType(), MinTRTHitCut = 10, max_abs_d0 = 10 * Units.mm, max_abs_z0 = 300 * Units.mm, max_abs_eta = 2.5, MinTrackP = 0.0 * Units.GeV, min_pT = minTrkPtCut, # default = 0.5 GeV min_si_hits = minSiHitCut, # default = 1 min_pixel_hits = 0, min_sct_hits = 0, min_trt_hits = 10 ) if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'): InDetTRT_Monitoring_Tool.FilterTools.append(monFilledBunchFilterTool)
InDetPixelMainsMonOnPixelTrack.FilterTools.append(monFilledBunchFilterTool) ToolSvc += InDetPixelMainsMonOnPixelTrack if (InDetFlags.doPrintConfigurables()): print InDetPixelMainsMonOnPixelTrack ###################################### # configure the pixel mon manager and add main pixel monitoring tool from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager from AthenaMonitoring.DQMonFlags import DQMonFlags InDetPixMonMan = AthenaMonManager( "InDetPixelMonManager", FileKey = DQMonFlags.monManFileKey(), ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(), ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup(), DataType = DQMonFlags.monManDataType(), Environment = DQMonFlags.monManEnvironment(), Run = DQMonFlags.monManRun(), LumiBlock = DQMonFlags.monManLumiBlock()) if doAllHits: InDetPixMonMan.AthenaMonTools += [ InDetPixelMainsMon ] if doHitsOnTrack: InDetPixMonMan.AthenaMonTools += [ InDetPixelMainsMonOnTrack ] if doHitsOnPixelTrack: InDetPixMonMan.AthenaMonTools += [ InDetPixelMainsMonOnPixelTrack ] topSequence += InDetPixMonMan if (InDetFlags.doPrintConfigurables()):
DQMonFlags.doMonitoring=False elif (DQMonFlags.monType=='BS_ESD'): if rec.readRDO(): DQMonFlags.monManEnvironment='tier0Raw' if rec.readESD(): DQMonFlags.monManEnvironment='tier0ESD' if rec.readAOD(): DQMonFlags.monManEnvironment='AOD' elif DQMonFlags.monType=='BSall': DQMonFlags.monManEnvironment='tier0' if rec.readESD(): DQMonFlags.doMonitoring=False else: local_logger.warning("invalid DQMonFlags.monType: %s, using default monManEnvironment", DQMonFlags.monType()) if not DQMonFlags.doMonitoring(): local_logger.info("monitoring globally switched off") DQMonFlags.doGlobalMon=False DQMonFlags.doLVL1CaloMon=False DQMonFlags.doCTPMon=False DQMonFlags.doHLTMon=False DQMonFlags.doPixelMon=False DQMonFlags.doSCTMon=False DQMonFlags.doTRTMon=False DQMonFlags.doTRTElectronMon=False DQMonFlags.doInDetGlobalMon=False DQMonFlags.doInDetAlignMon=False DQMonFlags.doInDetPerfMon=False DQMonFlags.doLArMon=False
triggerChainName="NoTrig", regions=["All", "BB", "EAEA", "ECEC"], varsVSmean=varsVSmeanZmumu, varsVSwidth=varsVSwidthZmumu, varsDistr=varsDistrZmumu, doFits=True, doSaveFits=False, # setDebug = True, OutputLevel=INFO) #ToolSvc += ZmumuMon from AthenaMonitoring.DQMonFlags import DQMonFlags from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager IDPerfMonManager = AthenaMonManager( name="IDPerfMonManager", FileKey=DQMonFlags.monManFileKey(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType(), Environment="user", ManualRunLBSetup=True, Run=1, LumiBlock=1) IDPerfMonManager.AthenaMonTools += [ZmumuMon] ServiceMgr.THistSvc.Output += [ "DiMuMon DATAFILE='DiMuMon.root' OPT='RECREATE'" ] IDPerfMonManager.FileKey = "DiMuMon" topSequence += IDPerfMonManager
################################ # setup of alignment monitoring from AthenaMonitoring.DQMonFlags import DQMonFlags from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager InDetAlignMonManager = AthenaMonManager( name="InDetAlignMonManager", FileKey=DQMonFlags.monManFileKey(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType(), Environment="user", ManualRunLBSetup=True, Run=1, LumiBlock=1) from InDetAlignmentMonitoring.InDetAlignmentMonitoringConf import InDetAlignMon__TrackSelectionTool # All tracks selection allSelection = InDetAlignMon__TrackSelectionTool( name="InDetAlignMonTrackSelectionTool", PassAllTracks=True, ## Uncomment this line to bypass track slection ) ToolSvc += allSelection # Align tracks selection from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetTrtDriftCircleCutTool trtDCtool = InDet__InDetTrtDriftCircleCutTool( name="TrtHitsEtaCutTool", #OutputLevel = newInDetAlignAlg_Options["outputLevel"], UseNewParameterization=True,
#################################################### # # # InDetGlobalManager top algorithm # # # #################################################### if InDetFlags.doMonitoringGlobal() or InDetFlags.doMonitoringPrimaryVertexingEnhanced(): from AthenaMonitoring.DQMonFlags import DQMonFlags from InDetGlobalMonitoring.InDetGlobalMonitoringConf import InDetGlobalManager InDetGlobalManager=InDetGlobalManager( name = "InDetGlobalManager", TRT_DriftCircleName = InDetKeys.TRT_DriftCircles(), FileKey = DQMonFlags.monManFileKey(), ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(), ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup(), DataType = DQMonFlags.monManDataType(), Environment = DQMonFlags.monManEnvironment(), Run = DQMonFlags.monManRun(), LumiBlock = DQMonFlags.monManLumiBlock(), doTopBottom = True, AthenaMonTools = []) # these are set at the end if InDetFlags.doMonitoringGlobal(): ####################################################### # # # LVL1 & BC ID monitoring - only for real data # # # ####################################################### from InDetGlobalMonitoring.InDetGlobalMonitoringConf import InDetGlobalSynchMonTool InDetGlobalSynchMonTool = InDetGlobalSynchMonTool( name = "InDetGlobalSynchMonTool", histoPathBase = "/GLOBAL", checkRate = 2000)
tdt_local_logger = logging.getLogger('TrigDecTool_jobOptions') # Set up the trigger decision tool (for trigger-aware monitoring) if not 'DQMonFlags' in dir(): tdt_local_logger.debug("DQMonFlags not yet imported - I import them now") from AthenaMonitoring.DQMonFlags import DQMonFlags if DQMonFlags.useTrigger(): if not 'rec' in dir(): from RecExConfig.RecFlags import rec if rec.readESD() and (DQMonFlags.monManEnvironment=='tier0ESD'): # for ESD->AOD use trigger config stored as in-file meta-data, if not 'TriggerFlags' in dir(): from TriggerJobOpts.TriggerFlags import TriggerFlags TriggerFlags.configurationSourceList = ['ds'] # set up trigger config service if not 'TriggerConfigGetter' in dir(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter() if not hasattr(ToolSvc, DQMonFlags.nameTrigDecTool()): from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool monTrigDecTool = Trig__TrigDecisionTool(name=DQMonFlags.nameTrigDecTool(), OutputLevel=ERROR, PublicChainGroups = {"EFTau": "EF_[0-9]?tau.*", "EFPhoton": "EF_[0-9]?g*", "EFJets":"EF_J.*", } )
## @file TrigT1Monitoring_forRecExCommission.py # # Standard monitoring jobOptions - runs on Tier0 (Reco_trf.py) or online. # # @authors Johanna Fleckner, Andrea Neusiedl, Peter Faulkner # from AthenaCommon.GlobalFlags import globalflags if not 'DQMonFlags' in dir(): print "TrigT1CaloMonitoring_forRecExCommission.py: DQMonFlags not yet imported - I import them now" from AthenaMonitoring.DQMonFlags import DQMonFlags # On Tier0 select monitoring tools according to processing step if DQMonFlags.monManEnvironment() == 'tier0Raw': # Tier0 RAWtoESD step l1caloRawMon=True l1caloESDMon=False elif DQMonFlags.monManEnvironment() == 'tier0ESD': # Tier0 ESDtoAOD step l1caloRawMon=False l1caloESDMon=True else: # Anything else l1caloRawMon=True l1caloESDMon=True # Don't run if full PPrStabilityMon running from TrigT1CaloMonitoringTools.LVL1CaloMonFlags import LVL1CaloMonFlags if LVL1CaloMonFlags.doPPrStabilityMon(): l1caloRawMon=False l1caloESDMon=False
include.block("LArMonitoring/LArMonitoring_jobOption.py") #Create the set of flags from AthenaMonitoring.DQMonFlags import DQMonFlags from AthenaCommon.GlobalFlags import globalflags from LumiBlockComps.BunchCrossingCondAlgDefault import BunchCrossingCondAlgDefault BunchCrossingCondAlgDefault() if 'ESD' not in DQMonFlags.monManEnvironment(): include("LArCellRec/LArCollisionTime_jobOptions.py") from LArMonitoring.LArCollisionTimeMonAlg import LArCollisionTimeMonConfigOld topSequence += LArCollisionTimeMonConfigOld(DQMonFlags) if globalflags.DataSource() == 'data': from LArMonitoring.LArAffectedRegionsAlg import LArAffectedRegionsConfigOld topSequence += LArAffectedRegionsConfigOld(DQMonFlags) if 'ESD' not in DQMonFlags.monManEnvironment(): from LArMonitoring.LArNoisyROMonAlg import LArNoisyROMonConfigOld topSequence += LArNoisyROMonConfigOld(DQMonFlags) if globalflags.DataSource == 'data' and 'online' not in DQMonFlags.monManEnvironment( ): from LArMonitoring.LArHVCorrMonAlg import LArHVCorrMonConfigOld topSequence += LArHVCorrMonConfigOld(DQMonFlags) if 'ESD' not in DQMonFlags.monManEnvironment( ) and globalflags.DataSource == 'data': from LArMonitoring.LArDigitMonAlg import LArDigitMonConfigOld topSequence += LArDigitMonConfigOld(DQMonFlags)
CBNT_AthenaAware.Members += ["LVL1::CBNTAA_LVL1CaloESD/CBNT_LVL1calo"] elif (rec.readESD() or rec.readAOD()): CBNT_AthenaAware.Members += ["LVL1::CBNTAA_LVL1CaloESD/CBNT_LVL1calo"] elif (rec.readRDO() and TriggerFlags.doLVL1()): CBNT_AthenaAware.Members += [ "LVL1::CBNTAA_LVL1calo/CBNT_LVL1calo" ] elif ( jobproperties.CaloCellFlags.doFastCaloSim() and TriggerFlags.doLVL1()): CBNT_AthenaAware.Members += [ "LVL1::CBNTAA_LVL1calo/CBNT_LVL1calo" ] CBNT_AthenaAware.Members += [ "CBNTAA_ReadRoIBResult/CBNT_ReadRoIBResult" ] #CBNTAthenaAware=True include( "CBNT_Athena/CBNT_AthenaAware_jobOptions.py" ) include( "CBNT_Athena/CBNT_EventInfo_jobOptions.py" ) if rec.Commissioning: from AthenaMonitoring.DQMonFlags import DQMonFlags if DQMonFlags.doCTPMon(): include ("TrigT1CTMonitoring/NtupleFragment.py") if DQMonFlags.doLVL1CaloMon(): include( "TrigT1CaloCalibTools/CBNT_L1Calo_jobOptions.py" ) else: doL1CaloCBNT_JEM = False doL1CaloCBNT_CPM = False doL1CaloCBNT_RODHeader = False include( "TrigT1CaloCalibTools/CBNT_L1Calo_jobOptions.py" ) include("TrigNtInDet/jobOfragment_TrigNtInDet.py") #if CBNTAthenaAware: # include("TrigDecisionMaker/jobOfragment_CBNTAA_TriggerDecision.py")
from AthenaCommon.BeamFlags import jobproperties from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from AthenaMonitoring.DQMonFlags import DQMonFlags if not 'rec' in dir(): from RecExConfig.RecFlags import rec from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager ManagedAthenaTileMon = AthenaMonManager( "ManagedAthenaTileMon" ) #topSequence.ManagedAthenaTileMon from AthenaCommon.AppMgr import ServiceMgr ManagedAthenaTileMon.FileKey = DQMonFlags.monManFileKey() ManagedAthenaTileMon.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup() ManagedAthenaTileMon.DataType = DQMonFlags.monManDataType() ManagedAthenaTileMon.Environment = DQMonFlags.monManEnvironment() ManagedAthenaTileMon.ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup() ManagedAthenaTileMon.Run = DQMonFlags.monManRun() ManagedAthenaTileMon.LumiBlock = DQMonFlags.monManLumiBlock() if DQMonFlags.monManEnvironment() == 'tier0Raw': tileRawMon=True tileESDMon=False elif DQMonFlags.monManEnvironment() == 'tier0ESD': tileRawMon=False tileESDMon=True else: # it should be 'tier0' tileRawMon=True
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration include.block("CaloMonitoring/CaloNewMonitoring_jobOptions.py") #Create the set of flags from AthenaMonitoring.DQMonFlags import DQMonFlags if DQMonFlags.monManEnvironment() != 'AOD': from CaloMonitoring.LArCellMonAlg import LArCellMonConfigOld topSequence += LArCellMonConfigOld(DQMonFlags)
theLArBadChannelTool = LArBadChanTool() ToolSvc += theLArBadChannelTool LArCellMon = LArCellMonTool( name="LArCellMonCosmics", CaloCellContainer="AllCalo", #TimeGran = "run", ProcessNEvents= 100, #determines eventsblock time granularity, defined in ManagedMonitorToolBase. BadLBTool=GetLArBadLBFilterTool(), ReadyFilterTool=monAtlasReadyFilterTool, useElectronicNoiseOnly=False, #useTwoGaus = True, Tile-only CaloNoiseTool=theCaloNoiseTool, useTrigger=DQMonFlags.useTrigger(), rndmTriggerNames= "L1_RD0, L1_RD0_FILLED, L1_RD0_EMPTY, L1_RD1, L1_RD1_NOISE, L1_RD1_HIST, L1_RD1_BGRP4, L1_RD1_BGRP5", caloTriggerNames= "L1_EM[0-9]+, L1_HA[0-9]+, L1_J[0-9]+.*, L1_JB[0-9]+, L1_JF[0-9]+, L1_TE[0-9]+, L1_JE[0-9]+, L1_XE[0-9]+, L1_2EM[0-9]+, L1_2FJ[0-9]+, L1_2J[0-9]+,L1_3J[0-9]+.*,L1_4J[0-9]+.*,L1_5J[0-9]+,L1_6J[0-9]+,L1_FJ[0-9]+.*", minBiasTriggerNames="L1_RD0_FILLED, L1_MBTS_1, L1_MBTS_2, L1_MBTS_1_1", metTriggerNames="EF_xe[0-9]+.*", miscTriggerNames="", LArBadChannelMask=theLArChanMasker, LArBadChannelTool=theLArBadChannelTool, MaskBadChannels=False, MaskNoCondChannels=False, useReadyFilterTool=False, useBeamBackgroundRemoval=False, #doInverseMasking = False,
rec.doWriteESD = False rec.doDetStatus = False rec.doHist = False #-------------------------------------------------------------- # Internal flags for each subsystem #-------------------------------------------------------------- # MuDet if rec.doMuon() and rec.doESD(): from MuonRecExample.MuonRecFlags import muonRecFlags from MuonCnvExample.MuonCalibFlags import muonCalibFlags from AthenaMonitoring.DQMonFlags import DQMonFlags if rec.doESD() and DQMonFlags.doCTPMon() and rec.doTrigger(): include("TrigT1CTMonitoring/CTPFlags.py") # FIXME obsolete flags (should be removed)!!! # ------------------------------------ # import GlobalFlags from RecExCommon # ------------------------------------ # new flag rec.Commissioning = True rec.ScopingLevel = 4 if (globalflags.ConditionsTag() == ''): logRecExCommon_flags.warning( 'No globalflags.ConditionsTag() is set!!!') from IOVDbSvc.CondDB import conddb
elif DQMonFlags.monManEnvironment() == 'tier0Raw': MuonRawMon = True MuonESDMon = False elif DQMonFlags.monManEnvironment() == 'tier0ESD': MuonRawMon = False MuonESDMon = True elif DQMonFlags.monManEnvironment() == 'tier0': MuonRawMon = True MuonESDMon = True ## add an AthenaMonManager algorithm to the list of algorithms to be ran from AthenaMonitoring.DQMonFlags import DQMonFlags from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager muonOutputLevel = INFO if DQMonFlags.doMuonRawMon(): try: if MuonRawMon: if MuonDQADetFlags.doRPCL1Mon(): include("RpcRawDataMonitoring/RpcRawBS_MonitoringOptions.py") if MuonDQADetFlags.doCSCMon() or MuonDQADetFlags.doCSCClusMon(): include("CscRawDataMonitoring/CscRawBS_MonitoringOptions.py") if MuonESDMon: # add configuration of muon cablings import MuonCnvExample.MuonCablingConfig if MuonDQADetFlags.doMDTMon(): include("MdtRawDataMonitoring/MdtRaw_MonitoringOptions.py") if MuonDQADetFlags.doRPCMon(): include("RpcRawDataMonitoring/RpcRawESD_MonitoringOptions.py") if MuonDQADetFlags.doTGCMon() or MuonDQADetFlags.doTGCL1Mon: include("TgcRawDataMonitoring/TgcRaw_MonitoringOptions.py")
def TrigIDPhysValMonitoringTool(): from AthenaCommon.Constants import INFO,ERROR,FALSE,TRUE,DEBUG,VERBOSE # dataTypes: userDefined = 0, monteCarlo, collisions, cosmics if not 'DQMonFlags' in dir(): from AthenaMonitoring.DQMonFlags import DQMonFlags dataType = DQMonFlags.monManDataType() if not 'rec' in dir(): from RecExConfig.RecFlags import rec outputlist = [] if rec.doInDet: from TrigInDetAnalysisExample.TrigInDetAnalysisExampleConf import TrigTestPhysValMon from AthenaCommon.AppMgr import release_metadata d = release_metadata() def makePhysvalMon(name, pdgid, chainnames, useHighestPT, cosmic = False): Monname = "TestIDPhysValMon" + name TestIDPhysValMon = TrigTestPhysValMon(name=Monname) TestIDPhysValMon.SliceTag = "HLT/IDMon/" + name TestIDPhysValMon.OutputLevel = INFO TestIDPhysValMon.UseHighestPT = useHighestPT try: TestIDPhysValMon.EnableLumi = False except: pass TestIDPhysValMon.buildNtuple = False TestIDPhysValMon.AnalysisConfig = "Tier0" #T0 Analysis # TestIDPhysValMon.AnalysisConfig = "nTuple" #nTuple Analysis if (rec.doTruth == True): TestIDPhysValMon.mcTruth = True TestIDPhysValMon.ntupleChainNames = ['Truth'] TestIDPhysValMon.sctHitsOffline = -1 TestIDPhysValMon.pixHitsOffline = -1 if (pdgid != 0): TestIDPhysValMon.SelectTruthPdgId = pdgid elif (cosmic): TestIDPhysValMon.mcTruth = False TestIDPhysValMon.ntupleChainNames = ['Offline'] TestIDPhysValMon.sctHitsOffline = -1 TestIDPhysValMon.pixHitsOffline = -1 else: TestIDPhysValMon.mcTruth = False TestIDPhysValMon.ntupleChainNames = ['Offline',name] # use default values ? # TestIDPhysValMon.sctHitsOffline = 1 # TestIDPhysValMon.pixHitsOffline = 1 TestIDPhysValMon.ntupleChainNames += chainnames TestIDPhysValMon.releaseMetaData = d['nightly name'] + " " + d['nightly release'] + " " + d['date'] + " " + d['platform'] + " " + d['release'] from AthenaCommon.AppMgr import ToolSvc ToolSvc += TestIDPhysValMon Monname = "TrigTestPhysValMon/" + Monname return Monname ############### Electrons ############### name = "Electron" pdgid = 11 useHighestPT = True chainnames = [ "HLT_e.*idperf.*:InDetTrigTrackingxAODCnv_Electron_IDTrig", "HLT_e.*idperf.*:InDetTrigTrackingxAODCnv_Electron_FTF" ] outputlist += [makePhysvalMon(name, pdgid, chainnames, useHighestPT )] ############### Muons ############### name = "Muon" pdgid = 13 useHighestPT = True chainnames = [ "HLT_mu.*idperf.*:InDetTrigTrackingxAODCnv_Muon_IDTrig", "HLT_mu.*idperf.*:InDetTrigTrackingxAODCnv_Muon_FTF" ] outputlist += [makePhysvalMon(name, pdgid, chainnames, useHighestPT )] ############### Taus ############### name = "Tau" pdgid = 15 useHighestPT = True chainnames = [ "HLT_tau.*idperf.*:key=InDetTrigTrackingxAODCnv_Tau_IDTrig:roi=forID3", "HLT_tau.*idperf.*:key=InDetTrigTrackingxAODCnv_Tau_FTF:roi=forID", "HLT_tau.*idperf.*:key=InDetTrigTrackingxAODCnv_TauCore_FTF:roi=forID1", "HLT_tau.*idperf.*:key=InDetTrigTrackingxAODCnv_TauIso_FTF:roi=forID3" ] outputlist += [makePhysvalMon(name, pdgid, chainnames, useHighestPT )] ############### Bjets ############### name = "Bjet" pdgid = 5 useHighestPT = False chainnames = [ "HLT_j.*b.*perf_split:key=InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF:roi=TrigSuperRoi", "HLT_j.*b.*perf_split:InDetTrigTrackingxAODCnv_Bjet_IDTrig", "HLT_j.*b.*perf_split:InDetTrigTrackingxAODCnv_Bjet_FTF", "HLT_mu.*b.*perf_dr05:key=InDetTrigTrackingxAODCnv_BjetPrmVtx_FTF:roi=TrigSuperRoi", "HLT_mu.*b.*perf_dr05:InDetTrigTrackingxAODCnv_Bjet_IDTrig", "HLT_mu.*b.*perf_dr05:InDetTrigTrackingxAODCnv_Bjet_FTF" ] outputlist += [makePhysvalMon(name, pdgid, chainnames, useHighestPT )] ############### Bphys ############### name = "Bphys" pdgid = 0 # Doesn't make sense useHighestPT = False chainnames = [ "HLT_.*Bmumux.*:InDetTrigTrackingxAODCnv_Bphysics_IDTrig", "HLT_.*Bmumux.*:InDetTrigTrackingxAODCnv_Bphysics_FTF" ] outputlist += [makePhysvalMon(name, pdgid, chainnames, useHighestPT )] ############### Cosmics ############### name = "Cosmic" useHighestPT = False pdgid = 0 # Not used for cosmic chainnames = [ 'HLT_.*id.*cosmic.*:InDetTrigTrackingxAODCnvIOTRT_CosmicsN_EFID', 'HLT_.*id.*cosmic.*:InDetTrigTrackingxAODCnv_CosmicsN_EFID' ] outputlist += [makePhysvalMon(name, pdgid, chainnames, useHighestPT, cosmic=True)] return outputlist
doAside = True, # obsolete doCside = True, # obsolete doStraws = True, doChips = True, doShift = True, doDiagnostic = True, # obsolete EventBurstCut = eventBurstCut, # default = 200 DoRDOsMon = True, DoGeoMon = False, DoTracksMon = True, doExpert = athenaCommonFlags.isOnline(), IsCosmics = InDetFlags.doCosmics(), InDetTRT_DAQ_ConditionsSvc = InDetTRT_DAQ_ConditionsSvc, doEfficiency = False, # ME: turn off TRT hole search, it fails Tier-0 every_xth_track = 25, whatdatatype = DQMonFlags.monManDataType(), MinTRTHitCut = 10, max_abs_d0 = 10 * Units.mm, max_abs_z0 = 300 * Units.mm, max_abs_eta = 2.5, MinTrackP = 0.0 * Units.GeV, min_pT = minTrkPtCut, # default = 0.5 GeV min_si_hits = minSiHitCut, # default = 3 min_pixel_hits = minPixHitCut, # default = 1 min_sct_hits = 0, min_trt_hits = 10 ) if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'): InDetTRT_Monitoring_Tool.FilterTools.append(monFilledBunchFilterTool)
from InDetRecExample import TrackingCommon if (not 'doIdGlobalErrorMon' in dir()): doIdGlobalErrorMon = False #################################################### # # # InDetGlobalManager top algorithm # # # #################################################### if InDetFlags.doMonitoringGlobal() or InDetFlags.doMonitoringPrimaryVertexingEnhanced(): from AthenaMonitoring.DQMonFlags import DQMonFlags from InDetGlobalMonitoring.InDetGlobalMonitoringConf import InDetGlobalManager InDetGlobalManager=InDetGlobalManager( name = "InDetGlobalManager", TRT_DriftCircleName = InDetKeys.TRT_DriftCircles(), FileKey = DQMonFlags.monManFileKey(), ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(), ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup(), DataType = DQMonFlags.monManDataType(), Environment = DQMonFlags.monManEnvironment(), Run = DQMonFlags.monManRun(), LumiBlock = DQMonFlags.monManLumiBlock(), doTopBottom = True, doPixel = DetFlags.haveRDO.pixel_on(), doSCT = DetFlags.haveRDO.SCT_on(), doTRT = DetFlags.haveRDO.TRT_on(), AthenaMonTools = []) # these are set at the end if InDetFlags.doMonitoringGlobal(): ####################################################### # #
rec.readAOD = True rec.doWriteESD = False rec.doWriteAOD = False rec.doWriteTAG = False ############################### # Setup Athena Monitoring ############################### from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager if not 'DQMonFlags' in dir(): from AthenaMonitoring.DQMonFlags import DQMonFlags HLTmetOutputLevel = INFO myTrigDecisionTool = "" if (DQMonFlags.useTrigger() and hasattr(ToolSvc, DQMonFlags.nameTrigDecTool())): myTrigDecisionTool = getattr(ToolSvc, DQMonFlags.nameTrigDecTool()) else: from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool") ToolSvc.TrigDecisionTool.OutputLevel = ERROR ToolSvc.TrigDecisionTool.Navigation.OutputLevel = ERROR HLTmetMonMan = AthenaMonManager(name="HLTMonManager", FileKey=DQMonFlags.monManFileKey(), Environment=DQMonFlags.monManEnvironment(), OutputLevel=HLTmetOutputLevel) topSequence += HLTmetMonMan
elif (DQMonFlags.monType == 'BS_ESD'): if rec.readRDO(): DQMonFlags.monManEnvironment = 'tier0Raw' if rec.readESD(): DQMonFlags.monManEnvironment = 'tier0ESD' if rec.readAOD(): DQMonFlags.monManEnvironment = 'AOD' elif DQMonFlags.monType == 'BSall': DQMonFlags.monManEnvironment = 'tier0' if rec.readESD(): DQMonFlags.doMonitoring = False else: local_logger.warning( "invalid DQMonFlags.monType: %s, using default monManEnvironment", DQMonFlags.monType()) if not DQMonFlags.doMonitoring(): local_logger.info("monitoring globally switched off") DQMonFlags.doGlobalMon = False DQMonFlags.doLVL1CaloMon = False DQMonFlags.doCTPMon = False DQMonFlags.doHLTMon = False DQMonFlags.doPixelMon = False DQMonFlags.doSCTMon = False DQMonFlags.doTRTMon = False DQMonFlags.doTRTElectronMon = False DQMonFlags.doInDetGlobalMon = False DQMonFlags.doInDetAlignMon = False DQMonFlags.doInDetPerfMon = False DQMonFlags.doLArMon = False
HLTMonFlags.doMET = True HLTMonFlags.doJet = True HLTMonFlags.doBjet = True HLTMonFlags.doTau = True HLTMonFlags.doMuon = True HLTMonFlags.doIDtrk = True HLTMonFlags.doCalo = True HLTMonFlags.doBphys = False HLTMonFlags.doMinBias = False #-- setup DQTDataFlow ------------------------------------------------------------------------------ from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager( "GlobalMonManager" ) ManagedAthenaGlobalMon = topSequence.GlobalMonManager ManagedAthenaGlobalMon.FileKey = "GLOBAL" ManagedAthenaGlobalMon.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup() ManagedAthenaGlobalMon.DataType = DQMonFlags.monManDataType() ManagedAthenaGlobalMon.Environment = DQMonFlags.monManEnvironment() from DataQualityTools.DataQualityToolsConf import DQTDataFlowMonTool import os if 'AtlasProject' in os.environ and 'AtlasVersion' in os.environ: releaseString = '%s-%s' % (os.environ['AtlasProject'], os.environ['AtlasVersion']) else: releaseString = 'Unknown' DQTDataFlowMon = DQTDataFlowMonTool(name = 'DQTDataFlowMon', histoPathBase = '/GLOBAL/DQTDataFlow', releaseString = releaseString) #ToolSvc += DQTDataFlowMon #bugfix ATR-20161
## @file TrigT1CaloMonitoring_forRecExCommission.py # # Standard monitoring jobOptions - runs on Tier0 (Reco_trf.py) or online. # # @authors Johanna Fleckner, Andrea Neusiedl, Peter Faulkner # if not 'DQMonFlags' in dir(): print "TrigT1CaloMonitoring_forRecExCommission.py: DQMonFlags not yet imported - I import them now" from AthenaMonitoring.DQMonFlags import DQMonFlags # On Tier0 select monitoring tools according to processing step if DQMonFlags.monManEnvironment() == 'tier0Raw': # Tier0 RAWtoESD step l1caloRawMon = True l1caloESDMon = False elif DQMonFlags.monManEnvironment() == 'tier0ESD': # Tier0 ESDtoAOD step l1caloRawMon = False l1caloESDMon = True else: # Anything else l1caloRawMon = True l1caloESDMon = True if l1caloRawMon: Offline = not athenaCommonFlags.isOnline isData = (globalflags.DataSource() == "data") isCalo = (rec.doCalo() and rec.doLArg() and rec.doTile()) triggerConfigService = "TrigConf::TrigConfigSvc/TrigConfigSvc"
#Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration # CaloTransverseBalanceVecMon_jobOpt.py # Author : FENG TIAN #---------------------------------------------------------- from CaloMonitoring.CaloMonitoringConf import CaloTransverseBalanceVecMon from AthenaMonitoring.DQMonFlags import DQMonFlags if DQMonFlags.monManEnvironment() == 'online': TG_NoTA = "run" else: TG_NoTA = "lowStat" GeV = 1000 # no trigger awareness CaloTransverseBalanceMonNoTA = CaloTransverseBalanceVecMon( name="CaloTransverseBalanceMonNoTA", # Time granularity: by default it is run. It can be: run,eventsblock,lumiblock,10minutes,20minutes,90minutes,fill,all.Uncomment to modify. TimeGran=TG_NoTA, Calo_LArNoisyAlg=TRUE, # variables cut used in gamma-jet balance photonPTCut=20 * GeV, ) #ToolSvc += CaloTransverseBalanceMonNoTA CaloMon.AthenaMonTools += [CaloTransverseBalanceMonNoTA]
elif DQMonFlags.monManEnvironment() == 'tier0Raw': MuonRawMon=True MuonESDMon=False elif DQMonFlags.monManEnvironment() == 'tier0ESD': MuonRawMon=False MuonESDMon=True elif DQMonFlags.monManEnvironment() == 'tier0': MuonRawMon=True MuonESDMon=True ## add an AthenaMonManager algorithm to the list of algorithms to be ran from AthenaMonitoring.DQMonFlags import DQMonFlags from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager muonOutputLevel=INFO if DQMonFlags.doMuonRawMon(): try: if MuonRawMon: if MuonDQADetFlags.doRPCL1Mon(): include ("RpcRawDataMonitoring/RpcRawBS_MonitoringOptions.py") if MuonDQADetFlags.doCSCMon() or MuonDQADetFlags.doCSCClusMon(): include ("CscRawDataMonitoring/CscRawBS_MonitoringOptions.py") if MuonESDMon: # add configuration of muon cablings import MuonCnvExample.MuonCablingConfig if MuonDQADetFlags.doMDTMon(): include ("MdtRawDataMonitoring/MdtRaw_MonitoringOptions.py") if MuonDQADetFlags.doRPCMon(): include ("RpcRawDataMonitoring/RpcRawESD_MonitoringOptions.py") if MuonDQADetFlags.doTGCMon() or MuonDQADetFlags.doTGCL1Mon: include ("TgcRawDataMonitoring/TgcRaw_MonitoringOptions.py")
#-------------------------------------------------------------- # Load Inner Detector Monitoring, use the data quality flags for steering #-------------------------------------------------------------- if InDetFlags.doMonitoring(): if not hasattr(ServiceMgr, 'THistSvc'): from GaudiSvc.GaudiSvcConf import THistSvc ServiceMgr += THistSvc() from AthenaMonitoring.DQMonFlags import DQMonFlags DQMonFlags.monManFileKey = "GLOBAL" DQMonFlags.monManManualDataTypeSetup = True DQMonFlags.monManManualRunLBSetup = True DQMonFlags.monManDataType = "monteCarlo" DQMonFlags.monManEnvironment = "user" DQMonFlags.monManRun = 1 DQMonFlags.monManLumiBlock = 1 ServiceMgr.THistSvc.Output += [ DQMonFlags.monManFileKey()+" DATAFILE='monitoring.root' OPT='RECREATE'" ] include( "InDetRecExample/InDetMonitoring.py" ) # ------------------------------------------------------------ # switch off history service and no dump # ------------------------------------------------------------ ServiceMgr.StoreGateSvc.ActivateHistory = False ServiceMgr.StoreGateSvc.Dump = False # ------------------------------------------------------------ # get stack dump # ------------------------------------------------------------ gbl.AthenaServices.SetFatalHandler(438)