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()):
## @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"
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]
## @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"
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)
