diff --git a/Control/AthenaMonitoring/python/ExampleMonitorAlgorithm.py b/Control/AthenaMonitoring/python/ExampleMonitorAlgorithm.py index 44d472dd986ee72c466f9f82896b4cfab78bb049..d4ebec701dc1f21fec182bc9e58450c2ed6bb648 100644 --- a/Control/AthenaMonitoring/python/ExampleMonitorAlgorithm.py +++ b/Control/AthenaMonitoring/python/ExampleMonitorAlgorithm.py @@ -31,12 +31,13 @@ def ExampleMonitoringConfig(inputFlags): # helper. Then, the helper will instantiate an instance and set up the # base class configuration following the inputFlags. The returned object # is the algorithm. - from AthenaMonitoring.AthenaMonitoringConf import ExampleMonitorAlgorithm - exampleMonAlg = helper.addAlgorithm(ExampleMonitorAlgorithm,'ExampleMonAlg') + # This uses the new Configurables object system. + from AthenaConfiguration.ComponentFactory import CompFactory + exampleMonAlg = helper.addAlgorithm(CompFactory.ExampleMonitorAlgorithm,'ExampleMonAlg') # You can actually make multiple instances of the same algorithm and give # them different configurations - anotherExampleMonAlg = helper.addAlgorithm(ExampleMonitorAlgorithm,'AnotherExampleMonAlg') + anotherExampleMonAlg = helper.addAlgorithm(CompFactory.ExampleMonitorAlgorithm,'AnotherExampleMonAlg') # # If for some really obscure reason you need to instantiate an algorithm # # yourself, the AddAlgorithm method will still configure the base diff --git a/Control/AthenaMonitoring/python/TriggerInterface.py b/Control/AthenaMonitoring/python/TriggerInterface.py index 59f1deada18866101a629c89f85c59269bd544ec..6c79e4b5c028525bdc36f2d0259bc9c377591020 100644 --- a/Control/AthenaMonitoring/python/TriggerInterface.py +++ b/Control/AthenaMonitoring/python/TriggerInterface.py @@ -13,6 +13,7 @@ def getTrigDecisionTool(flags): if getTrigDecisionTool.rv: return getTrigDecisionTool.rv from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator + from AthenaConfiguration.ComponentFactory import CompFactory rv = ComponentAccumulator() @@ -22,12 +23,10 @@ def getTrigDecisionTool(flags): getTrigDecisionTool.rv = rv return getTrigDecisionTool.rv - from TrigConfxAOD.TrigConfxAODConf import TrigConf__xAODConfigTool - cfgtool = TrigConf__xAODConfigTool('xAODConfigTool') + cfgtool = CompFactory.TrigConf__xAODConfigTool('xAODConfigTool') rv.addPublicTool(cfgtool) - from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool - tdt = Trig__TrigDecisionTool('TrigDecisionTool') + tdt = CompFactory.Trig__TrigDecisionTool('TrigDecisionTool') tdt.ConfigTool = cfgtool tdt.NavigationFormat = "TrigComposite" if 'HLTNav_Summary' in flags.Input.Collections else "TriggerElement" rv.addPublicTool(tdt) @@ -39,13 +38,11 @@ def getTrigDecisionTool(flags): tdt.Navigation.Dlls = [e for e in EDMLibraries if 'TPCnv' not in e] # Minimal config needed to read metadata: MetaDataSvc & ProxyProviderSvc - from AthenaServices.AthenaServicesConf import MetaDataSvc - mdSvc = MetaDataSvc( "MetaDataSvc" ) + mdSvc = CompFactory.MetaDataSvc( "MetaDataSvc" ) mdSvc.MetaDataContainer = "MetaDataHdr" rv.addService(mdSvc) - from SGComps.SGCompsConf import ProxyProviderSvc - pdps = ProxyProviderSvc( "ProxyProviderSvc" ) + pdps = CompFactory.ProxyProviderSvc( "ProxyProviderSvc" ) pdps.ProviderNames += [ "MetaDataSvc" ] rv.addService(pdps) diff --git a/Control/AthenaMonitoring/share/Run3DQTestingDriver.py b/Control/AthenaMonitoring/share/Run3DQTestingDriver.py index 1826f9d9c40b50968caa118b74cd1276e193596c..259c5b18aef27020307e184a143057eb7be014db 100755 --- a/Control/AthenaMonitoring/share/Run3DQTestingDriver.py +++ b/Control/AthenaMonitoring/share/Run3DQTestingDriver.py @@ -44,7 +44,7 @@ if __name__=='__main__': from AthenaMonitoring.DQConfigFlags import allSteeringFlagsOff allSteeringFlagsOff() ConfigFlags.fillFromArgs(args.flags) - isReadingRaw = (GetFileMD(ConfigFlags.Input.Files).get('file_type', 'POOL') == 'RAW') + isReadingRaw = (GetFileMD(ConfigFlags.Input.Files).get('file_type', 'POOL') == 'BS') if isReadingRaw: if ConfigFlags.DQ.Environment not in ('tier0', 'tier0Raw', 'online'): log.warning('Reading RAW file, but DQ.Environment set to %s', @@ -89,14 +89,13 @@ if __name__=='__main__': # Force loading of conditions in MT mode if ConfigFlags.Concurrency.NumThreads > 0: + from AthenaConfiguration.ComponentFactory import CompFactory if len([_ for _ in cfg._conditionsAlgs if _.getName()=="PixelDetectorElementCondAlg"]) > 0: - from AthenaMonitoring.AthenaMonitoringConf import ForceIDConditionsAlg beginseq = cfg.getSequence("AthBeginSeq") - beginseq += ForceIDConditionsAlg("ForceIDConditionsAlg") + beginseq += CompFactoryForceIDConditionsAlg("ForceIDConditionsAlg") if len([_ for _ in cfg._conditionsAlgs if _.getName()=="MuonAlignmentCondAlg"]) > 0: - from AthenaMonitoring.AthenaMonitoringConf import ForceMSConditionsAlg beginseq = cfg.getSequence("AthBeginSeq") - beginseq += ForceMSConditionsAlg("ForceMSConditionsAlg") + beginseq += CompFactory.ForceMSConditionsAlg("ForceMSConditionsAlg") # any last things to do? if args.postExec: diff --git a/DataQuality/DataQualityTools/python/DQTBackgroundMon.py b/DataQuality/DataQualityTools/python/DQTBackgroundMon.py index 93e8fdc383afeb371c7a41af28a6b5ab72550507..844f71746ac4c37bcdfa943d97c31875ee3b7220 100644 --- a/DataQuality/DataQualityTools/python/DQTBackgroundMon.py +++ b/DataQuality/DataQualityTools/python/DQTBackgroundMon.py @@ -3,13 +3,15 @@ # def DQTBackgroundMonAlgConfig(flags, isOld=False): - from AthenaMonitoring import AthMonitorCfgHelper if isOld: # replace with helper for the old configuration from AthenaMonitoring import AthMonitorCfgHelperOld as AthMonitorCfgHelper + from .DataQualityToolsConf import DQTBackgroundMon + else: + from AthenaMonitoring import AthMonitorCfgHelper + from AthenaConfiguration.ComponentFactory import CompFactory + DQTBackgroundMon = CompFactory.DQTBackgroundMon helper = AthMonitorCfgHelper(flags, 'DQTBackgroundMonAlgCfg') - from DataQualityToolsConf import DQTBackgroundMon - from ROOT import EventInfo monAlg = helper.addAlgorithm(DQTBackgroundMon,'DQTBackgroundMonAlg') monAlg.Muons = True diff --git a/DataQuality/DataQualityTools/python/DQTDataFlowMonAlg.py b/DataQuality/DataQualityTools/python/DQTDataFlowMonAlg.py index 86fc5b85c0d91578fcbab70e311da0768a6da1fd..daafa004825e208947a3da07b361df753f2d5abc 100644 --- a/DataQuality/DataQualityTools/python/DQTDataFlowMonAlg.py +++ b/DataQuality/DataQualityTools/python/DQTDataFlowMonAlg.py @@ -4,22 +4,24 @@ def DQTDataFlowMonAlgConfig(flags): from AthenaMonitoring import AthMonitorCfgHelper + from AthenaConfiguration.ComponentFactory import CompFactory helper = AthMonitorCfgHelper(flags, 'DQTDataFlowMonAlgCfg') - _DQTDataFlowMonAlgConfigCore(helper, flags.Input.isMC) + _DQTDataFlowMonAlgConfigCore(helper, CompFactory.DQTDataFlowMonAlg, flags.Input.isMC) return helper.result() def DQTDataFlowMonAlgConfigOld(flags): from AthenaMonitoring import AthMonitorCfgHelperOld + from .DataQualityToolsConf import DQTDataFlowMonAlg from AthenaCommon.GlobalFlags import globalflags helper = AthMonitorCfgHelperOld(flags, 'DQTDataFlowMonAlgCfg') - _DQTDataFlowMonAlgConfigCore(helper, globalflags.DataSource() == 'geant4') + _DQTDataFlowMonAlgConfigCore(helper, DQTDataFlowMonAlg, + globalflags.DataSource() == 'geant4') return helper.result() -def _DQTDataFlowMonAlgConfigCore(helper, isMC): - from .DataQualityToolsConf import DQTDataFlowMonAlg +def _DQTDataFlowMonAlgConfigCore(helper, algConfObj, isMC): from ROOT import EventInfo - monAlg = helper.addAlgorithm(DQTDataFlowMonAlg,'DQTDataFlowMonAlg') + monAlg = helper.addAlgorithm(algConfObj,'DQTDataFlowMonAlg') # arguments are: algorithm, name of group used to access it from the alg, # the 'top level path' to put outputs in, and the default duration of diff --git a/DataQuality/DataQualityTools/python/DQTDetSynchMonAlg.py b/DataQuality/DataQualityTools/python/DQTDetSynchMonAlg.py index 269501672d1aa6b59e8a46efc4dd4d59d058407c..8c0b25b12d9c982473ace68a7bea1b093323d68f 100644 --- a/DataQuality/DataQualityTools/python/DQTDetSynchMonAlg.py +++ b/DataQuality/DataQualityTools/python/DQTDetSynchMonAlg.py @@ -3,8 +3,10 @@ # def DQTDetSynchMonAlgConfig(flags): from AthenaMonitoring import AthMonitorCfgHelper + from AthenaConfiguration.ComponentFactory import CompFactory helper = AthMonitorCfgHelper(flags,'DQTDetSynchMonAlgCfg') - _DQTDetSynchMonAlgConfigCore(helper, flags.Common.isOnline, False) + _DQTDetSynchMonAlgConfigCore(helper, CompFactory.DQTDetSynchMonAlg, + flags.Common.isOnline, False) acc = helper.result() # RPC currently crashes, switch off acc.getEventAlgo('DQTDetSynchMonAlg').doRPC = False @@ -17,14 +19,13 @@ def DQTDetSynchMonAlgConfig(flags): def DQTDetSynchMonAlgConfigOld(flags): from AthenaMonitoring import AthMonitorCfgHelperOld from AthenaCommon.AthenaCommonFlags import athenaCommonFlags + from DataQualityTools.DataQualityToolsConf import DQTDetSynchMonAlg helper = AthMonitorCfgHelperOld(flags,'DQTDetSynchMonAlgCfg') - _DQTDetSynchMonAlgConfigCore(helper, athenaCommonFlags.isOnline, True) + _DQTDetSynchMonAlgConfigCore(helper, DQTDetSynchMonAlg, athenaCommonFlags.isOnline, True) return helper.result() -def _DQTDetSynchMonAlgConfigCore(helper, isOnline=False, run2Compat=False): - from DataQualityTools.DataQualityToolsConf import DQTDetSynchMonAlg - - monAlg = helper.addAlgorithm(DQTDetSynchMonAlg,'DQTDetSynchMonAlg') +def _DQTDetSynchMonAlgConfigCore(helper, algConfObj, isOnline=False, run2Compat=False): + monAlg = helper.addAlgorithm(algConfObj,'DQTDetSynchMonAlg') monAlg.run2Compat = run2Compat # arguments are: algorithm, name of group used to access it from the alg, diff --git a/DataQuality/DataQualityTools/python/DQTLumiMonAlg.py b/DataQuality/DataQualityTools/python/DQTLumiMonAlg.py index c0bd02b20323cf3706daa8e78847838ac3f7b1e6..d6bfd47565458b54cacbcc1e03cbc7cf62b9a7c8 100644 --- a/DataQuality/DataQualityTools/python/DQTLumiMonAlg.py +++ b/DataQuality/DataQualityTools/python/DQTLumiMonAlg.py @@ -3,21 +3,27 @@ # def DQTLumiMonAlgConfig(flags, isOld=False): - from AthenaMonitoring import AthMonitorCfgHelper if isOld: # replace with the old version of the tool from AthenaMonitoring import AthMonitorCfgHelperOld as AthMonitorCfgHelper + from .DataQualityToolsConf import DQTLumiMonAlg + else: + from AthenaMonitoring import AthMonitorCfgHelper + from AthenaConfiguration.ComponentFactory import CompFactory + DQTLumiMonAlg = CompFactory.DQTLumiMonAlg + helper = AthMonitorCfgHelper(flags, 'DQTLumiMonAlgCfg') # Three instances of the algorithm. One using any trigger, another using only muon # triggers, and the final using only electron triggers. - DQTLumiMonAlgConfigByTriggerChain(helper) - DQTLumiMonAlgConfigByTriggerChain(helper,'CATEGORY_monitoring_muonIso','EF_muX') - DQTLumiMonAlgConfigByTriggerChain(helper,'CATEGORY_primary_single_ele','EF_eX') + DQTLumiMonAlgConfigByTriggerChain(helper, DQTLumiMonAlg) + DQTLumiMonAlgConfigByTriggerChain(helper, DQTLumiMonAlg, + 'CATEGORY_monitoring_muonIso','EF_muX') + DQTLumiMonAlgConfigByTriggerChain(helper, DQTLumiMonAlg, + 'CATEGORY_primary_single_ele','EF_eX') return helper.result() -def DQTLumiMonAlgConfigByTriggerChain(helper, triggerChain='', triggerPath=''): - from .DataQualityToolsConf import DQTLumiMonAlg - monAlg = helper.addAlgorithm(DQTLumiMonAlg, 'DQTLumiMonAlg'+triggerPath) +def DQTLumiMonAlgConfigByTriggerChain(helper, algConfObj, triggerChain='', triggerPath=''): + monAlg = helper.addAlgorithm(algConfObj, 'DQTLumiMonAlg'+triggerPath) if triggerChain: monAlg.TriggerChain = triggerChain diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthClusterMonAlgCfg.py b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthClusterMonAlgCfg.py index 39c250c839822c84f918a63104d21e298d32bdca..42469ac5cfcb61a616d6b5b19e6af6b927a5dfbc 100644 --- a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthClusterMonAlgCfg.py +++ b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthClusterMonAlgCfg.py @@ -12,9 +12,7 @@ from PixelMonitoring.PixelAthMonitoringBase import define1DLayers, defineMapVsLu from PixelMonitoring.PixelAthMonitoringBase import define1DProfLumiLayers from PixelMonitoring.PixelAthMonitoringBase import layers, totcuts, xbinsem, xminsem, lumibinsx, ztotbinsy, ztotminsy from PixelMonitoring.PixelAthMonitoringBase import addOnTrackTxt, addOnTrackToPath, fullDressTitle -from RecExConfig.AutoConfiguration import GetRunNumber -runNumber = GetRunNumber() -runtext = ' (Run ' + str(runNumber) + ')' +from PixelMonitoring.PixelAthMonitoringBase import runtext def PixelAthClusterMonAlgCfg(helper, alg, **kwargs): diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthErrorMonAlgCfg.py b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthErrorMonAlgCfg.py index c0bfdae4ac62b15808a7aaac5cedde306d22ea7e..687afb3501e8ee4725baf6bf4319e3f4fafa07fe 100644 --- a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthErrorMonAlgCfg.py +++ b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthErrorMonAlgCfg.py @@ -11,9 +11,7 @@ from PixelMonitoring.PixelAthMonitoringBase import define1DLayers from PixelMonitoring.PixelAthMonitoringBase import define1DProfLumiLayers from PixelMonitoring.PixelAthMonitoringBase import layers, totcuts, xbinsem, xminsem, lumibinsx from PixelMonitoring.PixelAthMonitoringBase import addOnTrackTxt, fullDressTitle -from RecExConfig.AutoConfiguration import GetRunNumber -runNumber = GetRunNumber() -runtext = ' (Run ' + str(runNumber) + ')' +from PixelMonitoring.PixelAthMonitoringBase import runtext def PixelAthErrorMonAlgCfg(helper, alg, **kwargs): ''' diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthHitMonAlgCfg.py b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthHitMonAlgCfg.py index bde90cb4ff05c13ea69662540c7e2ede0272bc0f..20d240a20e596638347c4c166a89089fb88f0407 100644 --- a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthHitMonAlgCfg.py +++ b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthHitMonAlgCfg.py @@ -12,9 +12,7 @@ from PixelMonitoring.PixelAthMonitoringBase import define1DLayers from PixelMonitoring.PixelAthMonitoringBase import define1DProfLumiLayers from PixelMonitoring.PixelAthMonitoringBase import layers, totcuts, xbinsem, xminsem, lumibinsx, bcidbinsx from PixelMonitoring.PixelAthMonitoringBase import addOnTrackTxt, addOnTrackToPath, fullDressTitle -from RecExConfig.AutoConfiguration import GetRunNumber -runNumber = GetRunNumber() -runtext = ' (Run ' + str(runNumber) + ')' +from PixelMonitoring.PixelAthMonitoringBase import runtext def PixelAthHitMonAlgCfg(helper, alg, **kwargs): ''' diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthMonitoringBase.py b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthMonitoringBase.py index 15281d7191feea84c349613707b1b8c46a039dfe..da4018cbf0f33c8a564cc374f87e4049990d8995 100644 --- a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthMonitoringBase.py +++ b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelAthMonitoringBase.py @@ -6,9 +6,15 @@ @file PixelAthMonitoringBase.py @brief Helper functions for Run 3 Pixel monitoring algorithm configuration ''' -from RecExConfig.AutoConfiguration import GetRunNumber -runNumber = GetRunNumber() -runtext = ' (Run ' + str(runNumber) + ')' +# hack to deal with global variables in this module +from AthenaCommon.Configurable import Configurable +if “ServiceMgr” in dir(): + from RecExConfig.AutoConfiguration import GetRunNumber + runtext = ' (Run ' + str(GetRunNumber()) + ')' +else: + from AthenaConfiguration.AllConfigFlags import ConfigFlags + runtext = '(Run %d)' % ConfigFlags.Input.RunNumber[0] + NumLayersDisk = 3 NumLayersDBM = 3 diff --git a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelMonitoringConfig.py b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelMonitoringConfig.py index b0f6b099019f36fb04609af9c08b1585fc35c1f1..0f6b56933ad591ecf84d85a957cbdd133367deb6 100644 --- a/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelMonitoringConfig.py +++ b/InnerDetector/InDetMonitoring/PixelMonitoring/python/PixelMonitoringConfig.py @@ -8,54 +8,53 @@ def PixelMonitoringConfig(flags): # run on RAW only if flags.DQ.Environment in ('online', 'tier0', 'tier0Raw'): - kwargsHitMonTool = { 'doOnline' : flags.Common.isOnline, #Histograms for online (athenaPT) running + kwargsHitMonAlg = { 'doOnline' : flags.Common.isOnline, #Histograms for online (athenaPT) running + 'doModules' : flags.Common.isOnline, #Turn on/off the sets of 1744 module histograms (for dqmf) + 'doLumiBlock' : not flags.Common.isOnline, #Turn on/off histograms stored for each lumi block + 'doLowOccupancy' : False, #Turn on/off histograms with binning for cosmics/single beam + 'doHighOccupancy' : True, #Turn on/off histograms with binning for collisions + #'doHeavyIonMon' : InDetFlags.doHeavyIon(), # Histogram modification for heavy ion monitoring + #'RDOName' : InDetKeys.PixelRDOs() + 'doHeavyIonMon' : False, #Until new config ready + 'RDOName' : 'PixelRDOs',#Until new config ready + } + + kwargsClusMonAlg = { 'doOnline' : flags.Common.isOnline, #Histograms for online (athenaPT) running 'doModules' : flags.Common.isOnline, #Turn on/off the sets of 1744 module histograms (for dqmf) 'doLumiBlock' : not flags.Common.isOnline, #Turn on/off histograms stored for each lumi block - 'doLowOccupancy' : False, #Turn on/off histograms with binning for cosmics/single beam + 'doLowOccupancy' : False, #Turn on/off histograms with binning for cosmics/single beam 'doHighOccupancy' : True, #Turn on/off histograms with binning for collisions #'doHeavyIonMon' : InDetFlags.doHeavyIon(), # Histogram modification for heavy ion monitoring - #'RDOName' : InDetKeys.PixelRDOs() - 'doHeavyIonMon' : False, #Until new config ready - 'RDOName' : 'PixelRDOs',#Until new config ready - } - - kwargsClusMonTool = { 'doOnline' : flags.Common.isOnline, #Histograms for online (athenaPT) running - 'doModules' : flags.Common.isOnline, #Turn on/off the sets of 1744 module histograms (for dqmf) - 'doLumiBlock' : not flags.Common.isOnline, #Turn on/off histograms stored for each lumi block - 'doLowOccupancy' : False, #Turn on/off histograms with binning for cosmics/single beam - 'doHighOccupancy' : True, #Turn on/off histograms with binning for collisions - #'doHeavyIonMon' : InDetFlags.doHeavyIon(), # Histogram modification for heavy ion monitoring - 'doHeavyIonMon' : False, #Until new config ready - # 'doStatus' : True, #Turn on/off histograms with Module Status information - #'ClusterName' : InDetKeys.PixelClusters(), - 'ClusterName' : 'PixelClusters', #Until new config ready - #'TrackName' : InDetKeys.Tracks() - 'TrackName' : 'Tracks', #Until new config ready + 'doHeavyIonMon' : False, #Until new config ready + # 'doStatus' : True, #Turn on/off histograms with Module Status information + #'ClusterName' : InDetKeys.PixelClusters(), + 'ClusterName' : 'PixelClusters', #Until new config ready + #'TrackName' : InDetKeys.Tracks() + 'TrackName' : 'Tracks', #Until new config ready } - kwargsErrMonTool = { 'doOnline' : flags.Common.isOnline, #Histograms for online (athenaPT) running - 'doModules' : flags.Common.isOnline, #Turn on/off the sets of 1744 module histograms (for dqmf) - 'doLumiBlock' : not flags.Common.isOnline, #Turn on/off histograms stored for each lumi block - 'doLowOccupancy' : False, #Turn on/off histograms with binning for cosmics/single beam - 'doHighOccupancy' : True, #Turn on/off histograms with binning for collisions - #'doHeavyIonMon' : InDetFlags.doHeavyIon() - 'doHeavyIonMon' : False, #Until new config is ready + kwargsErrMonAlg = { 'doOnline' : flags.Common.isOnline, #Histograms for online (athenaPT) running + 'doModules' : flags.Common.isOnline, #Turn on/off the sets of 1744 module histograms (for dqmf) + 'doLumiBlock' : not flags.Common.isOnline, #Turn on/off histograms stored for each lumi block + 'doLowOccupancy' : False, #Turn on/off histograms with binning for cosmics/single beam + 'doHighOccupancy' : True, #Turn on/off histograms with binning for collisions + #'doHeavyIonMon' : InDetFlags.doHeavyIon() + 'doHeavyIonMon' : False, #Until new config is ready } from AthenaMonitoring import AthMonitorCfgHelper helper = AthMonitorCfgHelper(flags, "NewPixelMonitoring") - from PixelMonitoring.PixelMonitoringConf import PixelAthHitMonTool - from PixelMonitoring.PixelAthHitMonToolCfg import PixelAthHitMonToolCfg - pixelAthHitMonAlg = helper.addAlgorithm(PixelAthHitMonTool, 'PixelAthHitMonAlg') - for k, v in kwargsHitMonTool.items(): + from AthenaConfiguration.ComponentFactory import CompFactory + from PixelMonitoring.PixelAthHitMonAlgCfg import PixelAthHitMonAlgCfg + pixelAthHitMonAlg = helper.addAlgorithm(CompFactory.PixelAthHitMonAlg, 'PixelAthHitMonAlg') + for k, v in kwargsHitMonAlg.items(): setattr(pixelAthHitMonAlg, k, v) - PixelAthHitMonToolCfg(helper, pixelAthHitMonAlg, **kwargsHitMonTool) + PixelAthHitMonAlgCfg(helper, pixelAthHitMonAlg, **kwargsHitMonAlg) - from PixelMonitoring.PixelMonitoringConf import PixelAthClusterMonTool - from PixelMonitoring.PixelAthClusterMonToolCfg import PixelAthClusterMonToolCfg - pixelAthClusterMonAlg = helper.addAlgorithm(PixelAthClusterMonTool, 'PixelAthClusterMonAlg') - for k, v in kwargsClusMonTool.items(): + from PixelMonitoring.PixelAthClusterMonAlgCfg import PixelAthClusterMonAlgCfg + pixelAthClusterMonAlg = helper.addAlgorithm(CompFactory.PixelAthClusterMonAlg, 'PixelAthClusterMonAlg') + for k, v in kwargsClusMonAlg.items(): setattr(pixelAthClusterMonAlg, k, v) pixelAthClusterMonAlg.TrackSelectionTool.UseTrkTrackTools = True pixelAthClusterMonAlg.TrackSelectionTool.CutLevel = "TightPrimary" @@ -64,105 +63,19 @@ def PixelMonitoringConfig(flags): pixelAthClusterMonAlg.TrackSelectionTool.maxZ0 = 150 # Run 3 configs - stolen from SCT - # Taken from InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py - from PixelConditionsTools.PixelConditionsSummaryConfig import PixelConditionsSummaryCfg - InDetPixelConditionsSummaryTool = acc.popToolsAndMerge(PixelConditionsSummaryCfg(flags)) - # Taken from Tracking/TrkConfig/python/AtlasExtrapolatorConfig.py - # AtlasExtrapolatorConfig can give only private extrapolator. We need public extrapolator. - from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg - trackGeomCfg = TrackingGeometrySvcCfg(flags) - geom_svc = trackGeomCfg.getPrimary() - geom_svc.GeometryBuilder.Compactify = False ######## To avoid crash ######## - acc.merge(trackGeomCfg) - from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg - acc.merge(MagneticFieldSvcCfg(flags)) - from TrkExTools.TrkExToolsConf import Trk__Navigator - AtlasNavigator = Trk__Navigator(name = 'AtlasNavigator') - AtlasNavigator.TrackingGeometrySvc = geom_svc - acc.addPublicTool(AtlasNavigator) - # Taken from InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py - from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator - InDetPropagator = Propagator(name = 'InDetPropagator') - InDetPropagator.AccuracyParameter = 0.0001 - InDetPropagator.MaxStraightLineStep = .004 - acc.addPublicTool(InDetPropagator) - from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator - InDetMaterialUpdator = Trk__MaterialEffectsUpdator(name = "InDetMaterialEffectsUpdator") - acc.addPublicTool(InDetMaterialUpdator) - InDetSubPropagators = [] - InDetSubUpdators = [] - # -------------------- set it depending on the geometry ---------------------------------------------------- - # default for ID is (Rk,Mat) - InDetSubPropagators += [ InDetPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - # default for Calo is (Rk,MatLandau) - InDetSubPropagators += [ InDetPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - # default for MS is (STEP,Mat) - #InDetSubPropagators += [ InDetStepPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - from TrkExTools.TrkExToolsConf import Trk__Extrapolator - InDetExtrapolator = Trk__Extrapolator(name = 'InDetExtrapolator', - Propagators = [ InDetPropagator ], - MaterialEffectsUpdators = [ InDetMaterialUpdator ], - Navigator = AtlasNavigator, - SubPropagators = InDetSubPropagators, - SubMEUpdators = InDetSubUpdators) - acc.addPublicTool(InDetExtrapolator) - from InDetTestPixelLayer.InDetTestPixelLayerConf import InDet__InDetTestPixelLayerTool - InDetTestPixelLayerTool = InDet__InDetTestPixelLayerTool(name = "InDetTestPixelLayerTool", - PixelSummaryTool = InDetPixelConditionsSummaryTool, - CheckActiveAreas=True, - CheckDeadRegions=True, - CheckDisabledFEs=True) - acc.addPublicTool(InDetTestPixelLayerTool) - from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool - InDetHoleSearchTool = InDet__InDetTrackHoleSearchTool(name = "InDetHoleSearchTool", - Extrapolator = InDetExtrapolator, - PixelSummaryTool = InDetPixelConditionsSummaryTool, - usePixel = flags.Detector.GeometryPixel, - useSCT = flags.Detector.GeometrySCT, - CountDeadModulesAfterLastHit = True, - PixelLayerTool = InDetTestPixelLayerTool) - acc.addPublicTool(InDetHoleSearchTool) - from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels - InDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(name = "InDetPrdAssociationTool", - PixelClusterAmbiguitiesMapName = "PixelClusterAmbiguitiesMap", - SetupCorrect = True, - addTRToutliers = True) - acc.addPublicTool(InDetPrdAssociationTool) - from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool - InDetTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(name = "InDetSummaryHelper", - AssoTool = InDetPrdAssociationTool, - PixelToTPIDTool = None, - TestBLayerTool = None, - RunningTIDE_Ambi = True, - DoSharedHits = False, - HoleSearch = InDetHoleSearchTool, - usePixel = flags.Detector.GeometryPixel, - useSCT = flags.Detector.GeometrySCT, - useTRT = flags.Detector.GeometryTRT) - from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool - InDetTrackSummaryTool = Trk__TrackSummaryTool(name = "InDetTrackSummaryTool", - InDetSummaryHelperTool = InDetTrackSummaryHelperTool, - doSharedHits = False, - doHolesInDet = True, - TRT_ElectronPidTool = None, - TRT_ToT_dEdxTool = None, - PixelToTPIDTool = None) - ############################## WORKAROUND (END) ############################ - pixelAthClusterMonAlg.TrackSelectionTool.TrackSummaryTool = InDetTrackSummaryTool - pixelAthClusterMonAlg.TrackSelectionTool.Extrapolator = InDetExtrapolator + from SCT_Monitoring.TrackSummaryToolWorkaround import TrackSummaryToolWorkaround + pixelAthClusterMonAlg.TrackSelectionTool.TrackSummaryTool = acc.popToolsAndMerge(TrackSummaryToolWorkaround(flags)) + pixelAthClusterMonAlg.TrackSelectionTool.Extrapolator = acc.getPublicTool("InDetExtrapolator") - PixelAthClusterMonToolCfg(helper, pixelAthClusterMonAlg, **kwargsClusMonTool) + PixelAthClusterMonAlgCfg(helper, pixelAthClusterMonAlg, **kwargsClusMonAlg) - from PixelMonitoring.PixelMonitoringConf import PixelAthErrorMonTool - from PixelMonitoring.PixelAthErrorMonToolCfg import PixelAthErrorMonToolCfg - pixelAthMonAlgErrorMonAlg = helper.addAlgorithm(PixelAthErrorMonTool, 'PixelAthErrorMonAlg') - for k, v in kwargsErrMonTool.items(): + from PixelMonitoring.PixelMonitoringConf import PixelAthErrorMonAlg + from PixelMonitoring.PixelAthErrorMonAlgCfg import PixelAthErrorMonAlgCfg + pixelAthMonAlgErrorMonAlg = helper.addAlgorithm(PixelAthErrorMonAlg, 'PixelAthErrorMonAlg') + for k, v in kwargsErrMonAlg.items(): setattr(pixelAthMonAlgErrorMonAlg, k, v) - PixelAthErrorMonToolCfg(helper, pixelAthMonAlgErrorMonAlg, **kwargsErrMonTool) + PixelAthErrorMonAlgCfg(helper, pixelAthMonAlgErrorMonAlg, **kwargsErrMonAlg) acc.merge(helper.result()) return acc diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTLorentzMonAlg.py b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTLorentzMonAlg.py index fe7a3e296fe26de5c0d2809175aa40db884aa7f6..2e9851517f447819425fdee744d40e74298f863b 100644 --- a/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTLorentzMonAlg.py +++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTLorentzMonAlg.py @@ -28,8 +28,8 @@ def SCTLorentzMonAlgConfig(inputFlags): # helper. Then, the helper will instantiate an instance and set up the # base class configuration following the inputFlags. The returned object # is the algorithm. - from SCT_Monitoring.SCT_MonitoringConf import SCTLorentzMonAlg - myMonAlg = helper.addAlgorithm(SCTLorentzMonAlg, 'SCTLorentzMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + myMonAlg = helper.addAlgorithm(CompFactory.SCTLorentzMonAlg, 'SCTLorentzMonAlg') # # If for some really obscure reason you need to instantiate an algorithm # # yourself, the AddAlgorithm method will still configure the base @@ -42,101 +42,9 @@ def SCTLorentzMonAlgConfig(inputFlags): myMonAlg.TriggerChain = '' # myMonAlg.RandomHist = True - ############################## WORKAROUND (START) ########################## - ############################## TO RUN TRACKSUMMARYTOOL ##################### - - # Taken from InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py - from PixelConditionsTools.PixelConditionsSummaryConfig import PixelConditionsSummaryCfg - InDetPixelConditionsSummaryTool = result.popToolsAndMerge(PixelConditionsSummaryCfg(inputFlags)) - - # Taken from Tracking/TrkConfig/python/AtlasExtrapolatorConfig.py - # AtlasExtrapolatorConfig can give only private extrapolator. We need public extrapolator. - from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg - trackGeomCfg = TrackingGeometrySvcCfg(inputFlags) - geom_svc = trackGeomCfg.getPrimary() - geom_svc.GeometryBuilder.Compactify = False ######## To avoid crash ######## - result.merge(trackGeomCfg) - from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg - result.merge(MagneticFieldSvcCfg(inputFlags)) - from TrkExTools.TrkExToolsConf import Trk__Navigator - AtlasNavigator = Trk__Navigator(name = 'AtlasNavigator') - AtlasNavigator.TrackingGeometrySvc = geom_svc - result.addPublicTool(AtlasNavigator) - - # Taken from InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py - from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator - InDetPropagator = Propagator(name = 'InDetPropagator') - InDetPropagator.AccuracyParameter = 0.0001 - InDetPropagator.MaxStraightLineStep = .004 - result.addPublicTool(InDetPropagator) - from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator - InDetMaterialUpdator = Trk__MaterialEffectsUpdator(name = "InDetMaterialEffectsUpdator") - result.addPublicTool(InDetMaterialUpdator) - InDetSubPropagators = [] - InDetSubUpdators = [] - # -------------------- set it depending on the geometry ---------------------------------------------------- - # default for ID is (Rk,Mat) - InDetSubPropagators += [ InDetPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - # default for Calo is (Rk,MatLandau) - InDetSubPropagators += [ InDetPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - # default for MS is (STEP,Mat) - #InDetSubPropagators += [ InDetStepPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - from TrkExTools.TrkExToolsConf import Trk__Extrapolator - InDetExtrapolator = Trk__Extrapolator(name = 'InDetExtrapolator', - Propagators = [ InDetPropagator ], - MaterialEffectsUpdators = [ InDetMaterialUpdator ], - Navigator = AtlasNavigator, - SubPropagators = InDetSubPropagators, - SubMEUpdators = InDetSubUpdators) - result.addPublicTool(InDetExtrapolator) - from InDetTestPixelLayer.InDetTestPixelLayerConf import InDet__InDetTestPixelLayerTool - InDetTestPixelLayerTool = InDet__InDetTestPixelLayerTool(name = "InDetTestPixelLayerTool", - PixelSummaryTool = InDetPixelConditionsSummaryTool, - CheckActiveAreas=True, - CheckDeadRegions=True, - CheckDisabledFEs=True) - result.addPublicTool(InDetTestPixelLayerTool) - from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool - InDetHoleSearchTool = InDet__InDetTrackHoleSearchTool(name = "InDetHoleSearchTool", - Extrapolator = InDetExtrapolator, - PixelSummaryTool = InDetPixelConditionsSummaryTool, - usePixel = inputFlags.Detector.GeometryPixel, - useSCT = inputFlags.Detector.GeometrySCT, - CountDeadModulesAfterLastHit = True, - PixelLayerTool = InDetTestPixelLayerTool) - result.addPublicTool(InDetHoleSearchTool) - from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels - InDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(name = "InDetPrdAssociationTool", - PixelClusterAmbiguitiesMapName = "PixelClusterAmbiguitiesMap", - SetupCorrect = True, - addTRToutliers = True) - result.addPublicTool(InDetPrdAssociationTool) - from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool - InDetTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(name = "InDetSummaryHelper", - AssoTool = InDetPrdAssociationTool, - PixelToTPIDTool = None, - TestBLayerTool = None, - RunningTIDE_Ambi = True, - DoSharedHits = False, - HoleSearch = InDetHoleSearchTool, - usePixel = inputFlags.Detector.GeometryPixel, - useSCT = inputFlags.Detector.GeometrySCT, - useTRT = inputFlags.Detector.GeometryTRT) - from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool - InDetTrackSummaryTool = Trk__TrackSummaryTool(name = "InDetTrackSummaryTool", - InDetSummaryHelperTool = InDetTrackSummaryHelperTool, - doSharedHits = False, - doHolesInDet = True, - TRT_ElectronPidTool = None, - TRT_ToT_dEdxTool = None, - PixelToTPIDTool = None) - ############################## WORKAROUND (END) ############################ - # Set InDetTrackSummaryTool to TrackSummaryTool of SCTLorentzMonAlg - myMonAlg.TrackSummaryTool = InDetTrackSummaryTool + from .TrackSummaryToolWorkaround import TrackSummaryToolWorkaround + myMonAlg.TrackSummaryTool = result.popToolsAndMerge(TrackSummaryToolWorkaround(inputFlags)) ### STEP 4 ### # Add some tools. N.B. Do not use your own trigger decion tool. Use the diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTMonitoringConfig.py b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTMonitoringConfig.py index 5e2b33de73e4c6220d84e12838665d5e36d1b78e..e810beac3f93b7ebd5ca9a24439c2fa5ee50c609 100644 --- a/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTMonitoringConfig.py +++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTMonitoringConfig.py @@ -8,5 +8,7 @@ def SCTMonitoringConfig(flags): if flags.DQ.Environment in ('online', 'tier0', 'tier0Raw'): from .SCTLorentzMonAlg import SCTLorentzMonAlgConfig acc.merge(SCTLorentzMonAlgConfig(flags)) + from .SCTTracksMonAlg import SCTTracksMonAlgConfig + acc.merge(SCTTracksMonAlgConfig(flags)) return acc diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTTracksMonAlg.py b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTTracksMonAlg.py index 74ff779515d060fd8be55dd467d186ce5f7a9aee..754f28655a2e3297fd3da16c45c0977051218b0b 100644 --- a/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTTracksMonAlg.py +++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/SCTTracksMonAlg.py @@ -27,8 +27,8 @@ def SCTTracksMonAlgConfig(inputFlags): # helper. Then, the helper will instantiate an instance and set up the # base class configuration following the inputFlags. The returned object # is the algorithm. - from SCT_Monitoring.SCT_MonitoringConf import SCTTracksMonAlg - myMonAlg = helper.addAlgorithm(SCTTracksMonAlg, 'SCTTracksMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + myMonAlg = helper.addAlgorithm(CompFactory.SCTTracksMonAlg, 'SCTTracksMonAlg') # # If for some really obscure reason you need to instantiate an algorithm # # yourself, the AddAlgorithm method will still configure the base # # properties and add the algorithm to the monitoring sequence. @@ -40,101 +40,9 @@ def SCTTracksMonAlgConfig(inputFlags): myMonAlg.TriggerChain = '' # myMonAlg.RandomHist = True - ############################## WORKAROUND (START) ########################## - ############################## TO RUN TRACKSUMMARYTOOL ##################### - - # Taken from InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py - from PixelConditionsTools.PixelConditionsSummaryConfig import PixelConditionsSummaryCfg - InDetPixelConditionsSummaryTool = result.popToolsAndMerge(PixelConditionsSummaryCfg(inputFlags)) - - # Taken from Tracking/TrkConfig/python/AtlasExtrapolatorConfig.py - # AtlasExtrapolatorConfig can give only private extrapolator. We need public extrapolator. - from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg - trackGeomCfg = TrackingGeometrySvcCfg(inputFlags) - geom_svc = trackGeomCfg.getPrimary() - geom_svc.GeometryBuilder.Compactify = False ######## To avoid crash ######## - result.merge(trackGeomCfg) - from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg - result.merge(MagneticFieldSvcCfg(inputFlags)) - from TrkExTools.TrkExToolsConf import Trk__Navigator - AtlasNavigator = Trk__Navigator(name = 'AtlasNavigator') - AtlasNavigator.TrackingGeometrySvc = geom_svc - result.addPublicTool(AtlasNavigator) - - # Taken from InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py - from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator - InDetPropagator = Propagator(name = 'InDetPropagator') - InDetPropagator.AccuracyParameter = 0.0001 - InDetPropagator.MaxStraightLineStep = .004 - result.addPublicTool(InDetPropagator) - from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator - InDetMaterialUpdator = Trk__MaterialEffectsUpdator(name = "InDetMaterialEffectsUpdator") - result.addPublicTool(InDetMaterialUpdator) - InDetSubPropagators = [] - InDetSubUpdators = [] - # -------------------- set it depending on the geometry ---------------------------------------------------- - # default for ID is (Rk,Mat) - InDetSubPropagators += [ InDetPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - # default for Calo is (Rk,MatLandau) - InDetSubPropagators += [ InDetPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - # default for MS is (STEP,Mat) - #InDetSubPropagators += [ InDetStepPropagator.name() ] - InDetSubUpdators += [ InDetMaterialUpdator.name() ] - from TrkExTools.TrkExToolsConf import Trk__Extrapolator - InDetExtrapolator = Trk__Extrapolator(name = 'InDetExtrapolator', - Propagators = [ InDetPropagator ], - MaterialEffectsUpdators = [ InDetMaterialUpdator ], - Navigator = AtlasNavigator, - SubPropagators = InDetSubPropagators, - SubMEUpdators = InDetSubUpdators) - result.addPublicTool(InDetExtrapolator) - from InDetTestPixelLayer.InDetTestPixelLayerConf import InDet__InDetTestPixelLayerTool - InDetTestPixelLayerTool = InDet__InDetTestPixelLayerTool(name = "InDetTestPixelLayerTool", - PixelSummaryTool = InDetPixelConditionsSummaryTool, - CheckActiveAreas=True, - CheckDeadRegions=True, - CheckDisabledFEs=True) - result.addPublicTool(InDetTestPixelLayerTool) - from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool - InDetHoleSearchTool = InDet__InDetTrackHoleSearchTool(name = "InDetHoleSearchTool", - Extrapolator = InDetExtrapolator, - PixelSummaryTool = InDetPixelConditionsSummaryTool, - usePixel = inputFlags.Detector.GeometryPixel, - useSCT = inputFlags.Detector.GeometrySCT, - CountDeadModulesAfterLastHit = True, - PixelLayerTool = InDetTestPixelLayerTool) - result.addPublicTool(InDetHoleSearchTool) - from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels - InDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(name = "InDetPrdAssociationTool", - PixelClusterAmbiguitiesMapName = "PixelClusterAmbiguitiesMap", - SetupCorrect = True, - addTRToutliers = True) - result.addPublicTool(InDetPrdAssociationTool) - from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool - InDetTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(name = "InDetSummaryHelper", - AssoTool = InDetPrdAssociationTool, - PixelToTPIDTool = None, - TestBLayerTool = None, - RunningTIDE_Ambi = True, - DoSharedHits = False, - HoleSearch = InDetHoleSearchTool, - usePixel = inputFlags.Detector.GeometryPixel, - useSCT = inputFlags.Detector.GeometrySCT, - useTRT = inputFlags.Detector.GeometryTRT) - from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool - InDetTrackSummaryTool = Trk__TrackSummaryTool(name = "InDetTrackSummaryTool", - InDetSummaryHelperTool = InDetTrackSummaryHelperTool, - doSharedHits = False, - doHolesInDet = True, - TRT_ElectronPidTool = None, - TRT_ToT_dEdxTool = None, - PixelToTPIDTool = None) - ############################## WORKAROUND (END) ############################ - # Set InDetTrackSummaryTool to TrackSummaryTool of SCTLorentzMonAlg - myMonAlg.TrackSummaryTool = InDetTrackSummaryTool + from .TrackSummaryToolWorkaround import TrackSummaryToolWorkaround + myMonAlg.TrackSummaryTool = result.popToolsAndMerge(TrackSummaryToolWorkaround(inputFlags)) ### STEP 4 ### # Add some tools. N.B. Do not use your own trigger decion tool. Use the diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/python/TrackSummaryToolWorkaround.py b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/TrackSummaryToolWorkaround.py new file mode 100644 index 0000000000000000000000000000000000000000..761f0fb28eb1594f9c4a1d23f07cf89424f5f4f1 --- /dev/null +++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/python/TrackSummaryToolWorkaround.py @@ -0,0 +1,100 @@ +# +# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration +# + +'''@file TrackingConfigurationWorkaround.py +@author Peter Onyisi +@date 2019-12-17 +@brief Centralize the DQ workarounds for setting up ID tracking tools in new-style config, until this is provided centrally +''' + +def TrackSummaryToolWorkaround(flags): + from AthenaConfiguration.ComponentFactory import CompFactory + from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator + result = ComponentAccumulator() + ############################## WORKAROUND (START) ########################## + ############################## TO RUN TRACKSUMMARYTOOL ##################### + + # Taken from InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py + from PixelConditionsTools.PixelConditionsSummaryConfig import PixelConditionsSummaryCfg + InDetPixelConditionsSummaryTool = result.popToolsAndMerge(PixelConditionsSummaryCfg(flags)) + + # Taken from Tracking/TrkConfig/python/AtlasExtrapolatorConfig.py + # AtlasExtrapolatorConfig can give only private extrapolator. We need public extrapolator. + from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg + trackGeomCfg = TrackingGeometrySvcCfg(flags) + geom_svc = trackGeomCfg.getPrimary() + geom_svc.GeometryBuilder.Compactify = False ######## To avoid crash ######## + result.merge(trackGeomCfg) + from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg + result.merge(MagneticFieldSvcCfg(flags)) + AtlasNavigator = CompFactory.Trk__Navigator(name = 'AtlasNavigator') + AtlasNavigator.TrackingGeometrySvc = geom_svc + result.addPublicTool(AtlasNavigator) + + # Taken from InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py + InDetPropagator = CompFactory.Trk__RungeKuttaPropagator(name = 'InDetPropagator') + InDetPropagator.AccuracyParameter = 0.0001 + InDetPropagator.MaxStraightLineStep = .004 + result.addPublicTool(InDetPropagator) + InDetMaterialUpdator = CompFactory.Trk__MaterialEffectsUpdator(name = "InDetMaterialEffectsUpdator") + result.addPublicTool(InDetMaterialUpdator) + InDetSubPropagators = [] + InDetSubUpdators = [] + # -------------------- set it depending on the geometry ---------------------------------------------------- + # default for ID is (Rk,Mat) + InDetSubPropagators += [ InDetPropagator.name() ] + InDetSubUpdators += [ InDetMaterialUpdator.name() ] + # default for Calo is (Rk,MatLandau) + InDetSubPropagators += [ InDetPropagator.name() ] + InDetSubUpdators += [ InDetMaterialUpdator.name() ] + # default for MS is (STEP,Mat) + #InDetSubPropagators += [ InDetStepPropagator.name() ] + InDetSubUpdators += [ InDetMaterialUpdator.name() ] + #from TrkExTools.TrkExToolsConf import Trk__Extrapolator + InDetExtrapolator = CompFactory.Trk__Extrapolator(name = 'InDetExtrapolator', + Propagators = [ InDetPropagator ], + MaterialEffectsUpdators = [ InDetMaterialUpdator ], + Navigator = AtlasNavigator, + SubPropagators = InDetSubPropagators, + SubMEUpdators = InDetSubUpdators) + result.addPublicTool(InDetExtrapolator) + InDetTestPixelLayerTool = CompFactory.InDet__InDetTestPixelLayerTool(name = "InDetTestPixelLayerTool", + PixelSummaryTool = InDetPixelConditionsSummaryTool, + CheckActiveAreas=True, + CheckDeadRegions=True, + CheckDisabledFEs=True) + result.addPublicTool(InDetTestPixelLayerTool) + InDetHoleSearchTool = CompFactory.InDet__InDetTrackHoleSearchTool(name = "InDetHoleSearchTool", + Extrapolator = InDetExtrapolator, + PixelSummaryTool = InDetPixelConditionsSummaryTool, + usePixel = flags.Detector.GeometryPixel, + useSCT = flags.Detector.GeometrySCT, + CountDeadModulesAfterLastHit = True, + PixelLayerTool = InDetTestPixelLayerTool) + result.addPublicTool(InDetHoleSearchTool) + InDetPrdAssociationTool = CompFactory.InDet__InDetPRD_AssociationToolGangedPixels(name = "InDetPrdAssociationTool", + PixelClusterAmbiguitiesMapName = "PixelClusterAmbiguitiesMap", + SetupCorrect = True, + addTRToutliers = True) + result.addPublicTool(InDetPrdAssociationTool) + InDetTrackSummaryHelperTool = CompFactory.InDet__InDetTrackSummaryHelperTool(name = "InDetSummaryHelper", + AssoTool = InDetPrdAssociationTool, + PixelToTPIDTool = None, + TestBLayerTool = None, + RunningTIDE_Ambi = True, + DoSharedHits = False, + HoleSearch = InDetHoleSearchTool, + usePixel = flags.Detector.GeometryPixel, + useSCT = flags.Detector.GeometrySCT, + useTRT = flags.Detector.GeometryTRT) + InDetTrackSummaryTool = CompFactory.Trk__TrackSummaryTool(name = "InDetTrackSummaryTool", + InDetSummaryHelperTool = InDetTrackSummaryHelperTool, + doSharedHits = False, + doHolesInDet = True, + TRT_ElectronPidTool = None, + TRT_ToT_dEdxTool = None, + PixelToTPIDTool = None) + result.setPrivateTools(InDetTrackSummaryTool) + ############################## WORKAROUND (END) ############################ + return result diff --git a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/TRTMonitoringRun3/TRTMonitoringRun3_Tool.h b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/TRTMonitoringRun3/TRTMonitoringRun3_Alg.h similarity index 94% rename from InnerDetector/InDetMonitoring/TRTMonitoringRun3/TRTMonitoringRun3/TRTMonitoringRun3_Tool.h rename to InnerDetector/InDetMonitoring/TRTMonitoringRun3/TRTMonitoringRun3/TRTMonitoringRun3_Alg.h index beeb7b3bd793b6eb22fd039092c2451b93c0ad6e..ed367364aedfafd3b372971c4f8b8daf8040ff91 100644 --- a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/TRTMonitoringRun3/TRTMonitoringRun3_Tool.h +++ b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/TRTMonitoringRun3/TRTMonitoringRun3_Alg.h @@ -2,8 +2,8 @@ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration */ -#ifndef TRTMONITORINGRUN3_TOOL_H -#define TRTMONITORINGRUN3_TOOL_H +#ifndef TRTMONITORINGRUN3_ALG_H +#define TRTMONITORINGRUN3_ALG_H #include "AthenaMonitoring/AthMonitorAlgorithm.h" #include "AthenaMonitoringKernel/Monitored.h" @@ -62,10 +62,10 @@ class ITRT_ByteStream_ConditionsSvc; class ITRT_StrawNeighbourSvc; class ITRT_DriftFunctionTool; -class TRTMonitoringRun3_Tool : public AthMonitorAlgorithm { +class TRTMonitoringRun3_Alg : public AthMonitorAlgorithm { public: - TRTMonitoringRun3_Tool( const std::string& name, ISvcLocator* pSvcLocator ); - virtual ~TRTMonitoringRun3_Tool(); + TRTMonitoringRun3_Alg( const std::string& name, ISvcLocator* pSvcLocator ); + virtual ~TRTMonitoringRun3_Alg(); virtual StatusCode initialize() override; virtual StatusCode fillTestTRTTrackHistograms( const TrackCollection& trackCollection) const; virtual StatusCode fillHistograms( const EventContext& ctx ) const override; diff --git a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3Config.py b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3Config.py index 012ffe012ec77a844e2b67321d4d22e59618f006..20f77202104669cb91a293daedea7ac8ab308d03 100644 --- a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3Config.py +++ b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3Config.py @@ -5,12 +5,12 @@ def TRTMonitoringRun3Cfg(flags): from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator - from .TRTMonitoringRun3_Tool import TRTMonitoringRun3_ToolConfig + from .TRTMonitoringRun3_Alg import TRTMonitoringRun3_AlgConfig result = ComponentAccumulator() # do not run in RAW->ESD (if two step) or AOD-only if flags.DQ.Environment not in ('tier0Raw', 'AOD'): - result.merge(TRTMonitoringRun3_ToolConfig(flags)) + result.merge(TRTMonitoringRun3_AlgConfig(flags)) return result diff --git a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3_Tool.py b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3_Alg.py similarity index 96% rename from InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3_Tool.py rename to InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3_Alg.py index 9e35f78d2d31270b9d4802243e2b189a2d517ee3..ff1bfe74170c23cc09e7222fb4a11551a88c4257 100644 --- a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3_Tool.py +++ b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/python/TRTMonitoringRun3_Alg.py @@ -2,7 +2,7 @@ # Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration # -'''@file TRTMonitoringRun3_Tool.py +'''@file TRTMonitoringRun3_Alg.py @author N. Belyaev @date 20.09.2019 @brief MT-compatible TRT Monitoring Tool for Run III based on the @@ -10,7 +10,7 @@ AthenaMonitoring package ''' -def TRTMonitoringRun3_ToolConfig(inputFlags): +def TRTMonitoringRun3_AlgConfig(inputFlags): '''Function to configures some algorithms in the monitoring system.''' # === STEP 1 === # @@ -34,8 +34,8 @@ def TRTMonitoringRun3_ToolConfig(inputFlags): # helper. Then, the helper will instantiate an instance and set up the # base class configuration following the inputFlags. The returned object # is the algorithm. - from TRTMonitoringRun3.TRTMonitoringRun3Conf import TRTMonitoringRun3_Tool - algTRTMonitoringRun3 = helper.addAlgorithm(TRTMonitoringRun3_Tool, + from AthenaConfiguration.ComponentFactory import CompFactory + algTRTMonitoringRun3 = helper.addAlgorithm(CompFactory.TRTMonitoringRun3_Alg, 'AlgTRTMonitoringRun3') # You can actually make multiple instances of the same algorithm and give @@ -180,7 +180,7 @@ if __name__ == '__main__': geoCfg = AtlasGeometryCfg(ConfigFlags) cfg.merge(geoCfg) - TRTMonitoringRun3Acc = TRTMonitoringRun3_ToolConfig(ConfigFlags) + TRTMonitoringRun3Acc = TRTMonitoringRun3_AlgConfig(ConfigFlags) ServiceMgr.Dump = False cfg.merge(TRTMonitoringRun3Acc) diff --git a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/TRTMonitoringRun3_Tool.cxx b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/TRTMonitoringRun3_Alg.cxx similarity index 94% rename from InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/TRTMonitoringRun3_Tool.cxx rename to InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/TRTMonitoringRun3_Alg.cxx index 5b3509874fbf42ec0cb0bc7f3b4839dec686e8be..e4ba4bc58e72e987cfa4eece06e246fd64c305af 100644 --- a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/TRTMonitoringRun3_Tool.cxx +++ b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/TRTMonitoringRun3_Alg.cxx @@ -2,7 +2,7 @@ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration */ -#include "TRTMonitoringRun3/TRTMonitoringRun3_Tool.h" +#include "TRTMonitoringRun3/TRTMonitoringRun3_Alg.h" #include "AthContainers/DataVector.h" #include "InDetReadoutGeometry/TRT_DetectorManager.h" @@ -25,15 +25,15 @@ #include -const int TRTMonitoringRun3_Tool::s_numberOfBarrelStacks = 32; -const int TRTMonitoringRun3_Tool::s_numberOfEndCapStacks = 32; -const int TRTMonitoringRun3_Tool::s_Straw_max[2] = {1642, 3840}; -const int TRTMonitoringRun3_Tool::s_iStack_max[2] = {32, 64}; -const int TRTMonitoringRun3_Tool::s_iChip_max[2] = {104, 240}; -const int TRTMonitoringRun3_Tool::s_numberOfStacks[2] = {32, 32}; -const int TRTMonitoringRun3_Tool::s_moduleNum[2] = {96, 64}; +const int TRTMonitoringRun3_Alg::s_numberOfBarrelStacks = 32; +const int TRTMonitoringRun3_Alg::s_numberOfEndCapStacks = 32; +const int TRTMonitoringRun3_Alg::s_Straw_max[2] = {1642, 3840}; +const int TRTMonitoringRun3_Alg::s_iStack_max[2] = {32, 64}; +const int TRTMonitoringRun3_Alg::s_iChip_max[2] = {104, 240}; +const int TRTMonitoringRun3_Alg::s_numberOfStacks[2] = {32, 32}; +const int TRTMonitoringRun3_Alg::s_moduleNum[2] = {96, 64}; -TRTMonitoringRun3_Tool::TRTMonitoringRun3_Tool( const std::string& name, ISvcLocator* pSvcLocator ) +TRTMonitoringRun3_Alg::TRTMonitoringRun3_Alg( const std::string& name, ISvcLocator* pSvcLocator ) :AthMonitorAlgorithm(name,pSvcLocator) ,m_doRandom(false) ,m_pTRTHelper(0) @@ -53,10 +53,10 @@ TRTMonitoringRun3_Tool::TRTMonitoringRun3_Tool( const std::string& name, ISvcLoc } -TRTMonitoringRun3_Tool::~TRTMonitoringRun3_Tool() {} +TRTMonitoringRun3_Alg::~TRTMonitoringRun3_Alg() {} -StatusCode TRTMonitoringRun3_Tool::initialize() { +StatusCode TRTMonitoringRun3_Alg::initialize() { using namespace Monitored; // Initialization of VarHandleKeys @@ -78,7 +78,7 @@ StatusCode TRTMonitoringRun3_Tool::initialize() { //----------------------------------------------------------------------------------// -int TRTMonitoringRun3_Tool::strawLayerNumber(int strawLayerNumber, int LayerNumber) const { +int TRTMonitoringRun3_Alg::strawLayerNumber(int strawLayerNumber, int LayerNumber) const { //----------------------------------------------------------------------------------// switch (LayerNumber) { case 0: @@ -96,7 +96,7 @@ int TRTMonitoringRun3_Tool::strawLayerNumber(int strawLayerNumber, int LayerNumb } //----------------------------------------------------------------------------------// -int TRTMonitoringRun3_Tool::strawNumber(int strawNumber, int strawlayerNumber, int LayerNumber) const { +int TRTMonitoringRun3_Alg::strawNumber(int strawNumber, int strawlayerNumber, int LayerNumber) const { //----------------------------------------------------------------------------------// int addToStrawNumber = 0; int addToStrawNumberNext = 0; @@ -144,7 +144,7 @@ int TRTMonitoringRun3_Tool::strawNumber(int strawNumber, int strawlayerNumber, i //----------------------------------------------------------------------------------// -int TRTMonitoringRun3_Tool::strawNumberEndCap(int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side) const { +int TRTMonitoringRun3_Alg::strawNumberEndCap(int strawNumber, int strawLayerNumber, int LayerNumber, int phi_stack, int side) const { //----------------------------------------------------------------------------------// // Before perfoming map, corrections need to be perfomed. // apply special rotations for endcap mappings @@ -222,7 +222,7 @@ int TRTMonitoringRun3_Tool::strawNumberEndCap(int strawNumber, int strawLayerNum } //----------------------------------------------------------------------------------// -float TRTMonitoringRun3_Tool::radToDegrees(float radValue) const { +float TRTMonitoringRun3_Alg::radToDegrees(float radValue) const { //----------------------------------------------------------------------------------// float degreeValue = radValue / M_PI * 180; @@ -235,7 +235,7 @@ float TRTMonitoringRun3_Tool::radToDegrees(float radValue) const { //Fill the TRT Track level histograms //----------------------------------------------------------------------------------// -StatusCode TRTMonitoringRun3_Tool::fillTestTRTTrackHistograms(const TrackCollection& trackCollection) const { +StatusCode TRTMonitoringRun3_Alg::fillTestTRTTrackHistograms(const TrackCollection& trackCollection) const { //----------------------------------------------------------------------------------// ATH_MSG_VERBOSE("Filling Test TRT Tracks Histos"); @@ -494,7 +494,7 @@ StatusCode TRTMonitoringRun3_Tool::fillTestTRTTrackHistograms(const TrackCollect } -StatusCode TRTMonitoringRun3_Tool::fillHistograms( const EventContext& ctx ) const { +StatusCode TRTMonitoringRun3_Alg::fillHistograms( const EventContext& ctx ) const { using namespace Monitored; // Declare the quantities which should be monitored diff --git a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/components/TRTMonitoringRun3_entries.cxx b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/components/TRTMonitoringRun3_entries.cxx index 133f8acb8ecec1fd5bd98f68d0e985641560e983..adfb339dfe4c4706f99d53f2e1dea8f223eb3291 100644 --- a/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/components/TRTMonitoringRun3_entries.cxx +++ b/InnerDetector/InDetMonitoring/TRTMonitoringRun3/src/components/TRTMonitoringRun3_entries.cxx @@ -1,3 +1,3 @@ -#include "TRTMonitoringRun3/TRTMonitoringRun3_Tool.h" +#include "TRTMonitoringRun3/TRTMonitoringRun3_Alg.h" -DECLARE_COMPONENT( TRTMonitoringRun3_Tool ) \ No newline at end of file +DECLARE_COMPONENT( TRTMonitoringRun3_Alg ) \ No newline at end of file diff --git a/LArCalorimeter/LArMonitoring/python/LArAffectedRegionsAlg.py b/LArCalorimeter/LArMonitoring/python/LArAffectedRegionsAlg.py index 0bac368a947ff7fe7bc9d5dde054ac63f2a1b2a9..069ed54543e4addf643b2981ae1088d552ea59a2 100644 --- a/LArCalorimeter/LArMonitoring/python/LArAffectedRegionsAlg.py +++ b/LArCalorimeter/LArMonitoring/python/LArAffectedRegionsAlg.py @@ -15,8 +15,8 @@ def LArAffectedRegionsConfig(inputFlags): from LArCalibUtils.LArHVScaleConfig import LArHVScaleCfg acc.merge(LArHVScaleCfg(inputFlags)) - from LArMonitoring.LArMonitoringConf import LArAffectedRegionsAlg - larAffectedRegAlg = helper.addAlgorithm(LArAffectedRegionsAlg,'larAffectedRegAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + larAffectedRegAlg = helper.addAlgorithm(CompFactory.LArAffectedRegionsAlg,'larAffectedRegAlg') #define the group names here, as you'll use them multiple times affectedRegGroupName="LArAffectedRegionsMonGroup" diff --git a/LArCalorimeter/LArMonitoring/python/LArCollisionTimeMonAlg.py b/LArCalorimeter/LArMonitoring/python/LArCollisionTimeMonAlg.py index b3e22e608aed00411954fa539186fa05941f8aeb..725595b206201fc842746c8f98e7a71438bfd85f 100644 --- a/LArCalorimeter/LArMonitoring/python/LArCollisionTimeMonAlg.py +++ b/LArCalorimeter/LArMonitoring/python/LArCollisionTimeMonAlg.py @@ -17,19 +17,16 @@ def LArCollisionTimeMonConfig(inputFlags): from TileGeoModel.TileGMConfig import TileGMCfg cfg.merge(TileGMCfg(inputFlags)) - from LArMonitoring.LArMonitoringConf import LArCollisionTimeMonAlg - larCollTimeMonAlg = helper.addAlgorithm(LArCollisionTimeMonAlg,'larCollTimeMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + larCollTimeMonAlg = helper.addAlgorithm(CompFactory.LArCollisionTimeMonAlg,'larCollTimeMonAlg') collTimeGroupName="LArCollisionTimeMonGroup" larCollTimeMonAlg.CollTimeGroupName=collTimeGroupName - from TrigBunchCrossingTool.BunchCrossingTool import BunchCrossingTool - # FIXME when bunch crossing tool config is improved - bct = BunchCrossingTool(inputFlags.Common.bunchCrossingSource) - cfg.addPublicTool(bct) - larCollTimeMonAlg.BunchCrossingTool = bct + from LumiBlockComps.BunchCrossingCondAlgConfig import BunchCrossingCondAlgCfg + cfg.merge(BunchCrossingCondAlgCfg(inputFlags)) collTimeGroup = helper.addGroup( larCollTimeMonAlg, diff --git a/LArCalorimeter/LArMonitoring/python/LArDigitMonAlg.py b/LArCalorimeter/LArMonitoring/python/LArDigitMonAlg.py index a9f15bedf0fd22041a24927f1b48ffe906c7a06b..31f2f7a854ca8e4ff79f71f2fbb64408797363bb 100644 --- a/LArCalorimeter/LArMonitoring/python/LArDigitMonAlg.py +++ b/LArCalorimeter/LArMonitoring/python/LArDigitMonAlg.py @@ -9,8 +9,8 @@ def LArDigitMonConfig(inputFlags): from LArMonitoring.GlobalVariables import lArDQGlobals - from LArMonitoring.LArMonitoringConf import LArDigitMonAlg - larDigitMonAlg = helper.addAlgorithm(LArDigitMonAlg,'larDigitMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + larDigitMonAlg = helper.addAlgorithm(CompFactory.LArDigitMonAlg,'larDigitMonAlg') summaryGroupName="Summary" nslots=[] diff --git a/LArCalorimeter/LArMonitoring/python/LArFEBMonAlg.py b/LArCalorimeter/LArMonitoring/python/LArFEBMonAlg.py index 26b5dcdf0f0fcc06bc08c5633b83967c81764c98..882010a57f85ce4c0b9e9f36390908a94ad51d74 100644 --- a/LArCalorimeter/LArMonitoring/python/LArFEBMonAlg.py +++ b/LArCalorimeter/LArMonitoring/python/LArFEBMonAlg.py @@ -9,8 +9,8 @@ def LArFEBMonConfig(inputFlags, cellDebug=False, dspDebug=False): from LArMonitoring.GlobalVariables import lArDQGlobals - from LArMonitoring.LArMonitoringConf import LArFEBMonAlg - larFEBMonAlg = helper.addAlgorithm(LArFEBMonAlg,'larFEBMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + larFEBMonAlg = helper.addAlgorithm(CompFactory.LArFEBMonAlg,'larFEBMonAlg') GroupName="FEBMon" nslots=[] diff --git a/LArCalorimeter/LArMonitoring/python/LArHVCorrMonAlg.py b/LArCalorimeter/LArMonitoring/python/LArHVCorrMonAlg.py index 21bd79a1a52c735d09984c0ba24b94862b613ab0..89b1ccc10ca5c6188a107e4d6944f4ad02d68a72 100644 --- a/LArCalorimeter/LArMonitoring/python/LArHVCorrMonAlg.py +++ b/LArCalorimeter/LArMonitoring/python/LArHVCorrMonAlg.py @@ -14,8 +14,8 @@ def LArHVCorrMonConfig(inputFlags): from LArCalibUtils.LArHVScaleConfig import LArHVScaleCfg acc.merge(LArHVScaleCfg(inputFlags)) - from LArMonitoring.LArMonitoringConf import LArHVCorrectionMonAlg - larHVCorrAlg = helper.addAlgorithm(LArHVCorrectionMonAlg,'larHVCorrMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + larHVCorrAlg = helper.addAlgorithm(CompFactory.LArHVCorrectionMonAlg,'larHVCorrMonAlg') #define the group names here, as you'll use them multiple times hvCorrGroupName="LArHVCorrMonGroup" diff --git a/LArCalorimeter/LArMonitoring/python/LArRODMonAlg.py b/LArCalorimeter/LArMonitoring/python/LArRODMonAlg.py index 4634a4126d0c25f73187b62bfed696b477d1c538..3f67eeb6cf3b245e7caed02a31b67ac0d6572d9c 100644 --- a/LArCalorimeter/LArMonitoring/python/LArRODMonAlg.py +++ b/LArCalorimeter/LArMonitoring/python/LArRODMonAlg.py @@ -9,8 +9,8 @@ def LArRODMonConfig(inputFlags, cellDebug=False, dspDebug=False): from LArMonitoring.GlobalVariables import lArDQGlobals - from LArMonitoring.LArMonitoringConf import LArRODMonAlg - larRODMonAlg = helper.addAlgorithm(LArRODMonAlg,'larRODMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + larRODMonAlg = helper.addAlgorithm(CompFactory.LArRODMonAlg,'larRODMonAlg') GroupName="RODMon" nslots=[] diff --git a/LArCalorimeter/LArMonitoring/src/LArCollisionTimeMonAlg.cxx b/LArCalorimeter/LArMonitoring/src/LArCollisionTimeMonAlg.cxx index 95c3ae69b08404d8c85000176f31aaa39744971c..d923a18c00ec97e3e517a821e600969985e24139 100755 --- a/LArCalorimeter/LArMonitoring/src/LArCollisionTimeMonAlg.cxx +++ b/LArCalorimeter/LArMonitoring/src/LArCollisionTimeMonAlg.cxx @@ -19,9 +19,6 @@ #include "LArCollisionTimeMonAlg.h" #include "GaudiKernel/SystemOfUnits.h" -#include "TrigAnalysisInterfaces/IBunchCrossingTool.h" - - using namespace std; @@ -30,12 +27,7 @@ using namespace std; /*---------------------------------------------------------*/ LArCollisionTimeMonAlg::LArCollisionTimeMonAlg( const std::string& name, ISvcLocator* pSvcLocator ) : AthMonitorAlgorithm(name,pSvcLocator) - ,m_LArCollisionTimeKey("LArCollisionTime") - ,m_bunchCrossingTool("BunchCrossingTool") -{ - declareProperty( "Key" , m_LArCollisionTimeKey); - declareProperty( "BunchCrossingTool" , m_bunchCrossingTool); -} +{} /*---------------------------------------------------------*/ LArCollisionTimeMonAlg::~LArCollisionTimeMonAlg() @@ -47,6 +39,7 @@ LArCollisionTimeMonAlg::initialize() { //init handlers ATH_CHECK( m_LArCollisionTimeKey.initialize() ); + ATH_CHECK( m_bcKey.initialize() ); return AthMonitorAlgorithm::initialize(); } @@ -85,13 +78,13 @@ LArCollisionTimeMonAlg::fillHistograms( const EventContext& ctx ) const // luminosity block number lumi_block = event_info->lumiBlock(); - - if(m_bunchCrossingTool->bcType(bunch_crossing_id) == Trig::IBunchCrossingTool::Empty) { + SG::ReadCondHandle bcData(m_bcKey, ctx); + if(bcData->bcType(bunch_crossing_id) == BunchCrossingCondData::Empty) { ATH_MSG_INFO("BCID: "<distanceFromFront(bunch_crossing_id, Trig::IBunchCrossingTool::BunchCrossings); + int bcid_distance = bcData->distanceFromFront(bunch_crossing_id, BunchCrossingCondData::BunchCrossings); ATH_MSG_DEBUG("BCID distance: "< #include - -namespace Trig { -class IBunchCrossingTool; -} - - class LArCollisionTimeMonAlg: public AthMonitorAlgorithm { public: @@ -59,10 +53,8 @@ class LArCollisionTimeMonAlg: public AthMonitorAlgorithm Gaudi::Property m_eWeighted {this,"eWeighted",true}; //containers' handles - SG::ReadHandleKey m_LArCollisionTimeKey; - - //tools handles - ToolHandle m_bunchCrossingTool; + SG::ReadHandleKey m_LArCollisionTimeKey{this, "Key", "LArCollisionTime", "Key for the LArCollisionTime data"}; + SG::ReadCondHandleKey m_bcKey{this,"BunchCrossingKey","BunchCrossingData","Key for the bunch crossing conditions data"}; }; diff --git a/LumiBlock/LumiBlockData/LumiBlockData/BunchCrossingCondData.h b/LumiBlock/LumiBlockData/LumiBlockData/BunchCrossingCondData.h index 60c99481f8ec525a174ce4c847ced7773564e3dc..2a02a68ef40173fbfdca9184bff1e9afd7a81c6c 100644 --- a/LumiBlock/LumiBlockData/LumiBlockData/BunchCrossingCondData.h +++ b/LumiBlock/LumiBlockData/LumiBlockData/BunchCrossingCondData.h @@ -92,6 +92,35 @@ public: */ bool isBeam2(const bcid_type bcid ) const; + /// Enumeration type for a given bunch crossing + /** + * This enumeration can specify what kind of bunch crossing one BCID + * belongs to. The types could easily be extended later on. + */ + enum BunchCrossingType + { + Empty = 0, ///< An empty bunch far away from filled bunches + FirstEmpty = 1, ///< The first empty bunch after a train + MiddleEmpty = 2, ///< An empty BCID in the middle of a train + Single = 100, ///< This is a filled, single bunch (not in a train) + Front = 200, ///< The BCID belongs to the first few bunches in a train + Middle = 201, ///< The BCID belongs to the middle bunches in a train + Tail = 202, ///< The BCID belongs to the last few bunces in a train + Unpaired = 300 ///< This is an unpaired bunch (either beam1 or beam2) + }; + + /// Convenience function for the type of the specific bunch crossing + /** + * This function could be used as a single entry point to this data in + * principle. It gives a summary about a specific BCID. Remember however + * that the exact meaning of many of the return values of this function + * are configuration dependent. + * + * @param bcid The bcid that should be checked + * @returns The type of the bcid in question + */ + BunchCrossingType bcType(const bcid_type bcid ) const; + /// Enumeration specifying the units in which to expect the bunch distance type /** * To make it clear for the following functions what units to interpret their @@ -241,6 +270,7 @@ private: std::bitset m_beam1; std::bitset m_beam2; std::bitset m_luminous; + const static int m_headTailLength = 300; // magic number 300 ns from Run 2 tool struct bunchTrain_t { bunchTrain_t(bcid_type first, bcid_type last, unsigned ncoll) : diff --git a/LumiBlock/LumiBlockData/src/BunchCrossingCondData.cxx b/LumiBlock/LumiBlockData/src/BunchCrossingCondData.cxx index e8b55c2fbd85519cf428f8c57744efa0e8ea81b1..e07268761b67500c706badf5f917c533c4066e88 100644 --- a/LumiBlock/LumiBlockData/src/BunchCrossingCondData.cxx +++ b/LumiBlock/LumiBlockData/src/BunchCrossingCondData.cxx @@ -182,3 +182,48 @@ int BunchCrossingCondData::gapAfterTrain( bcid_type bcid, return result; } + +BunchCrossingCondData::BunchCrossingType BunchCrossingCondData::bcType(const bcid_type bcid ) const { + // First the obvious check: + if (!isFilled(bcid)) + { + // Check if it's an unpaired bunch: + if (isUnpaired(bcid)) + { + return Unpaired; + } + // If the previous bunch crossing is the tail of a bunch train: + if (!distanceFromTail(bcid - 1, BunchCrossings)) + { + return FirstEmpty; + } + // Check if it's in the middle of a bunch train: + if (findTrain(bcid) != nullptr) { + return MiddleEmpty; + } + // If none of the above are true, it has to be a "simple" empty bunch: + return Empty; + } + + // Now we know that the bunch has to be a filled one... + + // If it's not in a train, it has to be a single filled bunch: + if (!isInTrain(bcid)) + return Single; + + // Let's check if it is close to the front of a bunch train: + int distance = distanceFromFront(bcid, NanoSec); + if ((distance >= 0) && (distance <= m_headTailLength)) + { + return Front; + } + // Now let's check if it's close to the tail of a bunch train: + distance = distanceFromTail(bcid, NanoSec); + if ((distance >= 0) && (distance <= m_headTailLength)) + { + return Tail; + } + + // If none of the above are true, it has to be in the middle of a train: + return Middle; +} \ No newline at end of file diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/python/MDTMonitorAlgorithm.py b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/python/MDTMonitorAlgorithm.py index 836fe82a97d6d585a1cd68e9a078d4ec997e7bd0..02b28909b8ab1c91b35edf0fe3e662eab96d17e6 100644 --- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/python/MDTMonitorAlgorithm.py +++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/python/MDTMonitorAlgorithm.py @@ -2,8 +2,7 @@ #Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration # - -from MuonIdHelpers.MuonIdHelpersConf import Muon__MuonIdHelperTool +from AthenaConfiguration.ComponentFactory import CompFactory #from MdtRawDataMonitoring.MdtRawMonLabels import * from MdtMonUtils import getMDTLabel from MDTTubeMax import tubeMax @@ -30,7 +29,7 @@ def MdtMonitoringConfig(inputFlags): result.merge(MuonGeoModelCfg(inputFlags)) # Temporary, until we move to services/private tools-- from MuonSpectrometer/MuonConfig - result.addPublicTool( Muon__MuonIdHelperTool() ) + result.addPublicTool( CompFactory.Muon__MuonIdHelperTool() ) # The following class will make a sequence, configure algorithms, and link # them to GenericMonitoringTools @@ -45,9 +44,8 @@ def MdtMonitoringConfig(inputFlags): # helper. Then, the helper will instantiate an instance and set up the # base class configuration following the inputFlags. The returned object # is the algorithm. - from MdtRawDataMonitoring.MdtRawDataMonitoringConf import MdtRawDataMonAlg #MdtRawDataMonAlg.DoMdtEsd = True - mdtMonAlg = helper.addAlgorithm(MdtRawDataMonAlg,'MdtMonAlg') + mdtMonAlg = helper.addAlgorithm(CompFactory.MdtRawDataMonAlg,'MdtMonAlg') mdtMonAlg.DoMdtEsd = True # You can actually make multiple instances of the same algorithm and give diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/TgcRawDataMonitoring/python/TgcRawDataMonitorAlgorithm.py b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/TgcRawDataMonitoring/python/TgcRawDataMonitorAlgorithm.py index 365a05ee521b93e1e9c68261f73832d38d544b86..20315643f332dc9ced20309700c61304517db55c 100644 --- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/TgcRawDataMonitoring/python/TgcRawDataMonitorAlgorithm.py +++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/TgcRawDataMonitoring/python/TgcRawDataMonitorAlgorithm.py @@ -14,8 +14,8 @@ def TgcRawDataMonitoringConfig(inputFlags): from AthenaMonitoring import AthMonitorCfgHelper helper = AthMonitorCfgHelper(inputFlags,'TgcRawDataMonitorCfg') - from TgcRawDataMonitoring.TgcRawDataMonitoringConf import TgcRawDataMonitorAlgorithm - tgcRawDataMonAlg = helper.addAlgorithm(TgcRawDataMonitorAlgorithm,'TgcRawDataMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + tgcRawDataMonAlg = helper.addAlgorithm(CompFactory.TgcRawDataMonitorAlgorithm,'TgcRawDataMonAlg') tgcRawDataMonAlg.TagAndProbe = False diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/python/JetTagMonitorAlgorithm.py b/PhysicsAnalysis/JetTagging/JetTagMonitoring/python/JetTagMonitorAlgorithm.py index 8708ba871ae9f048777fc02f0737cf5f43f51f24..05d34036d6b008703945ecc8c6cb88b5e5bcd7e0 100644 --- a/PhysicsAnalysis/JetTagging/JetTagMonitoring/python/JetTagMonitorAlgorithm.py +++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/python/JetTagMonitorAlgorithm.py @@ -32,9 +32,9 @@ def JetTagMonitorConfig(inputFlags): # is the algorithm. # You can actually make multiple instances of the same algorithm and give # them different configurations - from JetTagMonitoring.JetTagMonitoringConf import JetTagMonitorAlgorithm + from AthenaConfiguration.ComponentFactory import CompFactory #jetTagGeneral = helper.addAlgorithm(JetTagMonitorAlgorithm,'JetTagGeneral') - jetTagMonAlg = helper.addAlgorithm(JetTagMonitorAlgorithm,'JetTagMonAlg') + jetTagMonAlg = helper.addAlgorithm(CompFactory.JetTagMonitorAlgorithm,'JetTagMonAlg') #anotherJetTagMonAlg = helper.addAlgorithm(JetTagMonitorAlgorithm,'AnotherJetTagMonAlg') # If for some really obscure reason you need to instantiate an algorithm diff --git a/Reconstruction/Jet/JetMonitoring/python/JetMonitoringConfig.py b/Reconstruction/Jet/JetMonitoring/python/JetMonitoringConfig.py index 1816166655fd7170f1cd3bac5865c4c7efce2309..f87365552870fb48b07a1081ba795c9f9c17b116 100644 --- a/Reconstruction/Jet/JetMonitoring/python/JetMonitoringConfig.py +++ b/Reconstruction/Jet/JetMonitoring/python/JetMonitoringConfig.py @@ -1,3 +1,4 @@ +from __future__ import print_function # Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration # ####################################### @@ -45,19 +46,19 @@ class ConfigDict(dict): def __getattr__(self, attr): try: return self[attr] - except: + except KeyError: dict.__getattribute__(self,attr) #raise AttributeError(attr) def __setattr__(self, attr, value): if attr in ['keys', 'clear', 'update', 'pop', 'iteritems', 'values','setdefault','get','has_key','copy']: - print 'ConfigDict ERROR can not assign attribute ', attr + print('ConfigDict ERROR can not assign attribute ', attr) return dict.__setitem__(self, attr, value) dict.__setattr__(self, attr, value) def __setitem__(self, attr, value): if attr in ['keys', 'clear', 'update', 'pop', 'iteritems', 'values','setdefault','get','has_key','copy']: - print 'ConfigDict ERROR can not assign attribute ', attr + print('ConfigDict ERROR can not assign attribute ', attr) return dict.__setitem__(self, attr, value) dict.__setattr__(self, attr, value) @@ -77,11 +78,11 @@ class ConfigDict(dict): from sys import stdout out = stdout _write = out.write - write = lambda s, e='\n' : _write(s+e) + def write(s, e='\n'): _write(s+e) self._dump(write) def _dump(self, writeFunc): - write = lambda s, e='\n' : writeFunc(' '+s,e) + def write(s, e='\n'): writeFunc(' '+s,e) writeFunc(self.__class__.__name__+'(') for k,v in sorted(self.iteritems()): if isinstance(v, ConfigDict): @@ -109,8 +110,8 @@ def interpretSelStr(selStr): """ if '>' in selStr: - print "JetMonitoring ERROR interpreting selection string ", selStr - print "JetMonitoring ERROR can not interpret '>', please use only '<' " + print("JetMonitoring ERROR interpreting selection string ", selStr) + print("JetMonitoring ERROR can not interpret '>', please use only '<' ") parts = selStr.split('<') cmin, cmax = None, None var = selStr @@ -118,7 +119,7 @@ def interpretSelStr(selStr): ismin = False try : var, cut = parts[0] , float(parts[1]) - except: + except ValueError: cut, var = float(parts[0]) ,parts[1] ismin=True if ismin : cmin = cut @@ -136,7 +137,7 @@ def findSelectIndex( name): """ interprets 'varName[X]' into ('varName',x) """ try: name, index = name.split('[') - except: + except ValueError: name, index = name, '' if not index.endswith(']'): return name, -1 @@ -159,7 +160,7 @@ class ToolSpec(ConfigDict): from AthenaCommon import CfgMgr conf = self.clone(self.name) klass = getattr(CfgMgr,conf.pop('klass')) # remove 'klass' - name = conf.pop('name') + conf.pop('name') conf.pop('defineHistoFunc',None) # not used here. for k, v in conf.iteritems(): if isinstance(v,ToolSpec): @@ -202,8 +203,8 @@ class VarSpec(ToolSpec): def toTool(self): - from JetMonitoring.JetMonitoringConf import JetHistoVarTool - return JetHistoVarTool(self.Name, **self) + from AthenaConfiguration.ComponentFactory import CompFactory + return CompFactory.JetHistoVarTool(self.Name, **self) def vname(self): if self.Index ==-1: return self.Name @@ -293,9 +294,9 @@ class HistoSpec(ToolSpec): def toTool(self): - from JetMonitoring.JetMonitoringConf import JetHistoAttributeFiller + from AthenaConfiguration.ComponentFactory import CompFactory vx = retrieveVarToolConf( self.xvar) - tool = JetHistoAttributeFiller(self.groupName()+"hfiller", + tool = CompFactory.JetHistoAttributeFiller(self.groupName()+"hfiller", VarX = vx.toTool(), Group = self.groupName(), ) @@ -352,7 +353,7 @@ class HistoSpec(ToolSpec): def _dump(self, writeFunc): - write = lambda s : writeFunc(' '+s) + def write(s): writeFunc(' '+s) writeFunc('HistoSpec("'+self.name+'", '+str(self.bins) ) for k in [ 'xvar', 'yvar', 'zvar', 'isProfile' ]: if self[k] is not None: @@ -385,7 +386,7 @@ class SelectSpec(ToolSpec): # assume it's a known pre-defined jet selector selSpec = knownSelector.get(selexpr, None) if selSpec is None : - print "ERROR ", selexpr , " is an unknown JetSelector " + print("ERROR ", selexpr , " is an unknown JetSelector ") # should raise an exception ?? return args['Selector'] = selSpec @@ -403,10 +404,10 @@ class SelectSpec(ToolSpec): self.FillerTools += tmpL def toTool(self): - from JetMonitoring.JetMonitoringConf import JetHistoSelectSort + from AthenaConfiguration.ComponentFactory import CompFactory # conf = self.clone(self.name) # name = conf.pop('name') - selTool = JetHistoSelectSort(self.name, SelectedIndex=self.get('SelectedIndex',-1)) + selTool = CompFactory.JetHistoSelectSort(self.name, SelectedIndex=self.get('SelectedIndex',-1)) if hasattr(self,'Selector'): selTool.Selector = self.Selector.toTool() if hasattr(self, 'SortVariable'): @@ -427,8 +428,8 @@ class SelectSpec(ToolSpec): def _dump(self, writeFunc): - write = lambda s,e='\n' : writeFunc(' '+s,e) - write2 = lambda s,e='\n' : writeFunc(' '+s,e) + def write(s,e='\n'): writeFunc(' '+s,e) + def write2(s,e='\n'): writeFunc(' '+s,e) writeFunc('SelectSpec("'+self.name+'", path='+self.path+',') if hasattr(self, 'Selector' ): write(' Selector=','') @@ -456,8 +457,8 @@ class JetMonAlgSpec(ConfigDict): self.FillerTools += tmpL def toAlg(self, monhelper): - from JetMonitoring.JetMonitoringConf import JetMonitoringAlg - alg = monhelper.addAlgorithm(JetMonitoringAlg, self.name) + from AthenaConfiguration.ComponentFactory import CompFactory + alg = monhelper.addAlgorithm(CompFactory.JetMonitoringAlg, self.name) alg.TriggerChain = self.TriggerChain alg.JetContainerName = self.JetContainerName @@ -470,8 +471,8 @@ class JetMonAlgSpec(ConfigDict): return alg def _dump(self, writeFunc): - write = lambda s,e='\n' : writeFunc(' '+s,e) - write2 = lambda s,e='\n' : writeFunc(' '+s,e) + def write(s,e='\n'): writeFunc(' '+s,e) + def write2(s,e='\n'): writeFunc(' '+s,e) writeFunc(self.__class__.__name__+'(') for k,v in sorted(self.iteritems()): if k == 'FillerTools': @@ -535,7 +536,7 @@ def retrieveHistoToolConf(alias): cY = knownHistos.get(aliasY,None) if len(aliases) == 2: if None in (cX,cY): - print "ERROR unknown Histo Filler specification ", cX if cX is None else cY + print("ERROR unknown Histo Filler specification ", cX if cX is None else cY) return None # merge the spec return cX.to2DSpec(cY) @@ -552,7 +553,7 @@ def retrieveHistoToolConf(alias): else: # What is this : - print 'ERROR can not instantiate a tool from ', alias + print('ERROR can not instantiate a tool from ', alias) return None diff --git a/Reconstruction/Jet/JetMonitoring/python/JetMonitoringStandard.py b/Reconstruction/Jet/JetMonitoring/python/JetMonitoringStandard.py index e972817af473df0391848d71d98302411d9fbe8b..802efba4ee32353ede4c950f23c2f0ec9f5aacb4 100644 --- a/Reconstruction/Jet/JetMonitoring/python/JetMonitoringStandard.py +++ b/Reconstruction/Jet/JetMonitoring/python/JetMonitoringStandard.py @@ -100,7 +100,7 @@ def standardJetMonitoring(inputFlags): """ from AthenaMonitoring import AthMonitorCfgHelper - helper = AthMonitorCfgHelper(inputFlags,'ExampleAthMonitorCfg') + helper = AthMonitorCfgHelper(inputFlags,'JetMonitoring') ak4conf = jetMonAntiKt4LCTopo() ak4conf.toAlg(helper) # adds the ak4conf as a JEtMonitoringAlg to the helper diff --git a/Reconstruction/MissingETMonitoring/python/METMonitorAlgorithm.py b/Reconstruction/MissingETMonitoring/python/METMonitorAlgorithm.py index 4e560f4a0c73a6752468a5dcb73533e425e66111..65a4b59257cb36f57317bbf4fcceaba57feb914f 100644 --- a/Reconstruction/MissingETMonitoring/python/METMonitorAlgorithm.py +++ b/Reconstruction/MissingETMonitoring/python/METMonitorAlgorithm.py @@ -57,8 +57,8 @@ def METMonitoringConfig(inputFlags): helper = AthMonitorCfgHelper(inputFlags,'METMonitor') - from MissingETMonitoring.MissingETMonitoringConf import METMonitoringAlg - METRefFinal_MonAlg = helper.addAlgorithm(METMonitoringAlg,'METRefFinal_MonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + METRefFinal_MonAlg = helper.addAlgorithm(CompFactory.METMonitoringAlg,'METRefFinal_MonAlg') # anotherExampleMonAlg = helper.addAlgorithm(METMonitoringExampleAlg,'AnotherExampleMonAlg') # met_types = ["MET_RefEle", "MET_RefGamma"] # met_types = ["MET_RefFinal"] @@ -75,7 +75,7 @@ def METMonitoringConfig(inputFlags): defineHistograms(METRefFinal_MonAlg, group,helper,mets) - METPflow_MonAlg = helper.addAlgorithm(METMonitoringAlg,'METPflow_MonAlg') + METPflow_MonAlg = helper.addAlgorithm(CompFactory.METMonitoringAlg,'METPflow_MonAlg') pfmet_types = ["MET_PFlow","MET_PFlow_RefJet","MET_PFlow_Muon","MET_PFlow_RefEle","MET_PFlow_RefGamma","MET_PFlow_RefTau","MET_PFlow_PVSoftTrk"] METPflow_MonAlg.METContainer="MET_Reference_AntiKt4EMPFlow" METPflow_MonAlg.metKeys = pfmet_types @@ -87,7 +87,7 @@ def METMonitoringConfig(inputFlags): - METCalo_MonAlg = helper.addAlgorithm(METMonitoringAlg,'METCalo_MonAlg') + METCalo_MonAlg = helper.addAlgorithm(CompFactory.METMonitoringAlg,'METCalo_MonAlg') metcalo_types = [ "PEMB", "EMB", "PEME", "EME", "TILE", "HEC", "FCAL" ] METCalo_MonAlg.METContainer="MET_Calo" METCalo_MonAlg.METCaloKeys = metcalo_types @@ -98,7 +98,7 @@ def METMonitoringConfig(inputFlags): defineHistogramsCalo(METCalo_MonAlg, group,helper,mets) - METRefFinal_METCut_MonAlg = helper.addAlgorithm(METMonitoringAlg,'METRefFinal_METCut_MonAlg') + METRefFinal_METCut_MonAlg = helper.addAlgorithm(CompFactory.METMonitoringAlg,'METRefFinal_METCut_MonAlg') METRefFinal_METCut_MonAlg.METContainer="MET_Reference_AntiKt4EMTopo" METRefFinal_METCut_MonAlg.metTotalKey="FinalTrk" METRefFinal_METCut_MonAlg.metKeys = met_types @@ -116,7 +116,7 @@ def METMonitoringConfig(inputFlags): # jetCleaningTool.CutLevel = "TightBad" jetCleaningTool.DoUgly = False - JetCleaning_METMonAlg = helper.addAlgorithm(METMonitoringAlg,'JetCleaning_METMonAlg') + JetCleaning_METMonAlg = helper.addAlgorithm(CompFactory.METMonitoringAlg,'JetCleaning_METMonAlg') JetCleaning_METMonAlg.metKeys = met_types JetCleaning_METMonAlg.DoJetCleaning = True JetCleaning_METMonAlg.JetCleaningTool = jetCleaningTool @@ -136,7 +136,7 @@ def METMonitoringConfig(inputFlags): # jetCleaningTool.CutLevel = "TightBad" jetCleaningTool.DoUgly = False - BadJets_METMonAlg = helper.addAlgorithm(METMonitoringAlg,'BadJets_METMonAlg') + BadJets_METMonAlg = helper.addAlgorithm(CompFactory.METMonitoringAlg,'BadJets_METMonAlg') BadJets_METMonAlg.metKeys = met_types BadJets_METMonAlg.DoJetCleaning = True BadJets_METMonAlg.alltrigger = True diff --git a/Reconstruction/tauMonitoring/python/tauMonitorAlgorithm.py b/Reconstruction/tauMonitoring/python/tauMonitorAlgorithm.py index 8a3f3977a9dc108bd265259bd3c96678bf4202bf..2b1eb0075c2f99388c7d40d494b6f21105961f3a 100644 --- a/Reconstruction/tauMonitoring/python/tauMonitorAlgorithm.py +++ b/Reconstruction/tauMonitoring/python/tauMonitorAlgorithm.py @@ -26,7 +26,8 @@ def tauMonitoringConfig(inputFlags): # helper. Then, the helper will instantiate an instance and set up the # base class configuration following the inputFlags. The returned object # is the algorithm. - from tauMonitoring.tauMonitoringConf import tauMonitorAlgorithm + from AthenaConfiguration.ComponentFactory import CompFactory + tauMonitorAlgorithm = CompFactory.tauMonitorAlgorithm tauMonAlgBA = cfgHelper.addAlgorithm( tauMonitorAlgorithm, name='tauMonAlgBA') tauMonAlgCR = cfgHelper.addAlgorithm( tauMonitorAlgorithm, name='tauMonAlgCR') tauMonAlgEC = cfgHelper.addAlgorithm( tauMonitorAlgorithm, name='tauMonAlgEC') diff --git a/TileCalorimeter/TileMonitoring/python/TileCellMonitorAlgorithm.py b/TileCalorimeter/TileMonitoring/python/TileCellMonitorAlgorithm.py index 7e447d9df00e76fa69f8a5f9c8b8e4bece849eed..97d72af858f55860e8983c1812e1fd30bc4dc891 100644 --- a/TileCalorimeter/TileMonitoring/python/TileCellMonitorAlgorithm.py +++ b/TileCalorimeter/TileMonitoring/python/TileCellMonitorAlgorithm.py @@ -32,8 +32,8 @@ def TileCellMonitoringConfig(flags, **kwargs): helper = AthMonitorCfgHelper(flags,'TileMonitoring') # Adding an TileCellMonitorAlgorithm algorithm to the helper - from TileMonitoring.TileMonitoringConf import TileCellMonitorAlgorithm - tileCellMonAlg = helper.addAlgorithm(TileCellMonitorAlgorithm, 'TileCellMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + tileCellMonAlg = helper.addAlgorithm(CompFactory.TileCellMonitorAlgorithm, 'TileCellMonAlg') tileCellMonAlg.TriggerChain = '' diff --git a/TileCalorimeter/TileMonitoring/python/TileClusterMonitorAlgorithm.py b/TileCalorimeter/TileMonitoring/python/TileClusterMonitorAlgorithm.py index a7639006a3db293adaf8a4d343361eb632985190..c04ca5dc9d147c9d7839ae892255f4ac7706cdb4 100644 --- a/TileCalorimeter/TileMonitoring/python/TileClusterMonitorAlgorithm.py +++ b/TileCalorimeter/TileMonitoring/python/TileClusterMonitorAlgorithm.py @@ -23,8 +23,8 @@ def TileClusterMonitoringConfig(flags, **kwargs): helper = AthMonitorCfgHelper(flags,'TileClusterMonitoring') # Adding an TileCellMonitorAlgorithm algorithm to the helper - from TileMonitoring.TileMonitoringConf import TileClusterMonitorAlgorithm - tileClusterMonAlg = helper.addAlgorithm(TileClusterMonitorAlgorithm, 'TileClusterMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + tileClusterMonAlg = helper.addAlgorithm(CompFactory.TileClusterMonitorAlgorithm, 'TileClusterMonAlg') tileClusterMonAlg.TriggerChain = '' diff --git a/TileCalorimeter/TileMonitoring/python/TileDQFragMonitorAlgorithm.py b/TileCalorimeter/TileMonitoring/python/TileDQFragMonitorAlgorithm.py index 4dd5956d38a9045c6eac90f67590b7e9d5623c52..241d25f5b704d7672b33e0763ac47ca63de7537e 100644 --- a/TileCalorimeter/TileMonitoring/python/TileDQFragMonitorAlgorithm.py +++ b/TileCalorimeter/TileMonitoring/python/TileDQFragMonitorAlgorithm.py @@ -49,7 +49,9 @@ def TileDQFragMonitoringConfig(flags, **kwargs): helper = AthMonitorCfgHelper(flags, 'TileDQFragMonAlgCfg') runNumber = flags.Input.RunNumber[0] - _TileDQFragMonitoringCore(helper, runNumber, **kwargs) + from AthenaConfiguration.ComponentFactory import CompFactory + _TileDQFragMonitoringCore(helper, CompFactory.TileDQFragMonitorAlgorithm, + runNumber, **kwargs) accumalator = helper.result() result.merge(accumalator) @@ -79,19 +81,19 @@ def TileDQFragMonitoringConfigOld(flags, **kwargs): from RecExConfig.AutoConfiguration import GetRunNumber runNumber = GetRunNumber() - _TileDQFragMonitoringCore(helper, runNumber, **kwargs) + from TileMonitoring.TileMonitoringConf import TileDQFragMonitorAlgorithm + _TileDQFragMonitoringCore(helper, TileDQFragMonitorAlgorithm, runNumber, **kwargs) return helper.result() -def _TileDQFragMonitoringCore(helper, runNumber, **kwargs): +def _TileDQFragMonitoringCore(helper, algConfObj, runNumber, **kwargs): ''' Function to configure TileDQFragMonitorAlgorithm algorithm in the monitoring system.''' run = str(runNumber) - # Adding an TileDQFragMonitorAlgorithm algorithm to the helper - from TileMonitoring.TileMonitoringConf import TileDQFragMonitorAlgorithm - tileDQFragMonAlg = helper.addAlgorithm(TileDQFragMonitorAlgorithm, 'TileDQFragMonAlg') + # Adding an TileDQFragMonitorAlgorithm algorithm to the helper; try to accommodate old/new configuration styles + tileDQFragMonAlg = helper.addAlgorithm(algConfObj, 'TileDQFragMonAlg') for k, v in kwargs.items(): setattr(tileDQFragMonAlg, k, v) diff --git a/TileCalorimeter/TileMonitoring/python/TileJetMonitorAlgorithm.py b/TileCalorimeter/TileMonitoring/python/TileJetMonitorAlgorithm.py index 92a073877a4af8de3006f30de46c92c17fbdf789..65062613db090943d68e849994a1d92121a3fbce 100644 --- a/TileCalorimeter/TileMonitoring/python/TileJetMonitorAlgorithm.py +++ b/TileCalorimeter/TileMonitoring/python/TileJetMonitorAlgorithm.py @@ -38,8 +38,8 @@ def TileJetMonitoringConfig(flags, **kwargs): helper = AthMonitorCfgHelper(flags,'TileMonitoring') # Adding an TileJetMonitorAlgorithm algorithm to the helper - from TileMonitoring.TileMonitoringConf import TileJetMonitorAlgorithm - tileJetMonAlg = helper.addAlgorithm(TileJetMonitorAlgorithm, 'TileJetMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + tileJetMonAlg = helper.addAlgorithm(CompFactory.TileJetMonitorAlgorithm, 'TileJetMonAlg') tileJetMonAlg.TileBadChanTool = badChanTool tileJetMonAlg.TriggerChain = '' diff --git a/TileCalorimeter/TileMonitoring/python/TileMBTSMonitorAlgorithm.py b/TileCalorimeter/TileMonitoring/python/TileMBTSMonitorAlgorithm.py index 5d40788126f37ec35edffe41b6d6960c8d3ed59e..1e8a7afd3841c1446e52a7359015b6004bb3ab42 100644 --- a/TileCalorimeter/TileMonitoring/python/TileMBTSMonitorAlgorithm.py +++ b/TileCalorimeter/TileMonitoring/python/TileMBTSMonitorAlgorithm.py @@ -38,7 +38,9 @@ def TileMBTSMonitoringConfig(flags, **kwargs): helper = AthMonitorCfgHelper(flags, 'TileMBTSMonAlgCfg') runNumber = flags.Input.RunNumber[0] - _TileMBTSMonitoringConfigCore(helper, runNumber, **kwargs) + from AthenaConfiguration.ComponentFactory import CompFactory + _TileMBTSMonitoringConfigCore(helper, CompFactory.TileMBTSMonitorAlgorithm, + runNumber, **kwargs) accumalator = helper.result() result.merge(accumalator) @@ -60,20 +62,20 @@ def TileMBTSMonitoringConfigOld(flags, **kwargs): from RecExConfig.AutoConfiguration import GetRunNumber runNumber = GetRunNumber() - _TileMBTSMonitoringConfigCore(helper, runNumber, **kwargs) + from TileMonitoring.TileMonitoringConf import TileMBTSMonitorAlgorithm + _TileMBTSMonitoringConfigCore(helper, TileMBTSMonitorAlgorithm, runNumber, **kwargs) return helper.result() -def _TileMBTSMonitoringConfigCore(helper, runNumber, **kwargs): +def _TileMBTSMonitoringConfigCore(helper, algConfObj, runNumber, **kwargs): ''' Function to configure TileMBTSMonitorAlgorithm algorithm in the monitoring system.''' run = str(runNumber) # Adding an TileMBTSMonitorAlgorithm algorithm to the helper - from TileMonitoring.TileMonitoringConf import TileMBTSMonitorAlgorithm - tileMBTSMonAlg = helper.addAlgorithm(TileMBTSMonitorAlgorithm, 'TileMBTSMonAlg') + tileMBTSMonAlg = helper.addAlgorithm(algConfObj, 'TileMBTSMonAlg') tileMBTSMonAlg.TriggerChain = '' diff --git a/TileCalorimeter/TileMonitoring/python/TileMuIdMonitorAlgorithm.py b/TileCalorimeter/TileMonitoring/python/TileMuIdMonitorAlgorithm.py index 00865386f0edb9a327424e86a994c550c5229934..653679ea2a9b4486296d14b28ad5fdb83e50c66b 100644 --- a/TileCalorimeter/TileMonitoring/python/TileMuIdMonitorAlgorithm.py +++ b/TileCalorimeter/TileMonitoring/python/TileMuIdMonitorAlgorithm.py @@ -20,8 +20,8 @@ def TileMuIdMonitoringConfig(flags, **kwargs): helper = AthMonitorCfgHelper(flags,'TileMuIdMonitoring') # Adding an TileCellMonitorAlgorithm algorithm to the helper - from TileMonitoring.TileMonitoringConf import TileMuIdMonitorAlgorithm - tileMuIdMonAlg = helper.addAlgorithm(TileMuIdMonitorAlgorithm, 'TileMuIdMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + tileMuIdMonAlg = helper.addAlgorithm(CompFactory.TileMuIdMonitorAlgorithm, 'TileMuIdMonAlg') tileMuIdMonAlg.TriggerChain = '' diff --git a/TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py b/TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py index cda670c75677737b1a5ba21f4bc3bf9353a25b91..d476e667ab2e1dd17dd244906b26fbecefabc2fb 100644 --- a/TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py +++ b/TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py @@ -26,8 +26,8 @@ def TileTopoClusterCfg(flags, **kwargs): acc.merge(CaloNoiseCondAlgCfg(flags, 'totalNoise')) # Configure Tile topo cluster maker - from CaloRec.CaloRecConf import CaloTopoClusterMaker - topoClusterMaker = CaloTopoClusterMaker() + from AthenaConfiguration.ComponentFactory import CompFactory + topoClusterMaker = CompFactory.CaloTopoClusterMaker() topoClusterMaker.CellsName = 'AllCalo' topoClusterMaker.CalorimeterNames = ['TILE'] # Cells from the following samplings will be able to form seeds. @@ -49,8 +49,7 @@ def TileTopoClusterCfg(flags, **kwargs): kwargs['ClusterMakerTools'] = [topoClusterMaker] # Configure Tile topo cluster splitter - from CaloRec.CaloRecConf import CaloTopoClusterSplitter - topoClusterSpliter = CaloTopoClusterSplitter() + topoClusterSpliter = CompFactory.CaloTopoClusterSplitter() topoClusterSpliter.SamplingNames = ['TileBar0', 'TileBar1', 'TileBar2', 'TileExt0', 'TileExt1', 'TileExt2' , 'TileGap1', 'TileGap2', 'TileGap3'] @@ -61,8 +60,7 @@ def TileTopoClusterCfg(flags, **kwargs): kwargs['ClusterMakerTools'] += [topoClusterSpliter] # Configure Tile topo cluster moments maker - from CaloRec.CaloRecConf import CaloClusterMomentsMaker - clsuterMomentsMaker = CaloClusterMomentsMaker() + clsuterMomentsMaker = CompFactory.CaloClusterMomentsMaker() clsuterMomentsMaker.MaxAxisAngle = 30 * deg clsuterMomentsMaker.MomentsNames = ['FIRST_PHI' , 'FIRST_ETA' @@ -102,8 +100,7 @@ def TileTopoClusterCfg(flags, **kwargs): kwargs['ClusterCorrectionTools'] = [clsuterMomentsMaker] - from CaloRec.CaloRecConf import CaloClusterMaker - acc.addEventAlgo(CaloClusterMaker(**kwargs), primary = True) + acc.addEventAlgo(CompFactory.CaloClusterMaker(**kwargs), primary = True) return acc diff --git a/Trigger/TrigMonitoring/TrigBjetMonitoring/python/TrigBjetMonitorAlgorithm.py b/Trigger/TrigMonitoring/TrigBjetMonitoring/python/TrigBjetMonitorAlgorithm.py index 4bf6d39e495d6a8452df4ca5b7241ccfba3fd189..bfcd09d48dc0355741d6bd77d1d33062c41239c2 100644 --- a/Trigger/TrigMonitoring/TrigBjetMonitoring/python/TrigBjetMonitorAlgorithm.py +++ b/Trigger/TrigMonitoring/TrigBjetMonitoring/python/TrigBjetMonitorAlgorithm.py @@ -36,8 +36,8 @@ def TrigBjetMonConfig(inputFlags): # is the algorithm. #The added algorithm must exist as a .h file - from TrigBjetMonitoring.TrigBjetMonitoringConf import TrigBjetMonitorAlgorithm - trigBjetMonAlg = helper.addAlgorithm(TrigBjetMonitorAlgorithm,'TrigBjetMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + trigBjetMonAlg = helper.addAlgorithm(CompFactory.TrigBjetMonitorAlgorithm,'TrigBjetMonAlg') # You can actually make multiple instances of the same algorithm and give # them different configurations diff --git a/Trigger/TrigMonitoring/TrigBphysMonitoring/python/TrigBphysMonitorAlgorithm.py b/Trigger/TrigMonitoring/TrigBphysMonitoring/python/TrigBphysMonitorAlgorithm.py index 88e417191ab00149f9396539e8147d38eb2a480b..2bcba346880cd1b50b643ca39089a77feec8b10b 100644 --- a/Trigger/TrigMonitoring/TrigBphysMonitoring/python/TrigBphysMonitorAlgorithm.py +++ b/Trigger/TrigMonitoring/TrigBphysMonitoring/python/TrigBphysMonitorAlgorithm.py @@ -33,8 +33,8 @@ def TrigBphysMonConfig(inputFlags): # is the algorithm. # The added algorithm must exist as a .h file - from TrigBphysMonitoring.TrigBphysMonitoringConf import TrigBphysMonitorAlgorithm - trigBphysMonAlg = helper.addAlgorithm(TrigBphysMonitorAlgorithm,'TrigBphysMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + trigBphysMonAlg = helper.addAlgorithm(CompFactory.TrigBphysMonitorAlgorithm,'TrigBphysMonAlg') #from AthenaCommon.Constants import DEBUG,INFO #trigBphysMonAlg.OutputLevel = INFO diff --git a/Trigger/TrigMonitoring/TrigCaloMonitoring/python/TrigCaloMonitorAlgorithm.py b/Trigger/TrigMonitoring/TrigCaloMonitoring/python/TrigCaloMonitorAlgorithm.py index e5dbfe7bf8e34034d4f6f23afa6f444bf604743f..825f0d0e1f0780ac1136086f620de4ffb237e535 100644 --- a/Trigger/TrigMonitoring/TrigCaloMonitoring/python/TrigCaloMonitorAlgorithm.py +++ b/Trigger/TrigMonitoring/TrigCaloMonitoring/python/TrigCaloMonitorAlgorithm.py @@ -32,8 +32,8 @@ def TrigCaloMonConfig(inputFlags): # Add monitor algorithm - from TrigCaloMonitoring.TrigCaloMonitoringConf import HLTCalo_L2CaloEMClustersMonitor - L2CaloEMClustersMonAlg = helper.addAlgorithm(HLTCalo_L2CaloEMClustersMonitor, 'HLT_L2CaloEMClustersMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + L2CaloEMClustersMonAlg = helper.addAlgorithm(CompFactory.HLTCalo_L2CaloEMClustersMonitor, 'HLT_L2CaloEMClustersMonAlg') # Set properties L2CaloEMClustersMonAlg.HLTContainer = 'HLT_L2CaloEMClusters' @@ -215,10 +215,9 @@ def TrigCaloMonConfig(inputFlags): # Add monitor algorithm - from TrigCaloMonitoring.TrigCaloMonitoringConf import HLTCalo_TopoCaloClustersMonitor - TopoCaloClustersFSMonAlg = helper.addAlgorithm(HLTCalo_TopoCaloClustersMonitor, 'HLT_TopoCaloClustersFSMonAlg') - TopoCaloClustersRoIMonAlg = helper.addAlgorithm(HLTCalo_TopoCaloClustersMonitor, 'HLT_TopoCaloClustersRoIMonAlg') - TopoCaloClustersLCMonAlg = helper.addAlgorithm(HLTCalo_TopoCaloClustersMonitor, 'HLT_TopoCaloClustersLCMonAlg') + TopoCaloClustersFSMonAlg = helper.addAlgorithm(CompFactory.HLTCalo_TopoCaloClustersMonitor, 'HLT_TopoCaloClustersFSMonAlg') + TopoCaloClustersRoIMonAlg = helper.addAlgorithm(CompFactory.HLTCalo_TopoCaloClustersMonitor, 'HLT_TopoCaloClustersRoIMonAlg') + TopoCaloClustersLCMonAlg = helper.addAlgorithm(CompFactory.HLTCalo_TopoCaloClustersMonitor, 'HLT_TopoCaloClustersLCMonAlg') TopoCaloClustersFSMonAlg.HLTContainer = 'HLT_TopoCaloClustersFS' TopoCaloClustersRoIMonAlg.HLTContainer = 'HLT_TopoCaloClustersRoI' TopoCaloClustersLCMonAlg.HLTContainer = 'HLT_TopoCaloClustersLC' diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringConfigRun3.py b/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringConfigRun3.py index 5ade1d64f3de6f19326fe36bcfec66616c895bf4..547d4685a36eb2c8c3d5a0ee4d4c64d853573f80 100644 --- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringConfigRun3.py +++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringConfigRun3.py @@ -140,7 +140,7 @@ class TrigEgammaMonToolBuilderRun3(TrigEgammaMonToolBuilder): log_trigeg.info('TrigEgammaMonToolBuilderRun3.config') self._get_monitoring_mode_success = self.get_monitoring_mode() #print self._get_monitoring_mode_success - if self._get_monitoring_mode_success == False: + if not self._get_monitoring_mode_success: log_trigeg.warning("HLTMonTriggerList: Error getting monitoring mode, default monitoring lists will be used.") else: log_trigeg.info("Configuring for %s", self.data_type) @@ -182,18 +182,18 @@ class TrigEgammaMonToolBuilderRun3(TrigEgammaMonToolBuilder): if doJpsiee: - self._nEtbins=51; + self._nEtbins=51 self._etbins = etbins_Jpsiee[0:self._nEtbins+1] else: - self._nEtbins=30; + self._nEtbins=30 self._etbins = etbins_Zee[0:self._nEtbins+1] # Define the binning - self._nEtabins=20; - self._ndefaultEtbins=13; - self._ndefaultEtabins=20; - self._ncoarseEtbins=6; - self._ncoarseEtabins=8; + self._nEtabins=20 + self._ndefaultEtbins=13 + self._ndefaultEtabins=20 + self._ncoarseEtbins=6 + self._ncoarseEtabins=8 #Fill the arrays self._etabins = etabins[0:self._nEtabins+1] @@ -224,8 +224,8 @@ class TrigEgammaMonToolBuilderRun3(TrigEgammaMonToolBuilder): # base class configuration following the inputFlags. The returned object # is the algorithm. #The added algorithm must exist as a .h file - from TrigEgammaMonitoring.TrigEgammaMonitoringConf import TrigEgammaMonitorAlgorithm - trigEgammaMonAlg = helper.addAlgorithm(TrigEgammaMonitorAlgorithm, algnameprefix+'__'+triggerChain) + from AthenaConfiguration.ComponentFactory import CompFactory + trigEgammaMonAlg = helper.addAlgorithm(CompFactory.TrigEgammaMonitorAlgorithm, algnameprefix+'__'+triggerChain) ### STEP 3 ### # Edit properties of a algorithm @@ -908,9 +908,9 @@ class TrigEgammaMonToolBuilderRun3(TrigEgammaMonToolBuilder): self.addHistogram(monGroup, TH1F("lhloose_discriminant", "lh loose discriminant; lh loose discriminant; Count", 50, -5.,2.)) if self.detailLevel: - addHistogram(monGroup, TH2F("deta1_vs_clusterEta", "HLT deta1 as function of cluster #eta; #eta; deta1; Count", - 50, -2.47, 2.47, - 90, -0.03, 0.03)) + self.addHistogram(monGroup, TH2F("deta1_vs_clusterEta", "HLT deta1 as function of cluster #eta; #eta; deta1; Count", + 50, -2.47, 2.47, + 90, -0.03, 0.03)) def bookEfficiency2DHistos(self, monGroup): diff --git a/Trigger/TrigMonitoring/TrigHLTMonitoring/python/TrigHLTMonitorAlgorithm.py b/Trigger/TrigMonitoring/TrigHLTMonitoring/python/TrigHLTMonitorAlgorithm.py index c95f71edef1a5d6c0dd10c0f20999d26dd8c942e..4d3d5793ca80754657f999b92a6f66f09c32baa2 100644 --- a/Trigger/TrigMonitoring/TrigHLTMonitoring/python/TrigHLTMonitorAlgorithm.py +++ b/Trigger/TrigMonitoring/TrigHLTMonitoring/python/TrigHLTMonitorAlgorithm.py @@ -86,9 +86,9 @@ def TrigHLTMonConfig(inputFlags): # Adding algorithms to the helper. # The added algorithm must exist as a .h file - from TrigHLTMonitoring.TrigHLTMonitoringConf import TrigHLTMonitorAlgorithm - trigHLTMonAlg = helper.addAlgorithm(TrigHLTMonitorAlgorithm,'TrigHLTMonAlg') - signatureTrigHLTMonAlg = helper.addAlgorithm(TrigHLTMonitorAlgorithm,'SignatureTrigHLTMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + trigHLTMonAlg = helper.addAlgorithm(CompFactory.TrigHLTMonitorAlgorithm,'TrigHLTMonAlg') + signatureTrigHLTMonAlg = helper.addAlgorithm(CompFactory.TrigHLTMonitorAlgorithm,'SignatureTrigHLTMonAlg') ### STEP 3 ### diff --git a/Trigger/TrigMonitoring/TrigMETMonitoring/python/TrigMETMonitorAlgorithm.py b/Trigger/TrigMonitoring/TrigMETMonitoring/python/TrigMETMonitorAlgorithm.py index a34750e44c32b6eba4185f8e24078ef6981d78cc..49e817950a8fe2c313a50b6a1ac1fbfe07304bd4 100644 --- a/Trigger/TrigMonitoring/TrigMETMonitoring/python/TrigMETMonitorAlgorithm.py +++ b/Trigger/TrigMonitoring/TrigMETMonitoring/python/TrigMETMonitorAlgorithm.py @@ -28,12 +28,12 @@ def TrigMETMonConfig(inputFlags): # is the algorithm. #The added algorithm must exist as a .h file - from TrigMETMonitoring.TrigMETMonitoringConf import TrigMETMonitorAlgorithm - TrigMETMonAlg = helper.addAlgorithm(TrigMETMonitorAlgorithm,'TrigMETMonAlg') + from AthenaConfiguration.ComponentFactory import CompFactory + TrigMETMonAlg = helper.addAlgorithm(CompFactory.TrigMETMonitorAlgorithm,'TrigMETMonAlg') # You can actually make multiple instances of the same algorithm and give # them different configurations - TrigMETMonChainAlg = helper.addAlgorithm(TrigMETMonitorAlgorithm,'TrigMETMonChainAlg') + TrigMETMonChainAlg = helper.addAlgorithm(CompFactory.TrigMETMonitorAlgorithm,'TrigMETMonChainAlg') # # If for some really obscure reason you need to instantiate an algorithm # # yourself, the AddAlgorithm method will still configure the base diff --git a/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L1MuonMonConfig.py b/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L1MuonMonConfig.py index 25f76c19f7249c26fa9283898ea6acf471aa2918..6e1713a725f46291828016e2d1350935e6670182 100644 --- a/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L1MuonMonConfig.py +++ b/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L1MuonMonConfig.py @@ -3,8 +3,8 @@ def L1MuonMonConfig(helper): - from TrigMuonMonitoringMT.TrigMuonMonitoringMTConf import L1MuonMonMT - monAlg = helper.addAlgorithm(L1MuonMonMT,'L1MuonMonMT') + from AthenaConfiguration.ComponentFactory import CompFactory + monAlg = helper.addAlgorithm(CompFactory.L1MuonMonMT,'L1MuonMonMT') histGroup = helper.addGroup(monAlg, 'L1MuonMonMT', 'HLT/MuonMon/L1Muon') diff --git a/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L2MuonSAMonConfig.py b/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L2MuonSAMonConfig.py index 9249e9c6384faf5046719f53270f3095cc11b16c..5cf22eb6f97c5eae7fae72e662119a31bf0475fa 100644 --- a/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L2MuonSAMonConfig.py +++ b/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/L2MuonSAMonConfig.py @@ -3,8 +3,8 @@ def L2MuonSAMonConfig(helper): - from TrigMuonMonitoringMT.TrigMuonMonitoringMTConf import L2MuonSAMonMT - monAlg = helper.addAlgorithm(L2MuonSAMonMT,'L2MuonSAMonMT') + from AthenaConfiguration.ComponentFactory import CompFactory + monAlg = helper.addAlgorithm(CompFactory.L2MuonSAMonMT,'L2MuonSAMonMT') histGroup = helper.addGroup(monAlg, 'L2MuonSAMonMT', 'HLT/MuonMon/L2MuonSA') diff --git a/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/TrigMuonEfficiencyMonConfig.py b/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/TrigMuonEfficiencyMonConfig.py index 2e567642773f3170058bcb82b6baf416fcf70f19..d2966fb32dbc453eae36c6a810b94afa27b91fcb 100644 --- a/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/TrigMuonEfficiencyMonConfig.py +++ b/Trigger/TrigMonitoring/TrigMuonMonitoringMT/python/TrigMuonEfficiencyMonConfig.py @@ -3,12 +3,12 @@ def TrigMuonEfficiencyMonConfig(helper): - from TrigMuonMonitoringMT.TrigMuonMonitoringMTConf import TrigMuonEfficiencyMonMT + from AthenaConfiguration.ComponentFactory import CompFactory Chains = ['HLT_mu26_ivarmedium_L1MU20', 'HLT_mu50_L1MU20', 'HLT_mu6_L1MU6'] for chain in Chains: - monAlg = helper.addAlgorithm(TrigMuonEfficiencyMonMT,'TrigMuEff_'+chain) + monAlg = helper.addAlgorithm(CompFactory.TrigMuonEfficiencyMonMT,'TrigMuEff_'+chain) monAlg.EventTrigger = '' monAlg.MeasuredTrigger = chain @@ -19,7 +19,6 @@ def TrigMuonEfficiencyMonConfig(helper): histGroup = helper.addGroup(monAlg, GroupName, 'HLT/MuonMon/Efficiency/'+chain) - import ROOT histGroup.defineHistogram(GroupName+'_muPt',title='All offline combined muon '+chain+';p_{T} [GeV];Events', type='TH1F', path='',xbins=30,xmin=0.0,xmax=60.0) histGroup.defineHistogram(GroupName+'_muPt,'+GroupName+'_muPt_L1passed',title='L1MU Efficiency '+chain+';p_{T} [GeV];Efficiency', type='TProfile', path='',xbins=30,xmin=0.0,xmax=60.0) histGroup.defineHistogram(GroupName+'_muPt,'+GroupName+'_muPt_SApassed',title='L2MuonSA Efficiency '+chain+';p_{T} [GeV];Efficiency', type='TProfile', path='',xbins=30,xmin=0.0,xmax=60.0)