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]
