diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/CscPrepDataRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/CscPrepDataRetriever.cxx
index 92d12ad8d84a06596f09f95ea19eaf3c407f9a35..ee2283274c7ee25375216ee373f620beed81baa3 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/CscPrepDataRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/CscPrepDataRetriever.cxx
@@ -38,7 +38,11 @@ namespace JiveXML {
ATH_MSG_VERBOSE("Retrieving " << dataTypeName());
SG::ReadHandle<Muon::CscPrepDataContainer> cscContainer(m_sgKey);
-
+
+ if (!cscContainer.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
int ndata = 0;
Muon::CscPrepDataContainer::const_iterator containerIt;
diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MMPrepDataRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MMPrepDataRetriever.cxx
index 859ba5b11557aa2e82ef2e2ed38efdc029b7fcb4..42cded98c1942397b5bb3d6e49bb39f7c820a10b 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MMPrepDataRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MMPrepDataRetriever.cxx
@@ -46,6 +46,11 @@ namespace JiveXML {
SG::ReadHandle<Muon::MMPrepDataContainer> mmContainer(m_sgKey);
+ if (!mmContainer.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
+
int ndata = 0;
for (const auto mmCollection : *mmContainer){
ndata += mmCollection->size();
diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MdtPrepDataRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MdtPrepDataRetriever.cxx
index 767d3e6fb9daf48f79e38e44e2e13ce9c22d6b87..f9f1fade1240e53d0cab0fb8c38657483e479a60 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MdtPrepDataRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/MdtPrepDataRetriever.cxx
@@ -40,7 +40,10 @@ namespace JiveXML {
ATH_MSG_VERBOSE("Retrieving " << dataTypeName());
SG::ReadHandle<Muon::MdtPrepDataContainer> mdtContainer(m_sgKey);
-
+ if (!mdtContainer.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
int ndata = 0;
Muon::MdtPrepDataContainer::const_iterator containerIt;
diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/RpcPrepDataRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/RpcPrepDataRetriever.cxx
index 0d6247a68199dbf4144dcd4879f1c98b648a2c8a..e07dc10a5ecad8a54e5c96a6946b827f725639ef 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/RpcPrepDataRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/RpcPrepDataRetriever.cxx
@@ -40,6 +40,11 @@ namespace JiveXML {
SG::ReadHandle<Muon::RpcPrepDataContainer> rpcContainer(m_sgKey);
+ if (!rpcContainer.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
+
int ndata = 0;
Muon::RpcPrepDataContainer::const_iterator containerIt;
for (containerIt=rpcContainer->begin(); containerIt!=rpcContainer->end(); ++containerIt) {
diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TgcPrepDataRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TgcPrepDataRetriever.cxx
index eeba935c39fa9647f64f01304550418ea0dee695..ed3cb6279c87456dfb5495f55ebbba74ecf29fef 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TgcPrepDataRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TgcPrepDataRetriever.cxx
@@ -38,6 +38,11 @@ namespace JiveXML {
SG::ReadHandle<Muon::TgcPrepDataContainer> tgcContainer(m_sgKey);
+ if (!tgcContainer.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
+
int ndata = 0;
Muon::TgcPrepDataContainer::const_iterator containerIt;
for (containerIt=tgcContainer->begin(); containerIt!=tgcContainer->end(); ++containerIt) {
diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigMuonROIRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigMuonROIRetriever.cxx
index 75038032d627d8e5fc5042fec448ecc375e47637..798d0bff9870a435cc776deeb89f34ae86257735 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigMuonROIRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigMuonROIRetriever.cxx
@@ -28,7 +28,11 @@ namespace JiveXML {
if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Retrieving " << dataTypeName() << endmsg;
SG::ReadHandle<LVL1_ROI> roi(m_sgKey);
-
+
+ if (!roi.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
int nRoIs = roi->getMuonROIs().size();
DataVect phi; phi.reserve(nRoIs);
diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigRpcDataRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigRpcDataRetriever.cxx
index 0d13e22735b7c7717cf1354476f59169666e81a1..2afc916114c8519811c9997d1db2199fca16e16f 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigRpcDataRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/TrigRpcDataRetriever.cxx
@@ -42,6 +42,11 @@ namespace JiveXML {
// retrieve the collection of RDO
SG::ReadHandle<RpcPadContainer> rdoContainer(m_sgKey);
+ if (!rdoContainer.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
+
int ndata=0;
for (auto containerIt=rdoContainer->begin(); containerIt!=rdoContainer->end(); ++containerIt) {
ndata += (*containerIt)->size();
diff --git a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/sTgcPrepDataRetriever.cxx b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/sTgcPrepDataRetriever.cxx
index 6aae6cca1dace1c566b54737423587357b6c0c93..89a2efe02d8ea329c84047d70b8e62c53245aeaa 100644
--- a/MuonSpectrometer/MuonCnv/MuonJiveXML/src/sTgcPrepDataRetriever.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonJiveXML/src/sTgcPrepDataRetriever.cxx
@@ -45,6 +45,11 @@ namespace JiveXML {
SG::ReadHandle<Muon::sTgcPrepDataContainer> stgcContainer(m_sgKey);
+ if (!stgcContainer.isValid()) {
+ ATH_MSG_WARNING("Unable to retrieve: " << m_sgKey);
+ return(StatusCode::SUCCESS);
+ }
+
int ndata = 0;
for (const auto stgcCollection : *stgcContainer){
ndata += stgcCollection->size();
diff --git a/graphics/EventDisplaysOnline/python/EventDisplaysOnlineConfig.py b/graphics/EventDisplaysOnline/python/EventDisplaysOnlineConfig.py
index 15cc256fddebf8c1c84aa44f586eccd998d05f81..5ed58d8746ce0f5afb911261c5f8158988114fd2 100644
--- a/graphics/EventDisplaysOnline/python/EventDisplaysOnlineConfig.py
+++ b/graphics/EventDisplaysOnline/python/EventDisplaysOnlineConfig.py
@@ -3,67 +3,43 @@
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from EventDisplaysOnline.EventDisplaysOnlineHelpers import GetRunType, GetBFields, WaitForPartition
-from AthenaConfiguration.Enums import BeamType
+from AthenaCommon.Constants import INFO, DEBUG, ERROR, WARNING
-isCosmicData = False
isHIMode = False #TODO
-isBeamSplashMode = False
-isOfflineTest = False
-testWithoutPartition = False
-HorizontalMuons_quickReco = False
-
-# An explicit list for nominal data taking to exclude some high rate streams
-# Empty list to read all
-streamsWanted = ['express','ZeroBias','CosmicCalo','IDCosmic','CosmicMuons','Background','Standby','L1Calo','Main']
-if isBeamSplashMode:
- streamsWanted = ['MinBias'] #if trigger fails it will go to debug_HltError
-
-# If testing at p1, write out to /tmp/ to see output
-outputDirectory="/atlas/EventDisplayEvents/"
-#outputDirectory="/tmp/myexley"
-if isOfflineTest:
- outputDirectory="."
-
-sendToPublicStream = False # Gets set later, overwrite here to True to test it
+#TODO isBeamSplashMode = False
+isOfflineTest = True
+testWithoutPartition = True
##----------------------------------------------------------------------##
## When the ATLAS partition is not running you can use two test ##
## partitions that serve events from a raw data file. ##
## To see which files will be ran over on the test partitions, at ##
## point 1, see the uncommented lines in: ##
-## /det/dqm/GlobalMonitoring/GMTestPartition_oks/tdaq-11-02-01/ ##
+## /det/dqm/GlobalMonitoring/GMTestPartition_oks/tdaq-10-00-00/ ##
## without_gatherer/GMTestPartitionT9.data.xml ##
## and in: ##
-## /det/dqm/GlobalMonitoring/GMTestPartition_oks/tdaq-11-02-01/ ##
+## /det/dqm/GlobalMonitoring/GMTestPartition_oks/tdaq-10-00-00/ ##
## without_gatherer/GMTestPartition.data.xml ##
##----------------------------------------------------------------------##
-partitionName = 'ATLAS' # 'ATLAS', 'GMTestPartition' or 'GMTestPartitionT9'
+partitionName = 'GMTestPartition' # ''ATLAS', 'GMTestPartitionT9' or 'GMTestPartition'
+
+# Pause this thread until the partition is up
+if not testWithoutPartition or not isOfflineTest:
+ WaitForPartition(partitionName)
+
+# outputDirectory="/atlas/EventDisplayEvents/"
+outputDirectory="/afs/cern.ch/user/m/myexley/WorkSpace/testCA/run/output/"
if isHIMode:
- maxEvents=200 # Number of events to keep per stream in /atlas/EventDisplays/stream
- projectTags=['data24_hi']
- projectName='data24_hi'
- publicStreams=['MinBias']
-if isCosmicData:
maxEvents=200
- projectTags=['data24_cos']
- projectName='data24_cos'
- publicStreams=['IDCosmics']
-if isBeamSplashMode:
- maxEvents=-1
- projectTags=['data24_13p6TeV']
- projectName='data24_13p6TeV'
- publicStreams=['']
+ projectTags=['data23_hi']
+ projectName='data23_hi'
+ publicStreams=['physics_MinBias']
else:
maxEvents=100
- projectTags=['data24_13p6TeV']
- projectName='data24_13p6TeV'
- publicStreams=['Main']
-
-
-# Pause this thread until the partition is up
-if not testWithoutPartition or not isOfflineTest:
- WaitForPartition(partitionName)
+ projectTags=['data23_13p6TeV']
+ projectName='data23_13p6TeV'
+ publicStreams=['physics_Main']
# Setup unique output files (so that multiple Athena jobs on the same machine don't interfere)
import os
@@ -83,88 +59,56 @@ flags = initConfigFlags()
if not isOfflineTest:
from AthenaConfiguration.AutoConfigOnlineRecoFlags import autoConfigOnlineRecoFlags
autoConfigOnlineRecoFlags(flags, partitionName)
+flags.Concurrency.NumThreads = 1
# Conditions tag
-flags.IOVDb.DatabaseInstance = "CONDBR2"
if isOfflineTest:
- flags.IOVDb.GlobalTag = 'CONDBR2-BLKPA-2023-02'
+ flags.IOVDb.GlobalTag = 'CONDBR2-BLKPA-2023-01'
else:
flags.IOVDb.GlobalTag = 'CONDBR2-HLTP-2023-01' # Online conditions tag
+
flags.GeoModel.Layout="atlas"
flags.GeoModel.AtlasVersion = 'ATLAS-R3S-2021-03-02-00' # Geometry tag
if isHIMode:
- flags.Beam.BunchSpacing = 100 # ns
+ flags.Beam.BunchSpacing = 100 # ns
else:
flags.Beam.BunchSpacing = 25 # ns
flags.Trigger.triggerConfig='DB'
-# Test wth a small amount of events and write out to e.g. a tmp dir
+# Test wth a small amount of events and write out to tmp dir
if testWithoutPartition or partitionName != 'ATLAS' or isOfflineTest:
- flags.Exec.MaxEvents = 5
+ flags.Exec.MaxEvents = 3
flags.Output.ESDFileName = outputDirectory + "ESD-%s-%s.pool.root" % (jobId[3], jobId[4])
else:
- flags.Exec.MaxEvents = 20000 # hack until we find a way to fix the memory fragmentation ATEAM-896, this resets the memory after 20k events
+ flags.Exec.MaxEvents = -1
flags.Output.ESDFileName = "ESD-%s-%s.pool.root" % (jobId[3], jobId[4])
flags.Output.doWriteESD = True
-#flags.Output.doJiveXML = True # We call the AlgoJive later on
+#flags.Output.doJiveXML = True
-if testWithoutPartition:
- flags.Input.Files = ['/detwork/dqm/EventDisplays_test_data/data23_13p6TeV.00454188.physics_Main.daq.RAW._lb0633._SFO-12._0002.data']
-if isOfflineTest:
- flags.Input.Files = ['/eos/home-m/myexley/sharedWithATLASauthors/data23_13p6TeV.00454188.physics_Main.daq.RAW._lb0633._SFO-12._0002.data']
+if testWithoutPartition or isOfflineTest:
+ #flags.Input.Files = ['/detwork/dqm/EventDisplays_test_data/data23_13p6TeV.00454188.physics_Main.daq.RAW._lb0633._SFO-12._0002.data']
+ flags.Input.Files = ['/afs/cern.ch/work/m/myexley/ED-files/nominal/data23_13p6TeV.00454188.physics_Main.daq.RAW._lb0633._SFO-12._0002.data']
else:
flags.Input.Files = [] # Files are read from the ATLAS (or GM test) partition
-flags.Reco.EnableTrigger = False # TODO test True
-flags.Detector.GeometryForward = False
-flags.Detector.EnableFwdRegion = False
-if isOfflineTest:
- flags.LAr.doHVCorr = True
-else:
- flags.LAr.doHVCorr = False # ATLASRECTS-6823
-
-if isBeamSplashMode or HorizontalMuons_quickReco:
- flags.Reco.EnableJet=False;
- flags.Reco.EnableMet=False;
- flags.Reco.EnableTau=False;
- flags.Reco.EnablePFlow=False;
- flags.Reco.EnableBTagging=False;
- flags.Reco.EnableEgamma=False;
- flags.Reco.EnableCombinedMuon=False;
-
-from AthenaCommon.Constants import INFO
+flags.Reco.EnableTrigger = False
+flags.LAr.doHVCorr = False # ATLASRECTS-6823
flags.Exec.OutputLevel = INFO
-flags.Concurrency.NumThreads = 0
if isOfflineTest:
flags.Common.isOnline = False
-else:
- flags.Common.isOnline = True
if partitionName == 'ATLAS' and not testWithoutPartition and not isOfflineTest:
# Read run number from the partition
# For beam plashes when LAr running in 32 samples mode, the current run number to LAr config is needed
# IS stands for Information Service
- from ispy import ISObject, IPCPartition, ISInfoAny, ISInfoDictionary
- part = IPCPartition(partitionName)
- RunParams = ISObject(part, 'RunParams.RunParams', 'RunParams')
+ from ispy import ISObject, IPCPartition
+ RunParams = ISObject(IPCPartition(partitionName), 'RunParams.RunParams', 'RunParams')
RunParams.checkout()
- run_number = RunParams.getAttributeValue('run_number')
- flags.Input.OverrideRunNumber = True
- flags.Input.RunNumbers = [run_number]
-
- # Is the data allowed to be seen by the general public on atlas live
- ready4physics = ISInfoAny()
- ISInfoDictionary(part).getValue('RunParams.Ready4Physics', ready4physics)
- print("Ready for physics: %s " % ready4physics.get())
- physicsReady = ISObject(part, 'RunParams.Ready4Physics','Ready4PhysicsInfo')
- physicsReady.checkout()
- print("Ready for physics: %r" % (physicsReady.ready4physics))
- if physicsReady.ready4physics and RunParams.T0_project_tag in projectTags:
- sendToPublicStream = True
-
+ flags.Input.RunNumber = RunParams.run_number
+
# Get the B field
(solenoidOn,toroidOn)=GetBFields()
flags.BField.override = True
@@ -173,27 +117,33 @@ if partitionName == 'ATLAS' and not testWithoutPartition and not isOfflineTest:
flags.BField.endcapToroidOn = toroidOn
# GM test partition needs to be given the below info
-if (partitionName == 'GMTestPartition' or partitionName == 'GMTestPartitionT9'):
- flags.Input.OverrideRunNumber = True
- flags.Input.RunNumbers = [449604] # keep this number the same as (or close to) the run number of the file you are testing on
- flags.Input.LumiBlockNumbers = [1]
+if (partitionName == 'GMTestPartition' or partitionName == 'GMTestPartitionT9') or testWithoutPartition:# or isOfflineTest:
+ flags.Input.RunNumber = [412343]
+ flags.Input.LumiBlockNumber = [1]
flags.Input.ProjectName = projectName
if not testWithoutPartition:
- if isCosmicData:
- flags.Beam.Type = BeamType.Cosmics
- else:
- flags.Beam.Type = BeamType.Collisions
+ RunType = GetRunType()
+ flags.Beam.Type = RunType # "singlebeam", "collisions" or "cosmics"
+
flags.lock()
flags.dump()
##----------------------------------------------------------------------##
-
from RecJobTransforms.RecoSteering import RecoSteering
acc = RecoSteering(flags)
from IOVDbSvc.IOVDbSvcConfig import addOverride
-if not isOfflineTest:
- acc.merge(addOverride(flags, "/TRT/Onl/Calib/PID_NN", "TRTCalibPID_NN_v2", db=""))
+acc.merge(addOverride(flags, "/TRT/Onl/Calib/PID_NN", "TRTCalibPID_NN_v2"))
+acc.merge(addOverride(flags,"/TRT/Calib/PID_NN", "TRTCalibPID_NN_v1"))
+
+if isHIMode:
+ maxEvents=200
+ projectTags=['data23_hi']
+ publicStreams=['physics_MinBias']
+else:
+ maxEvents=100
+ projectTags=['data23_13p6TeV']
+ publicStreams=['physics_Main']
if not testWithoutPartition:
bytestreamConversion = CompFactory.ByteStreamCnvSvc()
@@ -207,91 +157,68 @@ if not testWithoutPartition:
bytestreamInput.GroupName = "EventDisplaysOnline"
bytestreamInput.PublishName = "EventDisplays"
bytestreamInput.Key = "dcm"
- bytestreamInput.KeyCount = 3
- bytestreamInput.Timeout = 600000
+ bytestreamInput.KeyCount = 3 # equal or greater than the number of DCMs for beam splashes
+ bytestreamInput.Timeout = 600000 # 144000000 (40 hrs) for beam splashes
bytestreamInput.UpdatePeriod = 200
bytestreamInput.BufferSize = 10 # three times of keycount for beam splashes
bytestreamInput.ISServer = '' # Disable histogramming
- bytestreamInput.StreamNames = streamsWanted
- #bytestreamInput.StreamType = "physics" #comment out for all streams, e.g. if you also want claibration streams
+ # Empty stream name list to read all streams
+ # 'MinBias' for beam splashes
+ # An explicit list for nominal data taking to exclude some high rate streams
+ bytestreamInput.StreamNames = ['ZeroBias:CosmicCalo:IDCosmic:CosmicMuons:Background:Standby:L1Calo:Main']
+ bytestreamInput.StreamType = "physics"
bytestreamInput.StreamLogic = "Or"
- if isBeamSplashMode:
- bytestreamInput.KeyCount = 62 # equal or greater than the number of DCMs for beam splashes
- bytestreamInput.BufferSize = 186 # three times of keycount for beam splashes
- bytestreamInput.Timeout = 144000000 #(40 hrs) for beam splashes
- bytestreamInput.StreamType = "physics" #if trigger fails it will go to debug_HltError
-
if partitionName != 'ATLAS':
bytestreamInput.KeyValue = [ 'Test_emon_push' ]
bytestreamInput.KeyCount = 1
-if isBeamSplashMode or HorizontalMuons_quickReco:
- # switch of the NSW segment making as it takes too much CPU in beamsplashes
- acc.getEventAlgo("MuonSegmentMaker").doStgcSegments=False;
- acc.getEventAlgo("MuonSegmentMaker").doMMSegments=False;
- acc.getEventAlgo("MuonSegmentMaker_NCB").doStgcSegments=False;
- acc.getEventAlgo("MuonSegmentMaker_NCB").doMMSegments=False;
- acc.dropEventAlgo("QuadNSW_MuonSegmentCnvAlg");
-
-onlineEventDisplaysSvc = CompFactory.OnlineEventDisplaysSvc(
- name = "OnlineEventDisplaysSvc",
- MaxEvents = maxEvents, # Number of events to keep per stream
- OutputDirectory = outputDirectory, # Base directory for streams
- SendToPublicStream = sendToPublicStream, # Allowed to be made public
- PublicStreams = publicStreams, # These streams go into public stream when Ready4Physics
- StreamsWanted = streamsWanted,
- BeamSplash = isBeamSplashMode,
-)
-acc.addService(onlineEventDisplaysSvc, create=True)
-
-def StreamToFileToolCfg(flags, name='StreamToFileTool',**kwargs):
+def StreamToFileToolCfg(flags, name="StreamToFileTool",**kwargs):
result = ComponentAccumulator()
- kwargs.setdefault("OnlineEventDisplaysSvc", acc.getService("OnlineEventDisplaysSvc"))
- kwargs.setdefault("IsOnline", True)
- the_tool = CompFactory.JiveXML.StreamToFileTool(**kwargs)
- result.setPrivateTools(the_tool)
+ # if testing and you need to see the output change below to e.g. /tmp/username
+ OutputDirectory = outputDirectory
+ prefixFileName = "%s/.Unknown/JiveXML" % outputDirectory
+ #set the StreamName as prefix
+ kwargs.setdefault("FileNamePrefix", prefixFileName)
+ the_tool = CompFactory.JiveXML.StreamToFileTool(name,**kwargs)
+ result.addPublicTool(the_tool)
return result
-streamToFileTool = acc.popToolsAndMerge(StreamToFileToolCfg(flags))
+acc.merge(StreamToFileToolCfg(flags))
-streamToServerTool = None
if not isOfflineTest:
def StreamToServerToolCfg(flags, name="StreamToServerTool",**kwargs):
result = ComponentAccumulator()
- kwargs.setdefault("OnlineEventDisplaysSvc", acc.getService("OnlineEventDisplaysSvc"))
serverService = CompFactory.JiveXML.ExternalONCRPCServerSvc(name="ExternalONCRPCServerSvc", Hostname = "pc-tdq-mon-29")
result.addService(serverService)
kwargs.setdefault("ServerService",serverService)
- kwargs.setdefault("StreamName",".Unknown")
+ kwargs.setdefault("StreamName","Unknown")
the_tool = CompFactory.JiveXML.StreamToServerTool(name,**kwargs)
- result.setPrivateTools(the_tool)
+ result.addPublicTool(the_tool)
return result
- streamToServerTool = acc.popToolsAndMerge(StreamToServerToolCfg(flags))
+ acc.merge(StreamToServerToolCfg(flags))
from JiveXML.JiveXMLConfig import AlgoJiveXMLCfg
-acc.merge(AlgoJiveXMLCfg(flags,StreamToFileTool=streamToFileTool,StreamToServerTool=streamToServerTool,OnlineMode= not isOfflineTest))
+acc.merge(AlgoJiveXMLCfg(flags))
-if isBeamSplashMode:
- acc.getPublicTool("CaloLArRetriever").LArlCellThreshold=500.;
- acc.getPublicTool("CaloHECRetriever").HEClCellThreshold=500.;
+from EventDisplaysOnline.OnlineEventDisplaysSvc import OnlineEventDisplaysSvc
+acc.addService(OnlineEventDisplaysSvc(
+ name = "OnlineEventDisplaysSvc",
+ OutputLevel = DEBUG, # Verbosity
+ MaxEvents = maxEvents, # Number of events to keep per stream
+ OutputDirectory = outputDirectory, # Base directory for streams
+ ProjectTags = projectTags, # Project tags that are allowed to be made public
+ Public = publicStreams, # These streams go into public stream when Ready4Physics
-# This creates an ESD file per event which is renamed and moved to the desired output
-# dir in the VP1 Event Prod alg
-from AthenaServices.OutputStreamSequencerSvcConfig import OutputStreamSequencerSvcCfg
-acc.merge(OutputStreamSequencerSvcCfg(flags,incidentName="EndEvent"))
+), create=True)
StreamESD = acc.getEventAlgo("OutputStreamESD")
-vp1Alg = CompFactory.VP1EventProd(name="VP1EventProd",
- InputPoolFile = StreamESD.OutputFile,
- IsOnline = True,
- MaxNumberOfFiles = -1,
- OnlineEventDisplaysSvc = onlineEventDisplaysSvc)
-acc.addEventAlgo(vp1Alg, primary=True)
+vp1Alg = CompFactory.VP1EventProd(name="VP1EventProd", InputPoolFile = StreamESD.OutputFile)
+acc.addEventAlgo(vp1Alg)
acc.getService("PoolSvc").WriteCatalog = "xmlcatalog_file:PoolFileCatalog_%s_%s.xml" % (jobId[3], jobId[4])
##----------------------------------------------------------------------##
-## Need line below to fix error that occurs when trying to ##
+## Neeed line below to fix error that occurs when trying to ##
## get CaloRec::ToolConstants/H1WeightsCone4Topo DataObject ##
##----------------------------------------------------------------------##
acc.getService("PoolSvc").ReadCatalog += ["xmlcatalog_file:/det/dqm/GlobalMonitoring/PoolFileCatalog_M7/PoolFileCatalog.xml"]
diff --git a/graphics/EventDisplaysOnline/python/OnlineEventDisplaysSvc.py b/graphics/EventDisplaysOnline/python/OnlineEventDisplaysSvc.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa1cccd010385913707bbbf1d940cf699c8023fe
--- /dev/null
+++ b/graphics/EventDisplaysOnline/python/OnlineEventDisplaysSvc.py
@@ -0,0 +1,215 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+__doc__ = """This service runs in the online Athena event display threads. It
+manages the distribution of incoming events to the right event display streams.
+In order to do that it connects to the different Atlantis and VP1 event output
+algorithms/tools and manipulates their job options during the run.
+"""
+__version__ = "0.1"
+__author__ = "Eric Jansen <eric.jansen@cern.ch>"
+
+import os, grp, stat, random
+from ipc import IPCPartition
+from ispy import ISInfoDictionary, ISInfoAny, ISObject
+from AthenaPython import PyAthena
+from AthenaPython.PyAthena import StatusCode
+from PyAnalysisCore import PyEventTools
+from EventDisplaysOnline import EventUtils
+
+class OnlineEventDisplaysSvc( PyAthena.Svc ):
+
+ def __init__(self, name = 'OnlineEventDisplaysSvc', **kw):
+ kw['name'] = name
+ self.output = kw.get('OutputDirectory')
+ self.maxevents = kw.get('MaxEvents')
+ self.public = kw.get('Public')
+ self.projecttags = kw.get('ProjectTags')
+
+ self.zpgid = None
+ self.partition = None
+
+ self.StreamToFileTool = None
+ self.StreamToServerTool = None
+ self.VP1EventProducer = None
+
+ self.run = 0
+ self.event = 0
+ self.stream = ''
+ self.directory = ''
+
+ super(OnlineEventDisplaysSvc,self).__init__(**kw)
+
+ def initialize(self):
+ incidentSvc = PyAthena.py_svc('IncidentSvc', iface='IIncidentSvc')
+ incidentSvc.addListener(self, 'BeginEvent')
+ incidentSvc.addListener(self, 'StoreCleared')
+
+ self.partition = IPCPartition('ATLAS')
+ self.dict = ISInfoDictionary(self.partition)
+ self.zpgid = grp.getgrnam("zp").gr_gid
+ return StatusCode.Success
+
+ def finalize(self):
+ return StatusCode.Success
+
+ def getJobOptions(self):
+ self.StreamToFileTool = PyAthena.py_tool('JiveXML::StreamToFileTool', iface='IProperty')
+ self.StreamToServerTool = PyAthena.py_tool('JiveXML::StreamToServerTool', iface='IProperty')
+
+ # Some casting magic is needed to access algorithm properties
+ from GaudiPython.Bindings import gbl, InterfaceCast
+ vp1alg = PyAthena.py_alg('VP1EventProd')
+ self.VP1EventProducer = InterfaceCast(gbl.IProperty).cast(vp1alg)
+
+ self.msg.info("StreamToFileTool: %s", self.StreamToFileTool)
+ self.msg.info("StreamToServerTool: %s", self.StreamToServerTool)
+ self.msg.info("VP1EventProducer: %s", self.VP1EventProducer)
+
+ def beginEvent(self):
+ if not (self.StreamToFileTool and self.StreamToServerTool and self.VP1EventProducer):
+ self.getJobOptions()
+
+ try:
+ eventInfo = PyEventTools.getEventInfo('EventInfo')
+ except LookupError as err:
+ self.msg.error("Could not retrieve EventInfo: %s", err)
+ return StatusCode.Recoverable
+
+ try:
+ # Read event info
+ self.run = eventInfo.runNumber()
+ self.event = eventInfo.eventNumber()
+
+ # Retrieve trigger info
+ streamTags = eventInfo.streamTags()
+ except Exception as err:
+ self.msg.error("Exception occured while reading event/trigger info: %s", err)
+ return StatusCode.Recoverable
+
+ # Retrieve the physics stream names from the trigger info
+ streams = []
+ for tag in streamTags:
+
+ ## Added 08/03/15 - sjiggins - Wanted to see if events had physics stream tag or was from random trigger
+ if tag.name():
+ self.msg.debug("Event %d/%d has the corresponding streamTags: %s", self.run, self.event, tag.type())
+ ##################################################################################
+ if tag.type() == 'express' and tag.name():
+ streams += [tag.type()+'_'+tag.name()]
+
+ if tag.type() == 'physics' and tag.name():
+ streams += [tag.type()+'_'+tag.name()]
+
+ # Add special streams to the list Public
+ """
+ try:
+ for stream in streams:
+ if stream in self.public:
+ ready4physics = ISInfoAny()
+ self.dict.getValue('RunParams.Ready4Physics', ready4physics)
+ print("Ready for physics: %s " % ready4physics.get())
+ runparams = ISObject(self.partition, 'RunParams.RunParams','RunParams')
+ runparams.checkout()
+ physicsReady = ISObject(self.partition, 'RunParams.Ready4Physics','Ready4PhysicsInfo')
+ physicsReady.checkout()
+ print("Ready for physics: %r" % (physicsReady.ready4physics))
+ #if ready4physics.get() and physicsReady.ready4physics and runparams.T0_project_tag in self.projecttags:
+ if physicsReady.ready4physics and runparams.T0_project_tag in self.projecttags:
+ streams += ['Public']
+ else:
+ self.msg.debug("RunParams.Ready4Physics is not set, run number is not set, or T0_project_tag is not set to any of %s", ", ".join(self.projecttags))
+ break
+ except Exception as err:
+ self.msg.error("Exception occured while reading RunParams.Ready4Physics: %s", err)
+ """
+ # Randomize list of streams
+ random.shuffle(streams)
+ self.msg.debug("Event %d/%d has event display stream tags: %s", self.run, self.event, ", ".join(streams))
+
+ ## for beam splash, give priority to MinBias
+ #if 'physics_MinBias' in streams:
+ # streams = ['physics_MinBias']
+ # self.msg.debug("Modified stream tag: %s", ", ".join(streams))
+
+ # Start from the beginning and send the event to the first stream that passes our directory checks
+ self.directory = ''
+ for self.stream in streams:
+ self.directory = "%s/%s" % (self.output, self.stream)
+ if os.access(self.directory, os.F_OK):
+ if os.path.isdir(self.directory) and os.access(self.directory, os.W_OK):
+ self.msg.debug("Going to write file to existing directory: %s", self.directory)
+ if os.stat(self.directory).st_gid != self.zpgid:
+ self.msg.debug("Setting group to 'zp' for directory: %s", self.directory)
+ os.chown(self.directory, -1, self.zpgid)
+ break
+ else:
+ self.msg.warning("Directory \'%s\' is not usable, trying next alternative", self.directory)
+ self.directory = ''
+ else:
+ try:
+ os.mkdir(self.directory)
+ os.chmod(self.directory, stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH)
+ os.chown(self.directory, -1, self.zpgid)
+ self.msg.info("Created output directory \'%s\' for stream \'%s\'", self.directory, self.stream)
+ break
+ except OSError as err:
+ self.msg.warning("Failed to create output directory \'%s\' for stream \'%s\': %s", (self.directory, self.stream, err.strerror))
+ self.directory = ''
+
+ # Check if a suitable directory was found
+ if self.directory:
+ self.msg.debug("Event %d/%d will be streamed to: %s", self.run, self.event, self.stream)
+ self.msg.debug("Directory: %s", self.directory)
+ else:
+ # This event is hopelessly lost, send StatusCode.Recoverable in an attempt to abort.
+ # But if Athena chooses to ignore that, set the output to the "Unknown" trashcan stream.
+ self.stream = 'Unknown'
+ self.directory = "%s/.Unknown" % self.output
+ try:
+ # Set output stream for JiveXML event streaming (file and server)
+ self.StreamToServerTool.getProperty('StreamName').setValue("%s" % self.stream)
+ self.StreamToFileTool.getProperty('FileNamePrefix').setValue("%s/JiveXML" % self.directory)
+ self.msg.debug("Directory in try: %s", self.directory)
+ except Exception as err:
+ self.msg.error("Exception occured while setting job options: %s", err)
+ return StatusCode.Failure
+
+ if not self.directory:
+ return StatusCode.Recoverable
+
+ def endEvent(self):
+ # VP1 copied its ESD file of the previous event to the destination directory.
+ # So we set the directory of the current event in endEvent to pass it to the next event.
+ if self.VP1EventProducer:
+ self.VP1EventProducer.getProperty('DestinationDirectory').setValue(self.directory)
+
+ # Prune events and make index file for atlas-live.cern.ch
+ if self.directory:
+ # If VP1 event producer is missing, skip the pair check to make cleanup/sync work
+ if self.VP1EventProducer:
+ EventUtils.cleanDirectory(self.msg, self.directory, self.maxevents, checkpair=True)
+ else:
+ EventUtils.cleanDirectory(self.msg, self.directory, self.maxevents, checkpair=False)
+
+ ## for beam splashes, disable prepareFilesForTransfer() in EventUtils.py
+ ## Activate these lines to zip and transfer every JiveXML file.
+ #event = "%05d" % int(self.event)
+ #EventUtils.zipXMLFile(self.msg, self.directory, f'JiveXML_{self.run}_{event}.xml')
+
+ # And cleanup the variables
+ self.run = 0
+ self.event = 0
+ self.stream = ''
+ self.directory = ''
+
+ def handle(self, incident):
+ self.msg.verbose("Received incident %s from %s" % (incident.type(), incident.source()))
+
+ # Event and trigger info present, decide stream
+ if incident.type() == 'BeginEvent' and incident.source() == 'BeginIncFiringAlg':
+ self.beginEvent()
+
+ # VP1 writes its file at EndEvent, so we can do cleanup at StoreCleared
+ if incident.type() == 'StoreCleared' and incident.source() == 'StoreGateSvc':
+ self.endEvent()
+
diff --git a/graphics/JiveXML/JiveXML/AlgoJiveXML.h b/graphics/JiveXML/JiveXML/AlgoJiveXML.h
index 9416c0f6becfa98966a9dcc075ba671fc71b11dd..de5b07159a10c1505a4339aa1ff60534e5f0269a 100755
--- a/graphics/JiveXML/JiveXML/AlgoJiveXML.h
+++ b/graphics/JiveXML/JiveXML/AlgoJiveXML.h
@@ -42,32 +42,42 @@ namespace JiveXML {
StatusCode finalize();
private:
+ StatusCode chooseStream(const std::vector< xAOD::EventInfo::StreamTag >);
+
+ //Configurable properties
+ Gaudi::Property<bool> m_wantPublicStreams {this, "WantPublicStreams", false, "If running online, is the Public stream wanted."};
+ Gaudi::Property<bool> m_wantCalibrationStreams {this, "WantCalibrationStreams", false, "If running online, are the calibration streams wanted."};
+ Gaudi::Property<bool> m_wantMonitoringStreams {this, "WantMonitoringStreams", false, "If running online, are the monitoring streams wanted."};
+ Gaudi::Property<bool> m_wantPhysicsStreams {this, "WantPhysicsStreams", true, "If running online, are the physics streams wanted."};
+
Gaudi::Property<std::string> m_AtlasRelease {this, "AtlasRelease", "unknown", "The Athena release number"};
Gaudi::Property<std::vector<std::string>> m_dataTypes {this, "DataTypes", {}, "List of data retriever names to be run"};
Gaudi::Property<bool> m_writeToFile {this, "WriteToFile", true, "Whether XML files shall be produced"};
Gaudi::Property<bool> m_onlineMode {this, "OnlineMode", false, "Whether an XMLRPC server shall be started"};
Gaudi::Property<bool> m_writeGeometry {this, "WriteGeometry", false, "Whether Geometry-XML files shall be produced"};
Gaudi::Property<std::string> m_geometryVersionIn {this, "GeometryVersion", "default", "Geometry version as read from Athena"};
- Gaudi::Property<std::vector<std::string>> m_GeoWriterNames {this, "GeoWriterNames", {"JiveXML::GeometryWriter/GeometryWriter","JiveXML::MuonGeometryWriter/MuonGeometryWriter"}, "The names of the geometry-writer tools"};
- /**
- * The list of DataRetrievers. This is initialised using the list of names
- * supplied by the jobOptions. DataRetrievers are AlgTools residing in the
- * corresponding sub-detector packages (e.g. TrackRetriever in InDetJiveXML).
- **/
- ToolHandleArray<JiveXML::IDataRetriever> m_DataRetrievers;
+ Gaudi::Property<std::vector<std::string>> m_GeoWriterNames {this, "GeoWriterNames", {"JiveXML::GeometryWriter/GeometryWriter","JiveXML::MuonGeometryWriter/MuonGeometryWriter"}, "The names of the geometry-writer tools"};
+
+ protected:
- /**
- * Handle to the formatting tool, which is passed on to
- * the data retrievers and converts the data into XML
- **/
- ToolHandle<JiveXML::IFormatTool> m_FormatTool {this, "FormatTool", "JiveXML::XMLFormatTool/XMLFormatTool", "Format tool"};
+ /**
+ * The list of DataRetrievers. This is initialised using the list of names
+ * supplied by the jobOptions. DataRetrievers are AlgTools residing in the
+ * corresponding sub-detector packages (e.g. TrackRetriever in InDetJiveXML).
+ **/
+ ToolHandleArray<JiveXML::IDataRetriever> m_DataRetrievers;
+
+ /**
+ * Handle to the formatting tool, which is passed on to
+ * the data retrievers and converts the data into XML
+ **/
+ ToolHandle<JiveXML::IFormatTool> m_FormatTool;
- /**
- * Streaming tools that pass the formatted XML text
- * into a file, to a server, etc.
- **/
- ToolHandle<JiveXML::IStreamTool> m_StreamToFileTool {this, "StreamToFileTool", "JiveXML::StreamToFileTool", "Stream to file tool"};
- ToolHandle<JiveXML::IStreamTool> m_StreamToServerTool {this, "StreamToServerTool", "JiveXML::StreamToServerTool", "Stream to server tool"};
+ /**
+ * List of streaming tools that pass the formatted XML text
+ * into a file, to a server, etc.
+ **/
+ ToolHandleArray<JiveXML::IStreamTool> m_StreamTools;
};
diff --git a/graphics/JiveXML/JiveXML/StreamToFileTool.h b/graphics/JiveXML/JiveXML/StreamToFileTool.h
index a4ed1c52ed4c38f3f4ff72deb2da278274cbe85c..0c197307c3f7f7e86fc2ccb04f95e99527cbb654 100644
--- a/graphics/JiveXML/JiveXML/StreamToFileTool.h
+++ b/graphics/JiveXML/JiveXML/StreamToFileTool.h
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef JIVEXML__STREAMTOFILETOOL_H
@@ -8,8 +8,6 @@
//IAlgTool interface
#include "JiveXML/IStreamTool.h"
#include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "EventDisplaysOnline/IOnlineEventDisplaysSvc.h"
namespace JiveXML {
@@ -19,7 +17,7 @@ namespace JiveXML {
*
* @author Sebastian Boeser
*/
- class StreamToFileTool : virtual public IStreamTool, public AthAlgTool {
+ class StreamToFileTool : virtual public IStreamTool, public AthAlgTool{
public:
@@ -37,24 +35,21 @@ namespace JiveXML {
private:
- ServiceHandle<IOnlineEventDisplaysSvc> m_onlineEDsvc{this, "OnlineEventDisplaysSvc", "Online Event Displays Service"};
-
- Gaudi::Property<bool> m_isOnline {this, "IsOnline", false, "If running at point 1"};
-
- /** Prefix put in front of JiveXML file name */
- std::string m_FileNamePrefix;
+ Gaudi::Property<std::string> m_mytest {this, "MyTest", "", "My test"};
+ /** Prefix put in front of file name */
+ std::string m_FileNamePrefix;
- /** Suffix put at the end of the file name (including type)*/
- std::string m_FileNameSuffix;
+ /** Suffix put at the end of the file name (including type)*/
+ std::string m_FileNameSuffix;
- /** Generate a file name */
- std::string MakeFileName( const unsigned long EventNumber, const unsigned int RunNumber ) const;
+ /** Generate a file name */
+ std::string MakeFileName( const unsigned long EventNumber, const unsigned int RunNumber ) const;
- /** Creates a new output stream to write XML to */
- StatusCode NewFile( const unsigned long EventNumber, const unsigned int RunNumber, std::ofstream *& outFile ) const ;
+ /** Creates a new output stream to write XML to */
+ StatusCode NewFile( const unsigned long EventNumber, const unsigned int RunNumber, std::ofstream *& outFile ) const ;
- /** Closes output stream */
- StatusCode CloseFile( std::ofstream *& outFile ) const ;
+ /** Closes output stream */
+ StatusCode CloseFile( std::ofstream *& outFile ) const ;
};
diff --git a/graphics/JiveXML/python/JiveXMLConfig.py b/graphics/JiveXML/python/JiveXMLConfig.py
index c5f3d10afd136e128a7fd23942666f9434acf814..c1421b4051a5e4453fe2c88018ef157e1a57c949 100644
--- a/graphics/JiveXML/python/JiveXMLConfig.py
+++ b/graphics/JiveXML/python/JiveXMLConfig.py
@@ -4,7 +4,6 @@ from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.Enums import Format
-
def getATLASVersion():
import os
@@ -19,21 +18,20 @@ def getDataTypes(flags, haveRDO=False, readAOD=False):
data_types = [] # These need to match the tools added later
if flags.Detector.EnableID:
# General ID types
- if flags.Detector.GeometryPixel and flags.Detector.GeometrySCT:
- data_types += ["JiveXML::SiSpacePointRetriever/SiSpacePointRetriever"]
- data_types += ["JiveXML::SiClusterRetriever/SiClusterRetriever"]
+ data_types += ["JiveXML::SiSpacePointRetriever/SiSpacePointRetriever"]
+ data_types += ["JiveXML::SiClusterRetriever/SiClusterRetriever"]
data_types += ["JiveXML::VertexRetriever/VertexRetriever"]
# These options will retrieve any available collection of segments/tracks from storegate
data_types += ["JiveXML::SegmentRetriever/SegmentRetriever"]
data_types += ["JiveXML::TrackRetriever/TrackRetriever"]
- if flags.Detector.EnablePixel and flags.Detector.GeometryPixel:
+ if flags.Detector.EnablePixel:
data_types += ["JiveXML::PixelClusterRetriever/PixelClusterRetriever"]
if haveRDO:
data_types += ["JiveXML::PixelRDORetriever/PixelRDORetriever"]
- if flags.Detector.EnableTRT and flags.Detector.GeometryTRT:
+ if flags.Detector.EnableTRT:
data_types += ["JiveXML::TRTRetriever/TRTRetriever"]
- if haveRDO and flags.Detector.EnableSCT and flags.Detector.GeometrySCT:
+ if haveRDO and flags.Detector.EnableSCT:
data_types += ["JiveXML::SCTRDORetriever/SCTRDORetriever"]
# TODO this datatype is not yet understood by Atlantis
@@ -44,36 +42,34 @@ def getDataTypes(flags, haveRDO=False, readAOD=False):
data_types += ["JiveXML::TruthTrackRetriever/TruthTrackRetriever"]
data_types += ["JiveXML::TruthMuonTrackRetriever/TruthMuonTrackRetriever"]
- if flags.Detector.EnableCalo and flags.Detector.GeometryCalo:
+ if flags.Detector.EnableCalo:
# Taken from CaloJiveXML_DataTypes.py
# TODO find correct flag and check the LArDigitRetriever is doing what we want it to do
#if doLArDigits:
- #data_types += ["JiveXML::LArDigitRetriever/LArDigitRetriever"]
+ # data_types += ["JiveXML::LArDigitRetriever/LArDigitRetriever"]
#else:
- if flags.Detector.EnableLAr and flags.Detector.GeometryLAr:
- data_types += ["JiveXML::CaloFCalRetriever/CaloFCalRetriever"]
- data_types += ["JiveXML::CaloHECRetriever/CaloHECRetriever"]
- data_types += ["JiveXML::CaloLArRetriever/CaloLArRetriever"]
+ data_types += ["JiveXML::CaloFCalRetriever/CaloFCalRetriever"]
+ data_types += ["JiveXML::CaloLArRetriever/CaloLArRetriever"]
+ data_types += ["JiveXML::CaloHECRetriever/CaloHECRetriever"]
#end of else
- if flags.Detector.EnableMBTS and flags.Detector.GeometryMBTS:
- data_types += ["JiveXML::CaloMBTSRetriever/CaloMBTSRetriever"]
- if flags.Detector.EnableTile and flags.Detector.GeometryTile:
- data_types += ["JiveXML::CaloTileRetriever/CaloTileRetriever"]
+ data_types += ["JiveXML::CaloMBTSRetriever/CaloMBTSRetriever"]
+ data_types += ["JiveXML::CaloTileRetriever/CaloTileRetriever"]
data_types += ["JiveXML::CaloClusterRetriever/CaloClusterRetriever"]
- if flags.Detector.EnableMuon and flags.Detector.GeometryMuon:
+ if flags.Detector.EnableMuon:
# Taken from MuonJiveXML_DataTypes.py
- if flags.Detector.EnableMDT and flags.Detector.GeometryMDT:
+ if flags.Detector.EnableMDT:
data_types += ["JiveXML::MdtPrepDataRetriever/MdtPrepDataRetriever"]
- if flags.Detector.EnableTGC and flags.Detector.GeometryTGC:
+ if flags.Detector.EnableTGC:
data_types += ["JiveXML::TgcPrepDataRetriever/TgcPrepDataRetriever"]
- data_types += ["JiveXML::sTgcPrepDataRetriever/sTgcPrepDataRetriever"]
- if flags.Detector.EnableRPC and flags.Detector.GeometryRPC:
+ if flags.Detector.EnableRPC:
data_types += ["JiveXML::RpcPrepDataRetriever/RpcPrepDataRetriever"]
- if flags.Detector.EnableCSC and flags.Detector.GeometryCSC:
+ if flags.Detector.EnableCSC:
data_types += ["JiveXML::CSCClusterRetriever/CSCClusterRetriever"]
data_types += ["JiveXML::CscPrepDataRetriever/CscPrepDataRetriever"]
- if flags.Detector.EnableMM and flags.Detector.GeometryMM:
+ if flags.Detector.EnablesTGC:
+ data_types += ["JiveXML::sTgcPrepDataRetriever/sTgcPrepDataRetriever"]
+ if flags.Detector.EnableMM:
data_types += ["JiveXML::MMPrepDataRetriever/MMPrepDataRetriever"]
# TODO Not sure if below are still needed?
# data_types += ["JiveXML::TrigMuonROIRetriever/TrigMuonROIRetriever"]
@@ -107,16 +103,15 @@ def InDetRetrieversCfg(flags):
result = ComponentAccumulator()
# Do we need to add equivalent of InDetFlags.doSlimming=False (in JiveXML_RecEx_config.py)? If so, why?
# Following is based on InDetJiveXML_DataTypes.py and TrkJiveXML_DataTypes.py
- if flags.Detector.EnablePixel and flags.Detector.GeometryPixel:
+ if flags.Detector.EnablePixel:
result.merge(PixelClusterRetrieverCfg(flags))
- if flags.Detector.EnableID and flags.Detector.GeometryID:
- if flags.Detector.GeometryPixel and flags.Detector.GeometrySCT:
- result.merge(SiClusterRetrieverCfg(flags))
- result.merge(SiSpacePointRetrieverCfg(flags))
+ if flags.Detector.EnableID:
+ result.merge(SiClusterRetrieverCfg(flags))
+ result.merge(SiSpacePointRetrieverCfg(flags))
result.merge(TrackRetrieverCfg(flags))
- if flags.Detector.EnableTRT and flags.Detector.GeometryTRT:
+ if flags.Detector.EnableTRT:
result.merge(TRTRetrieverCfg(flags))
result.merge(BeamSpotRetrieverCfg(flags))
@@ -182,6 +177,11 @@ def TrackRetrieverCfg(flags, name="TrackRetriever", **kwargs):
# kwargs.setdefault("DoWriteHLT", True)
### switch residual data off:
kwargs.setdefault("DoWriteResiduals", False)
+ if flags.Common.isOnline:
+ doHitsDetails = False
+ else:
+ doHitsDetails = True
+ kwargs.setdefault("DoHitsDetails", doHitsDetails)
the_tool = CompFactory.JiveXML.TrackRetriever(name, **kwargs)
result.addPublicTool(the_tool)
return result
@@ -213,128 +213,95 @@ def CaloRetrieversCfg(flags, **kwargs):
from LArRecUtils.LArADC2MeVCondAlgConfig import LArADC2MeVCondAlgCfg
result.merge(LArADC2MeVCondAlgCfg (flags))
- from AthenaConfiguration.Enums import Format
- if flags.Input.Format is Format.BS:
- tileDigitsContainer = "TileDigitsCnt"
-
- if flags.Tile.doOpt2:
- tileRawChannelContainer = 'TileRawChannelOpt2'
- elif flags.Tile.doOptATLAS:
- tileRawChannelContainer = 'TileRawChannelFixed'
- elif flags.Tile.doFitCOOL:
- tileRawChannelContainer = 'TileRawChannelFitCool'
- elif flags.Tile.doFit:
- tileRawChannelContainer = 'TileRawChannelFit'
- else:
- tileRawChannelContainer = 'TileRawChannelCnt'
-
- else:
- if "TileDigitsCnt" in flags.Input.Collections:
- tileDigitsContainer = "TileDigitsCnt"
- elif "TileDigitsFlt" in flags.Input.Collections:
- tileDigitsContainer = "TileDigitsFlt"
-
- if "TileRawChannelOpt2" in flags.Input.Collections:
- tileRawChannelContainer = 'TileRawChannelOpt2'
- elif "TileRawChannelFitCool" in flags.Input.Collections:
- tileRawChannelContainer = 'TileRawChannelFitCool'
- elif "TileRawChannelFit" in flags.Input.Collections:
- tileRawChannelContainer = 'TileRawChannelFit'
- elif "TileRawChannelCnt" in flags.Input.Collections:
- tileRawChannelContainer = 'TileRawChannelCnt'
-
- from CaloJiveXML.CaloJiveXMLConf import JiveXML__LArDigitRetriever
- theLArDigitRetriever = JiveXML__LArDigitRetriever(name="LArDigitRetriever")
- theLArDigitRetriever.DoLArDigit = False
- theLArDigitRetriever.DoHECDigit = False
- theLArDigitRetriever.DoFCalDigit = False
-
- if (theLArDigitRetriever.DoLArDigit or theLArDigitRetriever.DoHECDigit or theLArDigitRetriever.DoFCalDigit):
- result.addPublicTool(
- CompFactory.JiveXML.LArDigitRetriever(
- name="LArDigitRetriever",
- DoLArDigit=False,
- DoHECDigit=False,
- DoFCalDigit=False,
- )
- )
-
- else:
- result.addPublicTool(
- CompFactory.JiveXML.CaloFCalRetriever(
- name="CaloFCalRetriever",
- DoFCalCellDetails=False,
- DoBadFCal=False,
- )
- )
-
- result.addPublicTool(
- CompFactory.JiveXML.CaloLArRetriever(
- name="CaloLArRetriever",
- DoLArCellDetails=False,
- DoBadLAr=False,
- )
- )
-
- result.addPublicTool(
- CompFactory.JiveXML.CaloHECRetriever(
- name="CaloHECRetriever",
- DoHECCellDetails=False,
- DoBadHEC=False,
- )
- )
+ rawChannelContainer = flags.Tile.RawChannelContainer
+ digitsContainer = "TileDigitsCnt"
+ if "TileDigitsFlt" in flags.Input.Collections:
+ digitsContainer = "TileDigitsFlt"
result.addPublicTool(
CompFactory.JiveXML.CaloClusterRetriever(name = "CaloClusterRetriever",**kwargs
)
)
+ if flags.Common.isOnline:
+ doTileCellDetails = True
+ doTileDigit = True
+ else:
+ doTileCellDetails = False
+ doTileDigit = False
result.addPublicTool(
CompFactory.JiveXML.CaloTileRetriever(
name = "CaloTileRetriever",
- TileDigitsContainer = tileDigitsContainer,
- TileRawChannelContainer = tileRawChannelContainer,
- DoTileCellDetails = False,
- DoTileDigit = False,
+ TileDigitsContainer = digitsContainer,
+ TileRawChannelContainer = rawChannelContainer,
+ DoTileCellDetails = doTileCellDetails,
+ DoTileDigit = doTileDigit,
DoBadTile = False,
)
)
+ if flags.Common.isOnline:
+ doMBTSDigits = True
+ doMBTSCellDetails = True
+ else:
+ doMBTSDigits = False
+ doMBTSCellDetails = False
+
result.addPublicTool(
CompFactory.JiveXML.CaloMBTSRetriever(
name = "CaloMBTSRetriever",
- TileDigitsContainer= tileDigitsContainer,
- TileRawChannelContainer = tileRawChannelContainer,
- DoMBTSDigits = False,
+ TileDigitsContainer= digitsContainer,
+ TileRawChannelContainer = rawChannelContainer,
+ DoMBTSDigits = doMBTSDigits,
+ DoMBTSCellDetails = doMBTSCellDetails,
+ )
+ )
+
+ result.addPublicTool(
+ CompFactory.JiveXML.CaloFCalRetriever(
+ name = "CaloFCalRetriever",
+ DoFCalCellDetails = False,
+ DoBadFCal = False,
+ )
+ )
+
+ result.addPublicTool(
+ CompFactory.JiveXML.CaloLArRetriever(
+ name = "CaloLArRetriever",
+ DoLArCellDetails = False,
+ DoBadLAr = False,
+ )
+ )
+
+ result.addPublicTool(
+ CompFactory.JiveXML.CaloHECRetriever(
+ name = "CaloHECRetriever",
+ DoHECCellDetails = False,
+ DoBadHEC = False,
)
)
+ result.addPublicTool(
+ CompFactory.JiveXML.LArDigitRetriever(
+ name = "LArDigitRetriever",
+ DoLArDigit = False,
+ DoHECDigit = False,
+ DoFCalDigit = False,
+ )
+ )
return result
def MuonRetrieversCfg(flags, **kwargs):
result = ComponentAccumulator()
+ # TODO add in other retrievers
+ # Based on MuonJiveXML_DataTypes.py
#kwargs.setdefault("StoreGateKey", "MDT_DriftCircles")
- if flags.Detector.EnableMuon and flags.Detector.GeometryMuon:
- # Taken from MuonJiveXML_DataTypes.py
- if flags.Detector.EnableMDT and flags.Detector.GeometryMDT:
- result.addPublicTool(CompFactory.JiveXML.MdtPrepDataRetriever(name="MdtPrepDataRetriever"), **kwargs)
- if flags.Detector.EnableTGC and flags.Detector.GeometryTGC:
- result.addPublicTool(CompFactory.JiveXML.TgcPrepDataRetriever(name="TgcPrepDataRetriever"), **kwargs)
- result.addPublicTool(CompFactory.JiveXML.sTgcPrepDataRetriever(name="sTgcPrepDataRetriever"), **kwargs)
- if flags.Detector.EnableRPC and flags.Detector.GeometryRPC:
- result.addPublicTool(CompFactory.JiveXML.RpcPrepDataRetriever(name="RpcPrepDataRetriever"), **kwargs)
- if flags.Detector.EnableCSC and flags.Detector.GeometryCSC:
- result.addPublicTool(CompFactory.JiveXML.CSCClusterRetriever(name="CSCClusterRetriever"), **kwargs)
- result.addPublicTool(CompFactory.JiveXML.CscPrepDataRetriever(name="CscPrepDataRetriever"), **kwargs)
- if flags.Detector.EnableMM and flags.Detector.GeometryMM:
- result.addPublicTool(CompFactory.JiveXML.MMPrepDataRetriever(name="MMPrepDataRetriever"), **kwargs)
- # TODO Not sure if below are still needed?
- # data_types += ["JiveXML::TrigMuonROIRetriever/TrigMuonROIRetriever"]
- # data_types += ["JiveXML::MuidTrackRetriever/MuidTrackRetriever]
- # data_types += ["JiveXML::TrigRpcDataRetriever/TrigRpcDataRetriever"]
-
+ result.addPublicTool(
+ CompFactory.JiveXML.MdtPrepDataRetriever(name = "MdtPrepDataRetriever",**kwargs
+ )
+ )
return result
@@ -417,6 +384,7 @@ def xAODRetrieversCfg(flags):
)
return result
+
def TriggerRetrieversCfg(flags):
result = ComponentAccumulator()
if flags.Reco.EnableTrigger:
@@ -460,7 +428,8 @@ def TriggerRetrieversCfg(flags):
)
return result
-def AlgoJiveXMLCfg(flags, name="MuonCombinePatternTool", **kwargs):
+
+def AlgoJiveXMLCfg(flags, name="AlgoJiveXML", **kwargs):
# This is based on a few old-style configuation files:
# JiveXML_RecEx_config.py
# JiveXML_jobOptionBase.py
@@ -468,8 +437,12 @@ def AlgoJiveXMLCfg(flags, name="MuonCombinePatternTool", **kwargs):
kwargs.setdefault("AtlasRelease", getATLASVersion())
kwargs.setdefault("WriteToFile", True)
- ### Enable this to recreate the geometry XML files for Atlantis
+ # Enable this to recreate the geometry XML files for Atlantis
kwargs.setdefault("WriteGeometry", False)
+ if flags.Common.isOnline:
+ kwargs.setdefault("OnlineMode", True)
+ else:
+ kwargs.setdefault("OnlineMode", False)
# This next bit sets the data types, then we set the associated public tools
readAOD = False # FIXME - set this properly
@@ -483,13 +456,13 @@ def AlgoJiveXMLCfg(flags, name="MuonCombinePatternTool", **kwargs):
result.merge(TruthTrackRetrieverCfg(flags))
if haveRDO or readESD:
- if flags.Detector.EnableID and flags.Detector.GeometryID:
+ if flags.Detector.EnableID:
result.merge(InDetRetrieversCfg(flags))
- if flags.Detector.EnableCalo and flags.Detector.GeometryCalo:
+ if flags.Detector.EnableCalo:
result.merge(CaloRetrieversCfg(flags))
- if flags.Detector.EnableMuon and flags.Detector.GeometryMuon:
+ if flags.Detector.EnableMuon:
result.merge(MuonRetrieversCfg(flags))
result.merge(xAODRetrieversCfg(flags))
@@ -498,4 +471,6 @@ def AlgoJiveXMLCfg(flags, name="MuonCombinePatternTool", **kwargs):
the_alg = CompFactory.JiveXML.AlgoJiveXML(name="AlgoJiveXML", **kwargs)
result.addEventAlgo(the_alg, primary=True)
+
+
return result
diff --git a/graphics/JiveXML/src/AlgoJiveXML.cxx b/graphics/JiveXML/src/AlgoJiveXML.cxx
index be39b369814a71364c84aaa2a635dc7fa029204e..33f0fad4bb8968a8753e0209b8b762d2f1b8190a 100755
--- a/graphics/JiveXML/src/AlgoJiveXML.cxx
+++ b/graphics/JiveXML/src/AlgoJiveXML.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
#include "JiveXML/AlgoJiveXML.h"
@@ -19,7 +19,17 @@
namespace JiveXML{
AlgoJiveXML::AlgoJiveXML(const std::string& name, ISvcLocator* pSvcLocator) :
- AthAlgorithm(name, pSvcLocator) {}
+ AthAlgorithm(name, pSvcLocator) {
+
+ //Array of tools that retrieve the data, set public and createIf as default
+ declareProperty("DataRetrievers", m_DataRetrievers = ToolHandleArray<IDataRetriever>( NULL ,true));
+
+ //Generate XMLFormatTool as default privat format tool
+ declareProperty("FormatTool", m_FormatTool = ToolHandle<IFormatTool>("JiveXML::XMLFormatTool/XMLFormatTool",this));
+
+ //Array of tools for streaming events, set public and createIf as default
+ declareProperty("StreamTools", m_StreamTools = ToolHandleArray<IStreamTool>(NULL,true));
+ }
/**
* Initialize - called once in the beginning
@@ -27,7 +37,8 @@ namespace JiveXML{
* - Get GeometryWriters and write geometry if asked for
* - Get the formatting tool
* - Get the data retrievers
- * - Get the streaming tools, including defaults if asked for */
+ * - Get the streaming tools, including defaults if asked for
+ */
StatusCode AlgoJiveXML::initialize(){
//be verbose
@@ -80,15 +91,23 @@ namespace JiveXML{
*/
ATH_MSG_DEBUG("Retrieving streaming tools");
if (m_writeToFile){
- ATH_MSG_INFO("Retrieving default file streaming tool");
- ATH_CHECK(m_StreamToFileTool.retrieve());
+ ATH_MSG_INFO("Adding default file streaming tool");
+ m_StreamTools.push_back("JiveXML::StreamToFileTool/StreamToFileTool");
}
/// Get the streaming tools
if (m_onlineMode == true){
- ATH_MSG_INFO("Retrieving default server streaming tool");
- ATH_CHECK(m_StreamToFileTool.retrieve());
+ m_StreamTools.push_back("JiveXML::StreamToServerTool/StreamToServerTool");
}
+ if (m_StreamTools.size() == 0) {
+ ATH_MSG_WARNING("No streaming tools defined, events will be created but not stored!");
+ } else {
+ if (m_StreamTools.retrieve().isFailure()){
+ ATH_MSG_ERROR("Unable to retrieve streaming tools !");
+ return StatusCode::FAILURE;
+ }
+ }
+
/**
* Get the IDataRetrievers requested in the m_dataTypes list from the toolSvc
* and store them in the ToolHandleArray
@@ -118,13 +137,18 @@ namespace JiveXML{
ATH_MSG_INFO("Retrieving data from " << m_DataRetrievers.size() << " tools" );
ATH_MSG_INFO("List property settings: ");
+ ATH_MSG_INFO("WantPublicStreams: " << m_wantPublicStreams);
+ ATH_MSG_INFO("WantCalibrationStreams: " << m_wantCalibrationStreams);
+ ATH_MSG_INFO("WantMonitoringStreams: " << m_wantMonitoringStreams);
+ ATH_MSG_INFO("WantPhysicsStreams: " << m_wantPhysicsStreams);
ATH_MSG_INFO("AtlasRelease: " << m_AtlasRelease);
ATH_MSG_INFO("DataTypes: " << m_dataTypes );
ATH_MSG_INFO("WriteToFile: " << m_writeToFile);
ATH_MSG_INFO("OnlineMode: " << m_onlineMode);
ATH_MSG_INFO("WriteGeometry: " << m_writeGeometry);
ATH_MSG_INFO("GeometryVersion: " << m_geometryVersionIn);
- ATH_MSG_INFO("GeoWriterNames: " << m_GeoWriterNames);
+ ATH_MSG_INFO("GeoWriterNames: " << m_GeoWriterNames );
+
return StatusCode::SUCCESS;
}
@@ -135,6 +159,7 @@ namespace JiveXML{
* - pass formatted events to streamers
*/
StatusCode AlgoJiveXML::execute() {
+
/**
* Firstly retrieve all the event header information
*/
@@ -157,7 +182,7 @@ namespace JiveXML{
return StatusCode::FAILURE;
}else{
// Event/xAOD/xAODEventInfo/trunk/xAODEventInfo/versions/EventInfo_v1.h
- ATH_MSG_INFO(" xAODEventInfo: runNumber: " << eventInfo->runNumber() // is '222222' for mc events ?
+ ATH_MSG_VERBOSE(" xAODEventInfo: runNumber: " << eventInfo->runNumber() // is '222222' for mc events ?
<< ", eventNumber: " << eventInfo->eventNumber()
<< ", mcChannelNumber: " << eventInfo->mcChannelNumber()
<< ", mcEventNumber: " << eventInfo->mcEventNumber() // MC: use this instead of runNumber
@@ -289,17 +314,16 @@ namespace JiveXML{
/**
* Now stream the events to all registered streaming tools
*/
-
- ATH_MSG_INFO("Streaming event to file");
- if ( (m_StreamToFileTool->StreamEvent(eventNo, runNo, m_FormatTool->getFormattedEvent()).isFailure() )){
- ATH_MSG_WARNING( "Could not stream event to file" );
- }
- if(m_onlineMode==true){
- ATH_MSG_INFO("Streaming event to server");
- if ( (m_StreamToServerTool->StreamEvent(eventNo, runNo, m_FormatTool->getFormattedEvent()).isFailure() )){
- ATH_MSG_WARNING( "Could not stream event to server" );
- }
+ ATH_MSG_DEBUG( "Starting loop over event streamers" );
+ //Loop over streaming tools
+ ToolHandleArray<IStreamTool>::iterator StreamToolsItr = m_StreamTools.begin();
+ for ( ; StreamToolsItr != m_StreamTools.end(); ++StreamToolsItr ){
+ ATH_MSG_INFO("Streaming event to " << (*StreamToolsItr)->name() );
+ if ( (*StreamToolsItr)->StreamEvent(eventNo, runNo, m_FormatTool->getFormattedEvent()).isFailure() ){
+ ATH_MSG_WARNING( "Could not stream event to " << (*StreamToolsItr)->name() );
+ }
}
+ ATH_MSG_DEBUG( "Finished loop over event streamers" );
return StatusCode::SUCCESS;
}
@@ -315,9 +339,31 @@ namespace JiveXML{
/// Release all the tools
m_DataRetrievers.release().ignore();
m_FormatTool.release().ignore();
- m_StreamToFileTool.release().ignore();
- m_StreamToServerTool.release().ignore();
-
+ m_StreamTools.release().ignore();
+
+ return StatusCode::SUCCESS;
+ }
+
+ StatusCode AlgoJiveXML::chooseStream(const std::vector< xAOD::EventInfo::StreamTag > evtStreamTags){
+ std::vector<std::string> wantedStreamTypes;
+ if (m_wantPublicStreams){
+ wantedStreamTypes.emplace_back("Public");
+ }
+ if (m_wantCalibrationStreams){
+ wantedStreamTypes.emplace_back("calibration");
+ }
+ if (m_wantMonitoringStreams){
+ wantedStreamTypes.emplace_back("monitoring");
+ }
+ if (m_wantPhysicsStreams){
+ wantedStreamTypes.emplace_back("physics");
+ }
+ std::vector< xAOD::EventInfo::StreamTag > goodStreams;
+ for (const auto& evtStreamTag : evtStreamTags) {
+ ATH_MSG_INFO( "Stream Tag in function: " << evtStreamTag.type() << "_" << evtStreamTag.name());
+ // if evtStreamTag.type() is in wantedStreamTypes add to goodStreams
+ }
+ //randomize goodStreams and return first value as choosen Stream
return StatusCode::SUCCESS;
}
} //namespace
diff --git a/graphics/JiveXML/src/StreamToFileTool.cxx b/graphics/JiveXML/src/StreamToFileTool.cxx
index 9786caebeca6ec4346a9aadde61739b8ee22e060..f0af88937b032259fa3f0554765fd7869e752bed 100644
--- a/graphics/JiveXML/src/StreamToFileTool.cxx
+++ b/graphics/JiveXML/src/StreamToFileTool.cxx
@@ -1,5 +1,5 @@
/*
- Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+ Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
#include <JiveXML/StreamToFileTool.h>
@@ -10,13 +10,13 @@
namespace JiveXML {
/**
- * Constructor
+ * Constructor
* - setup message service
* - initialize properties
*/
StreamToFileTool::StreamToFileTool( const std::string& type , const std::string& name, const IInterface* p):
AthAlgTool(type,name,p){
-
+
//Provide interface
declareInterface<IStreamTool>(this);
@@ -24,7 +24,6 @@ namespace JiveXML {
declareProperty("FileNamePrefix", m_FileNamePrefix = "JiveXML");
/// The file name suffix
declareProperty("FileNameSuffix", m_FileNameSuffix = ".xml");
-
}
/**
@@ -32,12 +31,6 @@ namespace JiveXML {
*/
StatusCode StreamToFileTool::initialize(){
return StatusCode::SUCCESS;
- if(m_isOnline){
- if( m_onlineEDsvc.retrieve().isFailure()){
- ATH_MSG_ERROR("Could not locate the online event displays service");
- return StatusCode::FAILURE;
- }
- }
}
/**
@@ -53,27 +46,27 @@ namespace JiveXML {
* @param RunNumber the run number
* @param EventBuffer the string holding the complete event
*/
- StatusCode StreamToFileTool::StreamEvent( const unsigned long EventNumber, const unsigned int RunNumber, const std::ostringstream* EventBuffer ) {
- if(m_isOnline){
- m_FileNamePrefix = m_onlineEDsvc->getFileNamePrefix();
- ATH_MSG_INFO("m_FileNamePrefix: " << m_FileNamePrefix << " EventNumber: " << EventNumber);
- }
+ StatusCode StreamToFileTool::StreamEvent( const unsigned long EventNumber, const unsigned int RunNumber, const std::ostringstream* EventBuffer ) {
+
+ if (msgLvl(MSG::INFO)) msg(MSG::INFO) << " m_FileNamePrefix: " << m_FileNamePrefix << endmsg;
/// Get a pointer to a new file
std::ofstream* outFile;
StatusCode sc = NewFile(EventNumber,RunNumber,outFile);
if (sc.isFailure()){
- ATH_MSG_WARNING("Could not open file for event " << EventNumber << " from run " << RunNumber);
+ if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Could not open file for event "
+ << EventNumber << " from run " << RunNumber << endmsg;
return sc;
}
- /// Stream this event into the file
+ /// Stream this event into the file
(*outFile) << EventBuffer->str();
outFile->flush();
/// Check wether we could write the event
if (!outFile->good()){
- ATH_MSG_WARNING("Could not open file for event " << EventNumber << " from run " << RunNumber);
+ if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Could not write event "
+ << EventNumber << " from run " << RunNumber << endmsg;
return StatusCode::FAILURE;
}
-
+
/// Finally close the file
sc = CloseFile(outFile);
return sc;
@@ -85,24 +78,24 @@ namespace JiveXML {
* @param EventNumber the event number
* @param RunNumber the run number
*/
- std::string StreamToFileTool::MakeFileName(const unsigned long EventNumber, const unsigned int RunNumber) const {
+ std::string StreamToFileTool::MakeFileName( const unsigned long EventNumber, const unsigned int RunNumber) const {
//Generate a the return string with file prefix
std::ostringstream name;
-
+
//Assemble file name
name << m_FileNamePrefix << std::setfill('0');
name << "_" << std::setw(5) << RunNumber;
name << "_" << std::setw(5) << EventNumber;
- name << m_FileNameSuffix;
+ name << m_FileNameSuffix;
return name.str();
}
- /**
+ /**
* Open a new file
*/
StatusCode StreamToFileTool::NewFile( const unsigned long EventNumber, const unsigned int RunNumber, std::ofstream *& outputFile) const {
-
+
// Generate the file name
std::string filename = MakeFileName(EventNumber,RunNumber);
@@ -111,24 +104,24 @@ namespace JiveXML {
// check if it worked
if ( !(outputFile->good()) ){
- ATH_MSG_WARNING("Unable to create output file with name " << filename);
- return StatusCode::FAILURE;
+ if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Unable to create output file with name " << filename << endmsg;
+ return StatusCode::FAILURE;
}
return StatusCode::SUCCESS;
}
/**
- * Close the file
- */
+ * Close the file
+ */
StatusCode StreamToFileTool::CloseFile( std::ofstream *& outputFile ) const {
//Try to close the file
outputFile->close();
-
+
//See if it worked
if (!outputFile->good()){
- ATH_MSG_WARNING("Unable to close file");
+ if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "Unable to close file" << endmsg;
}
//In any case delete object