Beispiel #1
0
        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
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
########################################################################
Beispiel #3
0
         from TrigT1CaloMonitoring.TrigT1CaloMonitoringConf import JetEfficienciesMonTool
         L1JetEfficienciesMonTool = JetEfficienciesMonTool ( name = "JetEfficienciesMonTool",
                                                               TriggerStrings = trigstring
                                                           )
         ToolSvc += L1JetEfficienciesMonTool
         L1CaloManD.AthenaMonTools += [ L1JetEfficienciesMonTool ]
         if not hasattr( #ToolSvc, "TrigDecisionTool" ):
             from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
             tdt = Trig__TrigDecisionTool('TrigDecisionTool')
             ToolSvc += tdt
 
 #=================================================================================
 # FileKey must match that given to THistSvc
 L1CaloMan0A1.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A1.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A1.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A1.DataType            = DQMonFlags.monManDataType()
 L1CaloMan0A2.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A2.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A2.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A2.DataType            = DQMonFlags.monManDataType()
 L1CaloMan0A3.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A3.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A3.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A3.DataType            = DQMonFlags.monManDataType()
 L1CaloMan0A4.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A4.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A4.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A4.DataType            = DQMonFlags.monManDataType()
 # Make sure we run these before RoIBResultToAOD as it also accesses
 # TriggerTowers and JetElements
Beispiel #4
0
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



Beispiel #5
0
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
    tileESDMon=True
                from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
                tdt = Trig__TrigDecisionTool('TrigDecisionTool')
                ToolSvc += tdt
    
        if isData and isCalo and Offline and (rec.triggerStream() == "Egamma"
                                           or rec.triggerStream() == "Muons"
                                           or rec.triggerStream() == "express"):
    
            #=================================================================================
            #=============================== Jet Efficiencies ================================
            #=================================================================================
            trigstring = ['EF_.*']
            from TrigT1CaloMonitoring.TrigT1CaloMonitoringConf import JetEfficienciesMonTool
            L1JetEfficienciesMonTool = JetEfficienciesMonTool ( name = "JetEfficienciesMonTool",
                                                                  TriggerStrings = trigstring
                                                              )
            ToolSvc += L1JetEfficienciesMonTool
            L1CaloMan.AthenaMonTools += [ L1JetEfficienciesMonTool ]
            if not hasattr( ToolSvc, "TrigDecisionTool" ):
                from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
                tdt = Trig__TrigDecisionTool('TrigDecisionTool')
                ToolSvc += tdt
    
    #=================================================================================
    # FileKey must match that given to THistSvc
    L1CaloMan.FileKey             = DQMonFlags.monManFileKey()
    L1CaloMan.Environment         = DQMonFlags.monManEnvironment()
    L1CaloMan.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
    L1CaloMan.DataType            = DQMonFlags.monManDataType()
    topSequence += L1CaloMan
####################################################
#                                                  #
# 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)
Beispiel #8
0
        #ToolSvc += L1CaloCTPMonTool
        L1Man1.AthenaMonTools += [L1CaloCTPMonTool]

    ####################### L1Calo->Level-2 ################################
    from TrigT1Monitoring.TrigT1MonitoringConf import LVL1__L1CaloLevel2Mon
    L1CaloLevel2MonTool = LVL1__L1CaloLevel2Mon(name="L1CaloLevel2MonTool",
                                                #OutputLevel = DEBUG,
                                                )
    #ToolSvc += L1CaloLevel2MonTool
    L1Man2.AthenaMonTools += [L1CaloLevel2MonTool]

    ##########################################################################
    # FileKey must match that given to THistSvc
    L1Man0A.FileKey = DQMonFlags.monManFileKey()
    L1Man0A.Environment = DQMonFlags.monManEnvironment()
    L1Man0A.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
    L1Man0A.DataType = DQMonFlags.monManDataType()
    L1Man0B.FileKey = DQMonFlags.monManFileKey()
    L1Man0B.Environment = DQMonFlags.monManEnvironment()
    L1Man0B.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
    L1Man0B.DataType = DQMonFlags.monManDataType()
    L1Man0C.FileKey = DQMonFlags.monManFileKey()
    L1Man0C.Environment = DQMonFlags.monManEnvironment()
    L1Man0C.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
    L1Man0C.DataType = DQMonFlags.monManDataType()
    L1Man1.FileKey = DQMonFlags.monManFileKey()
    L1Man1.Environment = DQMonFlags.monManEnvironment()
    L1Man1.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
    L1Man1.DataType = DQMonFlags.monManDataType()
    L1Man2.FileKey = DQMonFlags.monManFileKey()
    L1Man2.Environment = DQMonFlags.monManEnvironment()
         from TrigT1CaloMonitoring.TrigT1CaloMonitoringConf import JetEfficienciesMonTool
         L1JetEfficienciesMonTool = JetEfficienciesMonTool ( name = "JetEfficienciesMonTool",
                                                               TriggerStrings = trigstring
                                                           )
         ToolSvc += L1JetEfficienciesMonTool
         L1CaloManD.AthenaMonTools += [ L1JetEfficienciesMonTool ]
         if not hasattr( ToolSvc, "TrigDecisionTool" ):
             from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
             tdt = Trig__TrigDecisionTool('TrigDecisionTool')
             ToolSvc += tdt
 
 #=================================================================================
 # FileKey must match that given to THistSvc
 L1CaloMan0A1.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A1.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A1.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A1.DataType            = DQMonFlags.monManDataType()
 L1CaloMan0A2.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A2.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A2.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A2.DataType            = DQMonFlags.monManDataType()
 L1CaloMan0A3.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A3.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A3.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A3.DataType            = DQMonFlags.monManDataType()
 L1CaloMan0A4.FileKey             = DQMonFlags.monManFileKey()
 L1CaloMan0A4.Environment         = DQMonFlags.monManEnvironment()
 L1CaloMan0A4.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
 L1CaloMan0A4.DataType            = DQMonFlags.monManDataType()
 # Make sure we run these before RoIBResultToAOD as it also accesses
 # TriggerTowers and JetElements