def __init__(self, name): mlog = logging.getLogger(name+'::__init__') mlog.info("entering") egammaMonTool.__init__(self,name) _name = name try: ## add an AthenaMonManager algorithm to the list of algorithms to be ran from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager monMan = AthenaMonManager( "MonManager_%s" % name ) monMan.AthenaMonTools += [ "egammaMonTool/'%s'" % name ] # FileKey must match that given to THistSvc monMan.FileKey = "'%s'" % name # Set global monitoring parameters: see the AthenaMonManager class # in the Control/AthenaMonitoring package monMan.ManualDataTypeSetup = True monMan.DataType = "monteCarlo" monMan.Environment = "user" monMan.ManualRunLBSetup = True monMan.Run = 1 monMan.LumiBlock = 1 except Exception: mlog.error("could not initialize egammaMonTool/%s" % name) print(traceback.format_exc()) return False # get a handle on the top sequence of algorithms from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += monMan
from AthenaCommon.AlgSequence import AlgSequence from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager from MissingETMonitoring.MissingETMonitoringConf import * from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool from JetSelectorTools.JetSelectorToolsConf import JetCleaningTool cleaningTool = JetCleaningTool("LooseBadJets", CutLevel="LooseBad") ToolSvc += cleaningTool topSequence = AlgSequence() monManETmiss = AthenaMonManager( name="ETmissMonManager", FileKey=DQMonFlags.monManFileKey(), Environment=DQMonFlags.monManEnvironment(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType()) topSequence += monManETmiss # Monitoring of all events and XE trigger if DQMonFlags.useTrigger(): triggerList = [""] # All triggers # triggerList += ["EF_xe30_FEB_L1EM5"] # updated on March, 2012 (Heavy Ion runs) # triggerList += ["EF_xe25_FEB_L1TE90"] # updated on March, 2012 # triggerList += ["EF_xe30"] # updated on June, 2013 triggerList += ["L1_XE35"] # updated on June, 2013 # triggerList += ["EF_xe80"] # updated on June, 2013 else: triggerList = [""] # If trigger is on then run twice the same tools:
# main jobOption include("RecExCommon/RecExCommon_topOptions.py") # TDT from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool") ToolSvc.TrigDecisionTool.TrigDecisionKey = 'xTrigDecision' from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager monMan = AthenaMonManager("PhysValMonManager") monMan.FileKey = "PhysVal" topSequence += monMan from GaudiSvc.GaudiSvcConf import THistSvc ServiceMgr += THistSvc() ServiceMgr.THistSvc.Output += [ "PhysVal DATAFILE='PhysVal.root' OPT='RECREATE'" ] from AthenaCommon.AppMgr import ToolSvc from TrigEgammaAnalysisTools.TrigEgammaAnalysisToolsConfig import TrigEgammaNavAnalysisTool, TrigEgammaNavTPAnalysisTool from TrigEgammaAnalysisTools.TrigEgammaProbelist import default
if not hasattr(runArgs,"monFlags"): HLTMonFlags.doGeneral = True HLTMonFlags.doEgamma = True 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',
################################ # 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,
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]] elif jobproperties.Beam.beamType() == 'collisions': InDetAlignMonManager.AthenaMonTools += [InDetAlignMonSivsTRT_noTrig]
#-------------------------------------------------------------- # Load ReadCalibData Alg and Service #-------------------------------------------------------------- from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from InDetPhysValMonitoring.InDetPhysValMonitoringConf import HistogramDefinitionSvc ToolSvc = ServiceMgr.ToolSvc ServiceMgr+=HistogramDefinitionSvc() ServiceMgr.HistogramDefinitionSvc.DefinitionSource="../share/testHDef.xml" ServiceMgr.HistogramDefinitionSvc.DefinitionFormat="text/xml" from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager monMan = AthenaMonManager( "PhysValMonManager" ) monMan.ManualDataTypeSetup = True monMan.DataType = "monteCarlo" monMan.Environment = "altprod" monMan.ManualRunLBSetup = True monMan.Run = 1 monMan.LumiBlock = 1 monMan.FileKey = "TestPlots" topSequence += monMan from InDetPhysValMonitoring.InDetPhysValMonitoringConf import ToolTestMonitoringPlots tool1 = ToolTestMonitoringPlots() ToolSvc += tool1
else: LVL1ConfigSvc.ConfigSource = "XML" #LVL1ConfigSvc.XMLFile = "HLTconfig_Physics_pp_v1_16.1.0.2.xml" LVL1ConfigSvc.XMLMenuFile = "HLTconfig_Physics_pp_v1_16.1.0.2.xml" LVL1ConfigSvc.CreateLegacyObjects = True svcMgr += LVL1ConfigSvc ## get a handle on the ToolSvc ## add an AthenaMonManager algorithm to the list of algorithms to be ran ## get a handle to the default top-level algorithm sequence from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() if not hasattr(topSequence,"PrimaryManager"): from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager( "PrimaryManager" ) ## AthenaMonManager is the Algorithm that manages many classes inheriting ## from ManagedMonitorToolBase CTmonMan = topSequence.PrimaryManager from TrigT1CTMonitoring.TrigT1CTMonitoringConf import TrigT1CTMonitoring__BSMonitoring as BSMon #svcMgr.ToolSvc += BSMon() BSMonJob=BSMon(ProcessMuctpiData=True, ProcessMuctpiDataRIO=True, ProcessCTPData=True, ProcessRoIBResult=True, InclusiveTriggerThresholds=True, CompareRerun=True) CTmonMan.AthenaMonTools += [BSMonJob] #[ "TrigT1CTMonitoring__BSMonitoring/BSMon" ] CTmonMan.FileKey = "GLOBAL"
#InDetTrackPerfMonManager.FileKey = "InDetPerformanceMon" # -------------------------------------------- # # --- Physics Validation Monitoring # # -------------------------------------------- if InDetFlags.doPhysValMon(): from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager InDetPhysValMonManager = AthenaMonManager( name="InDetPhysValMonManager", FileKey="PhysValMon", ManualDataTypeSetup=True, DataType="userDefined", # use this for collision data for now Environment="user", ManualRunLBSetup=True, Run=1, LumiBlock=1) topSequence += InDetPhysValMonManager if (InDetFlags.doPrintConfigurables()): print(InDetPhysValMonManager) from InDetPhysValMonitoring.InDetPhysValMonitoringConf import InDetPhysValMonitoringTool if InDetFlags.doDBMstandalone(): InDetPhysValMonTool = InDetPhysValMonitoringTool( useTrackSelection=False, TrackParticleContainerName="InDetDBMTrackParticles", TrackSelectionTool=None, TruthSelectionTool=None,
if not 'MonitorOutput' in dir(): # MonitorOutput="SHIFT" MonitorOutput = "Tile" #************************************************************** # # jopOptions file for Tile Monitoring in Athena # #============================================================== from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("ManagedAthenaTileMon") ManagedAthenaTileMon = topSequence.ManagedAthenaTileMon from AthenaCommon.AppMgr import ServiceMgr ManagedAthenaTileMon.FileKey = "SHIFT" ManagedAthenaTileMon.ManualDataTypeSetup = True ManagedAthenaTileMon.DataType = "cosmics" if athenaCommonFlags.isOnline(): ManagedAthenaTileMon.Environment = "online" else: ManagedAthenaTileMon.Environment = "online" #ManagedAthenaTileMon.Environment = "tier0" #ManagedAthenaTileMon.ManualRunLBSetup = False ManagedAthenaTileMon.ManualRunLBSetup = True
if DQMonFlags.useTrigger(): # trigger decision tool try: include("AthenaMonitoring/TrigDecTool_jobOptions.py") except Exception: treatException( "Could not load AthenaMonitoring/TrigDecTool_jobOptions.py") # set up first monitoring manager to set static variables from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager monManGlobal = AthenaMonManager( name="AthenaMonManager", FileKey=DQMonFlags.monManFileKey(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType(), Environment=DQMonFlags.monManEnvironment(), LBsInLowStatInterval=DQMonFlags.monManLBsInLowStatInterval(), LBsInMediumStatInterval=DQMonFlags.monManLBsInMediumStatInterval(), LBsInHighStatInterval=DQMonFlags.monManLBsInHighStatInterval(), ManualRunLBSetup=DQMonFlags.monManManualRunLBSetup(), Run=DQMonFlags.monManRun(), LumiBlock=DQMonFlags.monManLumiBlock()) topSequence += monManGlobal # set up histogram output file if (DQMonFlags.histogramFile() != "") and (DQMonFlags.monManFileKey() != ""): from AthenaCommon.AppMgr import ServiceMgr as svcMgr if not hasattr(svcMgr, 'THistSvc'): from GaudiSvc.GaudiSvcConf import THistSvc svcMgr += THistSvc() svcMgr.THistSvc.Output += [
elif DQMonFlags.monManEnvironment() == 'tier0ESD': MuonRawMon=False MuonESDMon=True else: # 'tier0' MuonRawMon=True MuonESDMon=True if DQMonFlags.doMonitoring: # ****************************** # Muon Monitoring configuration # ****************************** from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager monMan = AthenaMonManager(name="MuonMonManager", FileKey = DQMonFlags.monManFileKey, ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup, DataType = DQMonFlags.monManDataType, Environment = DQMonFlags.monManEnvironment, ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup, Run = DQMonFlags.monManRun, LumiBlock = DQMonFlags.monManLumiBlock) topSequence += monMan #-------------------------------------------------------------- ### MuonRaw Monitoring ### if DQMonFlags.doMuonRawMon: if MuonRawMon: include("MuonRawDataMonitoring/MuonRawBS_MonitoringOptions.py") elif MuonESDMon: include("MuonRawDataMonitoring/MuonRawESD_MonitoringOptions.py") #-------------------------------------------------------------- ### MuonSegm Monitoring ### if DQMonFlags.doMuonSegmMon and MuonESDMon: include("MuonSegmMonitoring/MuonSegmDQA_options.py")
OutputLevel = 4, doTrigger = globalflags.DataSource == "data") from RecExConfig.RecFlags import rec if not rec.doTrigger(): InDetSCTRatioNoiseMonTool.doTrigger=False ToolSvc += InDetSCTRatioNoiseMonTool if (InDetFlags.doPrintConfigurables()): print InDetSCTRatioNoiseMonTool from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager InDetSCTMonMan = AthenaMonManager("InDetSCTMonManager", FileKey = DQMonFlags.monManFileKey(), ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(), ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup(), DataType = DQMonFlags.monManDataType(), Environment = DQMonFlags.monManEnvironment(), Run = DQMonFlags.monManRun(), LumiBlock = DQMonFlags.monManLumiBlock(), AthenaMonTools = [ InDetSCTTracksMonTool, InDetSCTRatioNoiseMonTool, InDetSCTLorentzMonTool, InDetSCTHitEffMonTool, InDetSCTHitsTool, InDetSCTErrMonTool ] ) topSequence += InDetSCTMonMan if (InDetFlags.doPrintConfigurables()): print InDetSCTMonMan
## read pool data import AthenaPoolCnvSvc.ReadAthenaPool svcMgr.EventSelector.InputCollections = [InputCollections] ## get the one and only one Athena Application Mgr from AthenaCommon.AppMgr import theApp theApp.EvtMax = EvtMax ## get a handle on the top sequence of algorithms from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() ## add an AthenaMonManager algorithm to the list of algorithms to be ran from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("AthenaMonManagerPV") # ************************ # Monitoring configuration # ************************ ## Setup the output file(s): from GaudiSvc.GaudiSvcConf import THistSvc svcMgr += THistSvc() ## The string "TestMon" in the argument below is the 'FileKey' ## used by Athena to access the output file internally if OutputFileName != 'NONE': svcMgr.THistSvc.Output += [ "PhysValMon DATAFILE='" + OutputFileName + "' OPT='RECREATE'"
#-----------ONLINE CODE--------------------- if isOnline and jp.ConcurrencyFlags.NumThreads() == 0: #from TrigServices.TrigServicesConf import TrigMonTHistSvc #THistSvc = TrigMonTHistSvc("THistSvc") #svcMgr += THistSvc doHist = True InputDir = "." OutputDir = "." FilePreFix = ["MonTest"] RootHistFileName = 'HistFile.root' ## add an AthenaMonManager algorithm to the list of algorithms to be ran if not hasattr(topSequence, "PrimaryManager"): from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("PrimaryManager") ## AthenaMonManager is the Algorithm that manages many classes inheriting ## from ManagedMonitorToolBase CTmonMan = topSequence.PrimaryManager theApp.Dlls += ["TrigT1CTMonitoring"] CTmonMan.AthenaMonTools += ["TrigT1CTMonitoring__BSMonitoring/BSMon"] ## FILEKEY must match that given to THistSvc CTmonMan.FileKey = "GLOBAL" DetDescrVersion = "ATLAS-DC3-05" # 11.0.42 files AllAlgs = False # if false, all algorithms are switched off by defaults from AthenaCommon.GlobalFlags import GlobalFlags
from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() ## add an AthenaMonManager algorithm to the list of algorithms to be ran from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager AFPMonManager = AthenaMonManager( name="AFPHitsMonitoringManager", FileKey=DQMonFlags.monManFileKey(), Environment=DQMonFlags.monManEnvironment(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType()) topSequence += AFPMonManager # ===== Silicon hits monitor ===== from AFP_Monitoring.AFP_MonitoringConf import AFPHitsMonitorTool AFPSiHitsMonTool = AFPHitsMonitorTool(name="AFPSiHitsMonitoring", PreScale=0, EnableLumi=True) layersInStationN = 4 from AFP_Monitoring.AFP_MonitoringConf import AFPSiStationMonitor # *** station 0 *** from AFP_Monitoring.AFP_MonitoringConf import AFPSiLayerMonitor layersStation0 = list() for layerID in range(layersInStationN): toolName = "station0Layer" toolName += str(layerID) layerTool = AFPSiLayerMonitor(name=toolName, pixelLayerID=layerID,
if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'): InDetTRT_Monitoring_Tool.FilterTools.append(monFilledBunchFilterTool) ToolSvc += InDetTRT_Monitoring_Tool if (InDetFlags.doPrintConfigurables()): print InDetTRT_Monitoring_Tool #------------------------------------------------------------- # add an AthenaMonManager algorithm to the list of algorithms to be ran #------------------------------------------------------------- from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager InDetTRTMonMan = AthenaMonManager( "TRTMonManager", FileKey = DQMonFlags.monManFileKey(), #"GLOBAL" #"stat" ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(), #True DataType = DQMonFlags.monManDataType(), #"cosmics" Environment = DQMonFlags.monManEnvironment(), #"user" ManualRunLBSetup = DQMonFlags.monManManualRunLBSetup(), #True Run = DQMonFlags.monManRun(), #1 LumiBlock = DQMonFlags.monManLumiBlock(), #1 AthenaMonTools = [ InDetTRT_Monitoring_Tool ]) topSequence += InDetTRTMonMan if (InDetFlags.doPrintConfigurables()): print InDetTRTMonMan
from AthenaMonitoring.DQMonFlags import DQMonFlags from AthenaCommon.AthenaCommonFlags import athenaCommonFlags from AthenaCommon.AppMgr import ServiceMgr as svcMgr from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager TRTElectronMonManager = AthenaMonManager( name="TRTElectronMonManager", FileKey=DQMonFlags.monManFileKey(), ManualDataTypeSetup=DQMonFlags.monManManualDataTypeSetup(), DataType=DQMonFlags.monManDataType(), Environment=DQMonFlags.monManEnvironment(), ManualRunLBSetup=DQMonFlags.monManManualRunLBSetup(), Run=DQMonFlags.monManRun(), LumiBlock=DQMonFlags.monManLumiBlock()) topSequence += TRTElectronMonManager from InDetPerformanceMonitoring.InDetPerformanceMonitoringConf import TRT_Electron_Monitoring_Tool TRT_Electron_Monitoring_Tool = TRT_Electron_Monitoring_Tool( name="TRT_Electron_Monitoring_Tool", #trackName = InDetKeys.TRTTracks() if InDetFlags.doTrackSegmentsTRT() else InDetKeys.UnslimmedTracks(), # trackName = "CombinedInDetTracks", # trackName = "CombinedTrackParticle", trackName="InDetTrackParticles", electronName="Electrons", muonName="Muons", conversionName="ConversionCandidate", doShift=True, doTracksMon=True, doElectronMon=True, doMuonMon=True, doRecElectrons=True,
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 # in order to check available detectors from RecExConfig.RecFlags import rec try: from TrigMETMonitoring.TrigMETMonitoringConfig import HLTMETMonitoringTool HLTmetMonMan.AthenaMonTools += HLTMETMonitoringTool() except: print "Problems with HLTMETTool, tool not enabled" HLTmetMonMan.FileKey = "MonitorHLTmet"
ToolSvc, 'DQFilledBunchFilterTool'): InDetPixelMainsMonOnTrack.FilterTools.append(monFilledBunchFilterTool) ToolSvc += InDetPixelMainsMonOnTrack if (InDetFlags.doPrintConfigurables()): print InDetPixelMainsMonOnTrack ########################################################################## # 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] topSequence += InDetPixMonMan if (InDetFlags.doPrintConfigurables()): print InDetPixMonMan
# # Include Pixel monitoring package # ServiceMgr.THistSvc.Output += [ "GLOBAL DATAFILE='PixelMonitoring.root' OPT='RECREATE'" ] # # Add an AthenaMonManager algorithm to the list of algorithms to be ran # # AthenaMonManager is the Algorithm that manages many classes inheriting # from ManagedMonitorToolBase # from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager monMan = AthenaMonManager("PixelMonManager") from PixelMonitoring.PixelMonitoringConf import * PixelMainsMon = PixelMainMon() ToolSvc += PixelMainsMon monMan.AthenaMonTools += [PixelMainsMon] print PixelMainsMon ## FileKey must match that given to THistSvc monMan.FileKey = "GLOBAL" ## Set global monitoring parameters: see the AthenaMonManager class ## in the Control/AthenaMonitoring package monMan.ManualDataTypeSetup = True monMan.DataType = "montecarlo" monMan.Environment = "user"
# 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: try:
CscCalcSlope = MuonCalib__CscCalcSlope("CscCalcSlope") topSequence += CscCalcSlope #Specify output calibration file CscCalcSlope.OutputFile = outputTextFile #Define calculations to do. PedestalRun is contradictory to the other options. CscCalcSlope.DoCrossTalkFix = True CscCalcSlope.DoBipolarFit = True CscCalcSlope.GetPedFromFile = False #CscCalcSlope.OutputLevel = DEBUG #if(ToolSvc.CscRdoContByteStreamTool.IsCosmicData) : # CscCalcSlope.ExpectedChamberLayer = 1 from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("MuonMonManager") # ****************************** # Muon Monitoring configuration # ****************************** monMan = topSequence.MuonMonManager #monMan = topSequence.PrimaryManager monMan.FileKey = "CscCalibMon" #"muoncosmics" ## FileKey must match that given to THistSvc ## Set global monitoring parameters: see the AthenaMonManager class # in the Control/AthenaMonitoring package monMan.ManualDataTypeSetup = True monMan.DataType = "monteCarlo" monMan.Environment = "user" monMan.ManualRunLBSetup = True monMan.Run = 1 monMan.LumiBlock = 1
#============================================================== from AthenaCommon.AthenaCommonFlags import athenaCommonFlags from AthenaCommon import CfgMgr 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':
13, -13, 1000015, -1000015 ] doMon = False if (doMon): from MuonPhysValMonitoring.MuonPhysValMonitoringConf import MuonPhysValMonitoring__MuonPhysValMonitoringTool tool1 = MuonPhysValMonitoring__MuonPhysValMonitoringTool() tool1.EnableLumi = False tool1.DetailLevel = 1 tool1.OutputLevel = VERBOSE tool1.MuonContainerName = colname ToolSvc += tool1 from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("PhysValMonManager") from AthenaCommon.AppMgr import ServiceMgr from GaudiSvc.GaudiSvcConf import THistSvc ServiceMgr += THistSvc() svcMgr.THistSvc.Output += [ "MuonMonExample DATAFILE='MuonMonExample.root' OPT='RECREATE'" ] monMan = topSequence.PhysValMonManager monMan.ManualDataTypeSetup = True monMan.DataType = "monteCarlo" monMan.Environment = "altprod" monMan.ManualRunLBSetup = True monMan.Run = 1 monMan.LumiBlock = 1
theBadRamp.RampToleranceFEB = ["0.05,0.05,0.05"] theBadRamp.KeyList = GainList theBadRamp.ValidationKey = "LArRamp" theBadRamp.ReferenceKey = "LArRampRef" theBadRamp.MsgLevelForDeviations = ERROR theBadRamp.ListOfDevFEBs = "Bad_rampFebs.txt" theRampValidationAlg.PatchMissingFEBs = False topSequence += theBadRamp if (doMonitoring): from AthenaMonitoring.DQMonFlags import DQMonFlags DQMonFlags.enableLumiAccess.set_Value_and_Lock(False) from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("LArMon") LArMon = topSequence.LArMon ## old style #LArMon.FileKey = "AllMon" #LArMon.ManualDataTypeSetup = True #LArMon.Environment = "user" #LArMon.ManualRunLBSetup = True #LArMon.Run = 1 #LArMon.LumiBlock = 1 #LArMon.CheckEveryNoEvents = 999999 #to do the check only at the end of the run ## tier0 style LArMon.FileKey = "GLOBAL" LArMon.ManualDataTypeSetup = True LArMon.Environment = "tier0"
from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("SCTMonManager") 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 ?
from LumiBlockComps.LuminosityToolDefault import LuminosityToolDefault lumiTool = LuminosityToolDefault() lumiTool.OutputLevel = DEBUG ToolSvc += lumiTool from LumiBlockComps.TrigLivefractionToolDefault import TrigLivefractionToolDefault liveTool = TrigLivefractionToolDefault() liveTool.OutputLevel = DEBUG ToolSvc += liveTool from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() ## add an AthenaMonManager algorithm to the list of algorithms to be ran from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager topSequence += AthenaMonManager("AthMonTestMan") from AthenaCommon.AppMgr import ServiceMgr as svcMgr svcMgr.MessageSvc.OutputLevel = INFO #svcMgr.MessageSvc.OutputLevel = WARNING #svcMgr.MessageSvc.OutputLevel = DEBUG # ************************ # Monitoring configuration # ************************ ## Setup the output file(s): from GaudiSvc.GaudiSvcConf import THistSvc svcMgr += THistSvc() ## The string "TestMon" in the argument below is the 'FileKey'
#====================================================================== # Standalone JobOptions to run MuonDQAMonitoring on ESD/AOD #====================================================================== # Set up the reading of the input ESD or xAOD: FNAME = '/afs/cern.ch/user/g/gcree/work/public/MuonData/data15_cos.00252404.physics_IDCosmic.merge.AOD.x294_m1374/data15_cos.00252404.physics_IDCosmic.merge.AOD.x294_m1374._lb0002-lb0006._0001.1' include("AthenaPython/iread_file.py") # import AthenaPoolCnvSvc.ReadAthenaPool # ServiceMgr.EventSelector.InputCollections = [ FNAME ] # Access the algorithm sequence: from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager monMan = AthenaMonManager("MyMuonMonManager") monMan.ManualDataTypeSetup = True monMan.DataType = "cosmics" #monMan.DataType = "monteCarlo" #monMan.DataType = "collisions" monMan.Environment = "tier0ESD" # monMan.ManualRunLBSetup = True # monMan.Run = 1 # monMan.LumiBlock = 1 monMan.FileKey = "MuonMon" topSequence += monMan #from MuonRecExample.MuonRecFlags import muonRecFlags from AthenaMonitoring.DQMonFlags import DQMonFlags DQMonFlags.doMuonRawMon = False
if (InDetFlags.doPrintConfigurables()): printfunc(IDPerfMonZee_2e10_loose_ion) #ToolSvc += IDPerfMonWenu_e15_loose_ion if (InDetFlags.doPrintConfigurables()): printfunc(IDPerfMonWenu_e15_loose_ion) ########################### ## add an AthenaMonManager algorithm to the list of algorithms to be ran from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager IDPerfMonManager = AthenaMonManager( name="IDPerfMonManager", FileKey="GLOBAL", ManualDataTypeSetup=True, DataType="userDefined", # use this for collision data for now Environment="user", ManualRunLBSetup=True, # maxPrescale=50, Run=1, LumiBlock=1) IDPerfMonManager.AthenaMonTools += [IDPerfMonZee_noTrig] IDPerfMonManager.AthenaMonTools += [IDPerfMonWenu_noTrig] if not DQMonFlags.useTrigger(): printfunc( "IDPerfMon_jobOptions.py: trigger decision tool not found: don't run trigger-aware monitoring" ) else: if not rec.doHeavyIon(): printfunc('INFO: adding trigger aware monitoring to tool') IDPerfMonManager.AthenaMonTools += [IDPerfMonZee_e24_medium_L1EM18VH]