diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/CscRawDataProvider.h b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/CscRawDataProvider.h
index b3add72fdba3558b81872a2de8177cc9103eafc3..45002da1d763dcc8e36c688062c88be7b8d3205d 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/CscRawDataProvider.h
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/CscRawDataProvider.h
@@ -5,7 +5,8 @@
#ifndef MUONBYTESTREAM_CSCRAWDATAPROVIDER_H
#define MUONBYTESTREAM_CSCRAWDATAPROVIDER_H
-#include "AthenaBaseComps/AthAlgorithm.h"
+// Base class
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
@@ -16,7 +17,7 @@
namespace Muon {
-class CscRawDataProvider : public AthAlgorithm
+class CscRawDataProvider : public AthReentrantAlgorithm
{
public:
@@ -27,7 +28,7 @@ public:
virtual StatusCode initialize();
//! Execute
- virtual StatusCode execute();
+ virtual StatusCode execute(const EventContext& ctx) const;
//! Destructor
~CscRawDataProvider()=default;
diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/MdtRawDataProvider.h b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/MdtRawDataProvider.h
index f2155aef518b8d8ba0269264b5bcd78db7346f48..2e1bb026457c389f8fcd5771a1756507b0a13b27 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/MdtRawDataProvider.h
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/MdtRawDataProvider.h
@@ -5,7 +5,8 @@
#ifndef MUONBYTESTREAM_MDTRAWDATAPROVIDER_H
#define MUONBYTESTREAM_MDTRAWDATAPROVIDER_H
-#include "AthenaBaseComps/AthAlgorithm.h"
+// Base class
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
@@ -16,7 +17,7 @@
namespace Muon {
-class MdtRawDataProvider : public AthAlgorithm
+class MdtRawDataProvider : public AthReentrantAlgorithm
{
public:
@@ -27,7 +28,7 @@ public:
virtual StatusCode initialize();
//! Execute
- virtual StatusCode execute();
+ virtual StatusCode execute(const EventContext& ctx) const;
//! Destructur
~MdtRawDataProvider()=default;
diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/RpcRawDataProvider.h b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/RpcRawDataProvider.h
index 7bf957d854b593fd429e51cb58ee14d500cf47cb..08ad7f1e3d83371dfce83809e93b7073fc408f1d 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/RpcRawDataProvider.h
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/RpcRawDataProvider.h
@@ -5,7 +5,8 @@
#ifndef MUONBYTESTREAM_RPCRAWDATAPROVIDER_H
#define MUONBYTESTREAM_RPCRAWDATAPROVIDER_H
-#include "AthenaBaseComps/AthAlgorithm.h"
+// Base class
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
@@ -15,7 +16,7 @@
namespace Muon {
-class RpcRawDataProvider : public AthAlgorithm
+class RpcRawDataProvider : public AthReentrantAlgorithm
{
public:
@@ -26,7 +27,7 @@ public:
virtual StatusCode initialize();
//! Execute
- virtual StatusCode execute();
+ virtual StatusCode execute(const EventContext& ctx) const;
//! Destructur
~RpcRawDataProvider()=default;
diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/TgcRawDataProvider.h b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/TgcRawDataProvider.h
index 359b202daf11c89a714fbb229bc82c91fea40b5c..b0617a62d7575a59be3408d6fe99e93590c07827 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/TgcRawDataProvider.h
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/MuonByteStream/TgcRawDataProvider.h
@@ -5,7 +5,8 @@
#ifndef MUONBYTESTREAM_TGCRAWDATAPROVIDER_H
#define MUONBYTESTREAM_TGCRAWDATAPROVIDER_H
-#include "AthenaBaseComps/AthAlgorithm.h"
+// Base class
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
@@ -16,7 +17,7 @@
namespace Muon
{
-class TgcRawDataProvider : public AthAlgorithm
+class TgcRawDataProvider : public AthReentrantAlgorithm
{
public:
@@ -27,7 +28,7 @@ public:
virtual StatusCode initialize();
//! Execute
- virtual StatusCode execute();
+ virtual StatusCode execute(const EventContext& ctx) const;
//! Destructur
~TgcRawDataProvider()=default;
diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/src/CscRawDataProvider.cxx b/MuonSpectrometer/MuonCnv/MuonByteStream/src/CscRawDataProvider.cxx
index 68fc6ef9cd479ac866644289403e0706eb0e1160..3734518bc7e3d1230b5fb91c22174fda931ead79 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/src/CscRawDataProvider.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/src/CscRawDataProvider.cxx
@@ -11,7 +11,7 @@
Muon::CscRawDataProvider::CscRawDataProvider(const std::string& name,
ISvcLocator* pSvcLocator) :
- AthAlgorithm(name, pSvcLocator),
+ AthReentrantAlgorithm(name, pSvcLocator),
m_regionSelector ("RegSelSvc",name)
{
declareProperty ("RegionSelectionSvc", m_regionSelector, "Region Selector");
@@ -36,19 +36,22 @@ StatusCode Muon::CscRawDataProvider::initialize() {
return StatusCode::SUCCESS;
}
-StatusCode Muon::CscRawDataProvider::execute() {
+// --------------------------------------------------------------------
+// Execute
+
+StatusCode Muon::CscRawDataProvider::execute(const EventContext& ctx) const {
ATH_MSG_VERBOSE( "CscRawDataProvider::execute" );
if(m_seededDecoding) {
- SG::ReadCondHandle<ALineMapContainer> readALineHandle(m_ALineKey);// !!! REMOVEME: when MuonDetectorManager in cond store
+ SG::ReadCondHandle<ALineMapContainer> readALineHandle(m_ALineKey, ctx);// !!! REMOVEME: when MuonDetectorManager in cond store
if(!readALineHandle.isValid()){// !!! REMOVEME: when MuonDetectorManager in cond store
ATH_MSG_WARNING("Cannot retrieve ALine Handle "<<m_ALineKey.key());// !!! REMOVEME: when MuonDetectorManager in cond store
return StatusCode::SUCCESS;// !!! REMOVEME: when MuonDetectorManager in cond store
}// !!! REMOVEME: when MuonDetectorManager in cond store
// read in the RoIs to process
- SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey);
+ SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey, ctx);
if(!muonRoI.isValid()){
ATH_MSG_WARNING("Cannot retrieve muonRoI "<<m_roiCollectionKey.key());
return StatusCode::SUCCESS;
@@ -62,7 +65,7 @@ StatusCode Muon::CscRawDataProvider::execute() {
m_regionSelector->DetHashIDList(CSC, *roi, csc_hash_ids);
// decode the ROBs
- if(m_rawDataTool->convert(csc_hash_ids).isFailure()) {
+ if(m_rawDataTool->convert(csc_hash_ids, ctx).isFailure()) {
ATH_MSG_ERROR( "RoI seeded BS conversion into RDOs failed" );
}
// clear vector of hash IDs ready for next RoI
@@ -70,7 +73,7 @@ StatusCode Muon::CscRawDataProvider::execute() {
}
} else {
// ask CscRawDataProviderTool to decode entire event and to fill the IDC
- if (m_rawDataTool->convert().isFailure())
+ if (m_rawDataTool->convert(ctx).isFailure())
ATH_MSG_ERROR ( "BS conversion into RDOs failed" );
}
diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/src/MdtRawDataProvider.cxx b/MuonSpectrometer/MuonCnv/MuonByteStream/src/MdtRawDataProvider.cxx
index 035f8303a32f481da0303eb171c805cb225cef89..1a5761699f7d70f8696bc1a8ea257f5f2976c150 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/src/MdtRawDataProvider.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/src/MdtRawDataProvider.cxx
@@ -8,7 +8,7 @@
Muon::MdtRawDataProvider::MdtRawDataProvider(const std::string& name,
ISvcLocator* pSvcLocator) :
- AthAlgorithm(name, pSvcLocator),
+ AthReentrantAlgorithm(name, pSvcLocator),
m_regionSelector ("RegSelSvc",name)
{
declareProperty ("RegionSelectionSvc", m_regionSelector, "Region Selector");
@@ -34,13 +34,16 @@ StatusCode Muon::MdtRawDataProvider::initialize() {
return StatusCode::SUCCESS;
}
-StatusCode Muon::MdtRawDataProvider::execute() {
+// --------------------------------------------------------------------
+// Execute
+
+StatusCode Muon::MdtRawDataProvider::execute(const EventContext& ctx) const {
ATH_MSG_VERBOSE( "MdtRawDataProvider::execute" );
if(m_seededDecoding) {
// read in the RoIs to process
- SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey);
+ SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey, ctx);
if(!muonRoI.isValid()){
ATH_MSG_WARNING("Cannot retrieve muonRoI "<<m_roiCollectionKey.key());
return StatusCode::SUCCESS;
@@ -54,7 +57,7 @@ StatusCode Muon::MdtRawDataProvider::execute() {
m_regionSelector->DetROBIDListUint(MDT,*roi,robs);
// decode the ROBs
- if(m_rawDataTool->convert(robs).isFailure()) {
+ if(m_rawDataTool->convert(robs, ctx).isFailure()) {
ATH_MSG_ERROR( "RoI seeded BS conversion into RDOs failed" );
}
// clear vector of ROB IDs ready for next RoI
@@ -63,7 +66,7 @@ StatusCode Muon::MdtRawDataProvider::execute() {
} else {
// ask MdtRawDataProviderTool to decode the event and to fill the IDC
- if (m_rawDataTool->convert().isFailure())
+ if (m_rawDataTool->convert(ctx).isFailure())
ATH_MSG_ERROR( "BS conversion into RDOs failed" );
}
diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/src/RpcRawDataProvider.cxx b/MuonSpectrometer/MuonCnv/MuonByteStream/src/RpcRawDataProvider.cxx
index 73784236f3c467d38b82593100a6b595ce5014f8..9168d8158a7e1a0fb3d8e0d6d4c0b368fe55f464 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/src/RpcRawDataProvider.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/src/RpcRawDataProvider.cxx
@@ -10,7 +10,7 @@
Muon::RpcRawDataProvider::RpcRawDataProvider(const std::string& name,
ISvcLocator* pSvcLocator) :
- AthAlgorithm(name, pSvcLocator),
+ AthReentrantAlgorithm(name, pSvcLocator),
m_regionSelector ("RegSelSvc",name)
{
declareProperty ("RegionSelectionSvc", m_regionSelector, "Region Selector");
@@ -34,13 +34,16 @@ StatusCode Muon::RpcRawDataProvider::initialize() {
return StatusCode::SUCCESS;
}
-StatusCode Muon::RpcRawDataProvider::execute() {
+// --------------------------------------------------------------------
+// Execute
+
+StatusCode Muon::RpcRawDataProvider::execute(const EventContext& ctx) const {
ATH_MSG_VERBOSE( "RpcRawDataProvider::execute" );
if(m_seededDecoding) {
// read in the RoIs to process
- SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey);
+ SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey, ctx);
if(!muonRoI.isValid()){
ATH_MSG_WARNING("Cannot retrieve muonRoI "<<m_roiCollectionKey.key());
return StatusCode::SUCCESS;
@@ -54,7 +57,7 @@ StatusCode Muon::RpcRawDataProvider::execute() {
m_regionSelector->DetROBIDListUint(RPC,*roi,rpcrobs);
// decode the ROBs
- if(m_rawDataTool->convert(rpcrobs).isFailure()) {
+ if(m_rawDataTool->convert(rpcrobs, ctx).isFailure()) {
ATH_MSG_ERROR( "RoI seeded BS conversion into RDOs failed" );
}
// clear vector of ROB IDs ready for next RoI
@@ -63,7 +66,7 @@ StatusCode Muon::RpcRawDataProvider::execute() {
} else {
// ask RpcRawDataProviderTool to decode the event and to fill the IDC
- if (m_rawDataTool->convert().isFailure())
+ if (m_rawDataTool->convert(ctx).isFailure())
ATH_MSG_ERROR( "BS conversion into RDOs failed" );
}
diff --git a/MuonSpectrometer/MuonCnv/MuonByteStream/src/TgcRawDataProvider.cxx b/MuonSpectrometer/MuonCnv/MuonByteStream/src/TgcRawDataProvider.cxx
index 00549cde8a07a9491e714afdf390cf3a3eefb14d..db0348b147e06c21c0a2642e7306de26776fd334 100644
--- a/MuonSpectrometer/MuonCnv/MuonByteStream/src/TgcRawDataProvider.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonByteStream/src/TgcRawDataProvider.cxx
@@ -11,7 +11,7 @@ using eformat::helper::SourceIdentifier;
Muon::TgcRawDataProvider::TgcRawDataProvider(const std::string& name,
ISvcLocator* pSvcLocator) :
- AthAlgorithm(name, pSvcLocator),
+ AthReentrantAlgorithm(name, pSvcLocator),
m_regionSelector ("RegSelSvc",name)
{
declareProperty ("RegionSelectionSvc", m_regionSelector, "Region Selector");
@@ -37,14 +37,17 @@ StatusCode Muon::TgcRawDataProvider::initialize()
return StatusCode::SUCCESS;
}
-StatusCode Muon::TgcRawDataProvider::execute()
+// --------------------------------------------------------------------
+// Execute
+
+StatusCode Muon::TgcRawDataProvider::execute(const EventContext& ctx) const
{
ATH_MSG_VERBOSE( "TgcRawDataProvider::execute" );
if(m_seededDecoding) {
// read in the RoIs to process
- SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey);
+ SG::ReadHandle<TrigRoiDescriptorCollection> muonRoI(m_roiCollectionKey, ctx);
if(!muonRoI.isValid()){
ATH_MSG_WARNING("Cannot retrieve muonRoI "<<m_roiCollectionKey.key());
return StatusCode::SUCCESS;
@@ -58,7 +61,7 @@ StatusCode Muon::TgcRawDataProvider::execute()
m_regionSelector->DetHashIDList(TGC, *roi, tgc_hash_ids);
// decode the ROBs
- if(m_rawDataTool->convert(tgc_hash_ids).isFailure()) {
+ if(m_rawDataTool->convert(tgc_hash_ids, ctx).isFailure()) {
ATH_MSG_ERROR( "RoI seeded BS conversion into RDOs failed" );
}
// clear vector of hash IDs ready for next RoI
@@ -66,7 +69,7 @@ StatusCode Muon::TgcRawDataProvider::execute()
}
} else {
// ask TgcRawDataProviderTool to decode full detector and to fill the IDC
- if (m_rawDataTool->convert().isFailure())
+ if (m_rawDataTool->convert(ctx).isFailure())
ATH_MSG_ERROR( "BS conversion into RDOs failed" );
}
diff --git a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.cxx b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.cxx
index b5c042234bb639c26c7a5d327225214c90a3e00b..cc8b62036e3b2998a62b7ffaf4358d445d950e7c 100644
--- a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.cxx
@@ -86,8 +86,7 @@ StatusCode Muon::CSC_RawDataProviderTool::convert(const EventContext& ctx) const
StatusCode Muon::CSC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs,
const std::vector<IdentifierHash>& /* collections */){
- const CSC_RawDataProviderTool* cthis = this;
- return cthis->convert (vecRobs, Gaudi::Hive::currentContext());
+ return this->convert (vecRobs, Gaudi::Hive::currentContext());
}
StatusCode
diff --git a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.h b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.h
index fc78a22b30a7a1b41770f4535d0134e39694f629..622ae006869902461bf7271629bafdab6d561458 100644
--- a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.h
+++ b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderTool.h
@@ -37,21 +37,23 @@ public:
virtual StatusCode convert(const ROBFragmentList& vecRobs) override
{
- const CSC_RawDataProviderTool* cthis = this;
- return cthis->convert (vecRobs, Gaudi::Hive::currentContext());
+ return this->convert (vecRobs, Gaudi::Hive::currentContext());
}
virtual StatusCode convert(const std::vector<IdentifierHash>& collections) override;
virtual StatusCode convert() override
{
- const CSC_RawDataProviderTool* cthis = this;
- return cthis->convert (Gaudi::Hive::currentContext());
+ return this->convert (Gaudi::Hive::currentContext());
}
virtual StatusCode convert(const std::vector<uint32_t>&) override {return StatusCode::FAILURE;}
- StatusCode convert(const ROBFragmentList& vecRobs,
- const EventContext& ctx) const;
- StatusCode convert(const EventContext& ctx) const;
+ virtual StatusCode convert(const ROBFragmentList& vecRobs, const EventContext& ctx) const override;
+ virtual StatusCode convert(const EventContext& ctx) const override;
+
+ // Not used
+ virtual StatusCode convert(const std::vector<IdentifierHash>&, const EventContext&) const override {return StatusCode::FAILURE;}
+ virtual StatusCode convert(const std::vector<uint32_t>&, const EventContext&) const override {return StatusCode::FAILURE;}
+ virtual StatusCode convert(const ROBFragmentList&, const std::vector<IdentifierHash>&, const EventContext&) const override {return StatusCode::FAILURE;}
private:
diff --git a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.cxx b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.cxx
index cae1e0731b6b6922fda1e49d62aaf11684d9452b..67b2126444e95a7e54acc72dfefa809cf597203c 100644
--- a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.cxx
@@ -59,7 +59,12 @@ StatusCode Muon::CSC_RawDataProviderToolMT::initialize()
//============================================================================================
// new one
+
StatusCode Muon::CSC_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& rdoIdhVect){
+ return this->convert (rdoIdhVect, Gaudi::Hive::currentContext());
+}
+
+StatusCode Muon::CSC_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& rdoIdhVect, const EventContext& ctx) const{
IdContext cscContext = m_idHelperSvc->cscIdHelper().module_context();
@@ -73,7 +78,10 @@ StatusCode Muon::CSC_RawDataProviderToolMT::convert(const std::vector<Identifier
}
m_robDataProvider->getROBData(robIds, vecOfRobf);
ATH_MSG_VERBOSE ( "Number of ROB fragments " << vecOfRobf.size() );
- return convert(vecOfRobf, rdoIdhVect);
+
+ // This would be passed to the function which does not use the IdentifierHash further
+ return convert(vecOfRobf, ctx);
+
}
StatusCode Muon::CSC_RawDataProviderToolMT::convert(const EventContext& ctx) const {
@@ -90,14 +98,13 @@ StatusCode Muon::CSC_RawDataProviderToolMT::convert(const EventContext& ctx) con
StatusCode Muon::CSC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs,
- const std::vector<IdentifierHash>& /* collections */){
- const CSC_RawDataProviderToolMT* cthis = this;
- return cthis->convert (vecRobs, Gaudi::Hive::currentContext());
+ const std::vector<IdentifierHash>& /* collections */){
+ return this->convert (vecRobs, Gaudi::Hive::currentContext());
}
StatusCode
Muon::CSC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs,
- const EventContext& ctx) const
+ const EventContext& ctx) const
{
SG::WriteHandle<CscRawDataContainer> rdoContainerHandle(m_containerKey, ctx);
diff --git a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.h b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.h
index 22b9f55db1178128a25614e1b7a257a29a955837..36d3a5bfe3559ff59dd9f930cfa5abeba45a28a1 100644
--- a/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.h
+++ b/MuonSpectrometer/MuonCnv/MuonCSC_CnvTools/src/CSC_RawDataProviderToolMT.h
@@ -35,21 +35,23 @@ public:
virtual StatusCode convert(const ROBFragmentList& vecRobs) override
{
- const CSC_RawDataProviderToolMT* cthis = this;
- return cthis->convert (vecRobs, Gaudi::Hive::currentContext());
+ return this->convert (vecRobs, Gaudi::Hive::currentContext());
}
virtual StatusCode convert(const std::vector<IdentifierHash>& collections) override;
virtual StatusCode convert() override
{
- const CSC_RawDataProviderToolMT* cthis = this;
- return cthis->convert (Gaudi::Hive::currentContext());
+ return this->convert (Gaudi::Hive::currentContext());
}
virtual StatusCode convert(const std::vector<uint32_t>&) override {return StatusCode::FAILURE;}
- StatusCode convert(const ROBFragmentList& vecRobs,
- const EventContext& ctx) const;
- StatusCode convert(const EventContext& ctx) const;
+ virtual StatusCode convert(const ROBFragmentList& vecRobs,const EventContext& ctx) const override;
+ virtual StatusCode convert(const EventContext& ctx) const override;
+ virtual StatusCode convert(const std::vector<IdentifierHash>&, const EventContext&) const override;
+
+ // Not used
+ virtual StatusCode convert(const std::vector<uint32_t>&, const EventContext&) const override {return StatusCode::FAILURE;}
+ virtual StatusCode convert(const ROBFragmentList&, const std::vector<IdentifierHash>&, const EventContext&) const override {return StatusCode::FAILURE;}
private:
diff --git a/MuonSpectrometer/MuonCnv/MuonCnvToolInterfaces/MuonCnvToolInterfaces/IMuonRawDataProviderTool.h b/MuonSpectrometer/MuonCnv/MuonCnvToolInterfaces/MuonCnvToolInterfaces/IMuonRawDataProviderTool.h
index 3f04917bc09ae2049659c9bd7e83d1d618da3716..d1738c0b5749294f66ae3275c66202cc6cd83715 100644
--- a/MuonSpectrometer/MuonCnv/MuonCnvToolInterfaces/MuonCnvToolInterfaces/IMuonRawDataProviderTool.h
+++ b/MuonSpectrometer/MuonCnv/MuonCnvToolInterfaces/MuonCnvToolInterfaces/IMuonRawDataProviderTool.h
@@ -8,6 +8,7 @@
#include "GaudiKernel/IAlgTool.h"
#include "ByteStreamData/RawEvent.h"
#include "Identifier/IdentifierHash.h"
+#include "GaudiKernel/EventContext.h"
#include <vector>
static const InterfaceID IID_IMuonRawDataProviderTool( "Muon::IMuonRawDataProviderTool", 1, 0 );
@@ -34,6 +35,14 @@ public:
virtual StatusCode convert() = 0; //!< for the entire event
virtual StatusCode convert(const std::vector<IdentifierHash>&) = 0; //!< for a selection of rdo collections
virtual StatusCode convert(const std::vector<uint32_t>&){return StatusCode::FAILURE;}
+ /** Event Context functions **/
+ virtual StatusCode convert(const EventContext&) const {return StatusCode::FAILURE;}
+ virtual StatusCode convert(const ROBFragmentList&, const EventContext&) const {return StatusCode::FAILURE;}
+ virtual StatusCode convert(const ROBFragmentList&, const std::vector<IdentifierHash>&, const EventContext&) const {return StatusCode::FAILURE;}
+ virtual StatusCode convert(const std::vector<IdentifierHash>&, const EventContext&) const {return StatusCode::FAILURE;}
+ virtual StatusCode convert(const std::vector<uint32_t>&, const EventContext&) const {return StatusCode::FAILURE;}
+
+
};
}
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.cxx b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.cxx
index 5d9859afe9bd85a44b0a764bf106f9234595ed18..6968248926fc2a08dff4218eab98ac432835a53c 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.cxx
@@ -42,45 +42,72 @@ StatusCode Muon::MDT_RawDataProviderTool::finalize()
// the new one
StatusCode Muon::MDT_RawDataProviderTool::convert() //call decoding function using list of all detector ROBId's
{
- SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey};
+ return this->convert( Gaudi::Hive::currentContext() );
+}
+
+// EventContext
+StatusCode Muon::MDT_RawDataProviderTool::convert(const EventContext& ctx) const {
+ SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey, ctx};
const MuonMDT_CablingMap* readCdo{*readHandle};
if(readCdo==nullptr){
ATH_MSG_ERROR("Null pointer to the read conditions object");
return StatusCode::FAILURE;
}
- return convert(readCdo->getAllROBId());
-}
+ return convert(readCdo->getAllROBId(), ctx);
+}
StatusCode Muon::MDT_RawDataProviderTool::convert(const std::vector<IdentifierHash>& HashVec)
{
- SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey};
+ return this->convert( HashVec, Gaudi::Hive::currentContext() );
+}
+
+// EventContext
+StatusCode Muon::MDT_RawDataProviderTool::convert(const std::vector<IdentifierHash>& HashVec, const EventContext& ctx) const
+{
+ SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey, ctx};
const MuonMDT_CablingMap* readCdo{*readHandle};
if(readCdo==nullptr){
ATH_MSG_ERROR("Null pointer to the read conditions object");
return StatusCode::FAILURE;
}
- return convert(readCdo->getROBId(HashVec));
+ return convert(readCdo->getROBId(HashVec), ctx);
}
StatusCode Muon::MDT_RawDataProviderTool::convert(const std::vector<uint32_t>& robIds)
+{
+ return this->convert( robIds, Gaudi::Hive::currentContext() ); // using the old one
+}
+
+StatusCode Muon::MDT_RawDataProviderTool::convert(const std::vector<uint32_t>& robIds, const EventContext& ctx) const
{
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
m_robDataProvider->getROBData( robIds, vecOfRobf);
- return convert(vecOfRobf); // using the old one
- }
+ return convert(vecOfRobf, ctx); // using the old one
+}
+
StatusCode Muon::MDT_RawDataProviderTool::convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs,
const std::vector<IdentifierHash>&)
{
- return convert(vecRobs);
+ return this->convert(vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::MDT_RawDataProviderTool::convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs,
+ const std::vector<IdentifierHash>& /*collections*/, const EventContext& ctx) const
+{
+ return convert(vecRobs, ctx);
}
/// This decode function is for single-thread running only
StatusCode Muon::MDT_RawDataProviderTool::convert ATLAS_NOT_THREAD_SAFE ( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs)
+{
+ return this->convert(vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::MDT_RawDataProviderTool::convert ( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const EventContext& ctx) const
{
ATH_MSG_VERBOSE("convert(): " << vecRobs.size()<<" ROBFragments.");
-
- SG::WriteHandle<MdtCsmContainer> rdoContainerHandle(m_rdoContainerKey);
+ SG::WriteHandle<MdtCsmContainer> rdoContainerHandle(m_rdoContainerKey, ctx);
MdtCsmContainer* rdoContainer = 0;
@@ -108,5 +135,5 @@ StatusCode Muon::MDT_RawDataProviderTool::convert ATLAS_NOT_THREAD_SAFE ( const
ATH_CHECK( convertIntoContainer( vecRobs, *rdoContainer ) );
return StatusCode::SUCCESS;
-}
+}
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.h b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.h
index a23afd654652b521bfa439f3ffe934e116e4cf0b..22d66891cc6ebec823e1c6ce7d1b0178d1a76e79 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.h
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderTool.h
@@ -39,12 +39,19 @@ class ATLAS_NOT_THREAD_SAFE MDT_RawDataProviderTool : virtual public IMuonRawDat
virtual StatusCode finalize ();
/** Convert method - declared in Muon::IMuonRdoToPrepDataTool*/
- virtual StatusCode convert ATLAS_NOT_THREAD_SAFE ( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs);
- virtual StatusCode convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>&);
+ virtual StatusCode convert ATLAS_NOT_THREAD_SAFE ( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs) override;
+ virtual StatusCode convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>&) override;
+
/** the new ones */
virtual StatusCode convert(); //!< for the entire event
- virtual StatusCode convert(const std::vector<IdentifierHash>& HashVec);
- virtual StatusCode convert(const std::vector<uint32_t>& robIds);//!< for a particular vector of ROBId's
+ virtual StatusCode convert(const std::vector<IdentifierHash>& HashVec) override;
+ virtual StatusCode convert(const std::vector<uint32_t>& robIds) override;//!< for a particular vector of ROBId's
+ /** EventContext ones **/
+ virtual StatusCode convert(const EventContext&) const override; //!< for the entire event
+ virtual StatusCode convert(const std::vector<IdentifierHash>& HashVec, const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<uint32_t>& robIds, const EventContext&) const override;//!< for a particular vector of ROBId's
+ virtual StatusCode convert(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>&, const EventContext&) const override;
};
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.cxx b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.cxx
index f9161b42b6d4ab2dd4d4f50a0d9fe213c832b45c..9a4192ea6f5a170cf032b83cbf92a18bfd83bcf6 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.cxx
@@ -44,7 +44,7 @@ StatusCode Muon::MDT_RawDataProviderToolCore::initialize()
return StatusCode::SUCCESS;
}
-StatusCode Muon::MDT_RawDataProviderToolCore::convertIntoContainer( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, MdtCsmContainer& mdtContainer)
+StatusCode Muon::MDT_RawDataProviderToolCore::convertIntoContainer( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, MdtCsmContainer& mdtContainer) const
{
ATH_MSG_VERBOSE("convert(): " << vecRobs.size()<<" ROBFragments.");
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.h b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.h
index 94a7d5400f977abcada83477069d2d3a286e1a1b..2b9fe5c29223b35d5e42d472aa28d16c632f7fe6 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.h
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolCore.h
@@ -43,7 +43,7 @@ class MDT_RawDataProviderToolCore : public AthAlgTool
virtual StatusCode initialize();
/** Convert method */
- virtual StatusCode convertIntoContainer( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, MdtCsmContainer& mdtContainer);
+ virtual StatusCode convertIntoContainer( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, MdtCsmContainer& mdtContainer) const;
protected:
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.cxx b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.cxx
index eaef673ff688b1d404bded51de2290afd3c55426..9bd333f21f14d3f49a4bd657e96b0c2e459f6dc1 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.cxx
@@ -41,43 +41,69 @@ StatusCode Muon::MDT_RawDataProviderToolMT::finalize()
// the new one
StatusCode Muon::MDT_RawDataProviderToolMT::convert() //call decoding function using list of all detector ROBId's
{
- SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey};
+ return this->convert( Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::MDT_RawDataProviderToolMT::convert(const EventContext& ctx) const //call decoding function using list of all detector ROBId's
+{
+ SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey, ctx};
const MuonMDT_CablingMap* readCdo{*readHandle};
if(readCdo==nullptr){
ATH_MSG_ERROR("Null pointer to the read conditions object");
return StatusCode::FAILURE;
}
- return convert(readCdo->getAllROBId());
+ return convert(readCdo->getAllROBId(), ctx);
}
StatusCode Muon::MDT_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& HashVec)
{
- SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey};
+ return this->convert(HashVec, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::MDT_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& HashVec, const EventContext& ctx) const
+{
+ SG::ReadCondHandle<MuonMDT_CablingMap> readHandle{m_readKey, ctx};
const MuonMDT_CablingMap* readCdo{*readHandle};
if(readCdo==nullptr){
ATH_MSG_ERROR("Null pointer to the read conditions object");
return StatusCode::FAILURE;
}
- return convert(readCdo->getROBId(HashVec));
+ return convert(readCdo->getROBId(HashVec), ctx);
}
StatusCode Muon::MDT_RawDataProviderToolMT::convert(const std::vector<uint32_t>& robIds)
+{
+ return this->convert(robIds, Gaudi::Hive::currentContext() );
+}
+
+ StatusCode Muon::MDT_RawDataProviderToolMT::convert(const std::vector<uint32_t>& robIds, const EventContext& ctx) const
{
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
m_robDataProvider->getROBData( robIds, vecOfRobf);
- return convert(vecOfRobf); // using the old one
- }
+ return convert(vecOfRobf, ctx); // using the old one
+}
+
StatusCode Muon::MDT_RawDataProviderToolMT::convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs,
const std::vector<IdentifierHash>&)
{
- return convert(vecRobs);
+ return this->convert(vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::MDT_RawDataProviderToolMT::convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs,
+ const std::vector<IdentifierHash>& /*collection*/, const EventContext& ctx) const
+{
+ return convert(vecRobs, ctx);
+}
+
+StatusCode Muon::MDT_RawDataProviderToolMT::convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs){
+ return this->convert(vecRobs, Gaudi::Hive::currentContext() );
}
-StatusCode Muon::MDT_RawDataProviderToolMT::convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs)
+StatusCode Muon::MDT_RawDataProviderToolMT::convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const EventContext& ctx) const
{
ATH_MSG_VERBOSE("convert(): " << vecRobs.size()<<" ROBFragments.");
- SG::WriteHandle<MdtCsmContainer> rdoContainerHandle(m_rdoContainerKey);
+ SG::WriteHandle<MdtCsmContainer> rdoContainerHandle(m_rdoContainerKey, ctx);
MdtCsmContainer* rdoContainer = 0;
@@ -94,7 +120,7 @@ StatusCode Muon::MDT_RawDataProviderToolMT::convert( const std::vector<const OFF
rdoContainer = rdoContainerHandle.ptr();
} else {
// use the cache to get the container
- SG::UpdateHandle<MdtCsm_Cache> update(m_rdoContainerCacheKey);
+ SG::UpdateHandle<MdtCsm_Cache> update(m_rdoContainerCacheKey, ctx);
ATH_CHECK(update.isValid());
ATH_CHECK(rdoContainerHandle.record (std::make_unique<MdtCsmContainer>(update.ptr())));
ATH_MSG_DEBUG("Created container using cache for " << m_rdoContainerCacheKey.key());
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.h b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.h
index baea3aec274b2c6048e0326fa85849225a6a025e..ab7adbe19e234e0dda02c426f48fb6e43449e2df 100644
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.h
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MDT_RawDataProviderToolMT.h
@@ -42,6 +42,12 @@ class MDT_RawDataProviderToolMT : virtual public IMuonRawDataProviderTool, publi
virtual StatusCode convert(); //!< for the entire event
virtual StatusCode convert(const std::vector<IdentifierHash>& HashVec);
virtual StatusCode convert(const std::vector<uint32_t>& robIds);//!< for a particular vector of ROBId's
+ /** EventContext **/
+ virtual StatusCode convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const EventContext& ctx) const override;
+ virtual StatusCode convert( const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>&, const EventContext& ctx) const override;
+ virtual StatusCode convert(const EventContext& ctx) const override; //!< for the entire event
+ virtual StatusCode convert(const std::vector<IdentifierHash>& HashVec, const EventContext& ctx) const override;
+ virtual StatusCode convert(const std::vector<uint32_t>& robIds, const EventContext& ctx) const override;//!< for a particular vector of ROBId's
private:
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.cxx b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.cxx
index f1e1012cdb221f00c95f1f357b9bcbe48faa19e9..8ae3ae94313574a7638de27830c301af13d8bec1 100755
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.cxx
@@ -79,7 +79,7 @@ StatusCode MdtROD_Decoder::finalize() {
StatusCode MdtROD_Decoder::fillCollections(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag,
- MdtCsmContainer& rdoIDC)
+ MdtCsmContainer& rdoIDC) const
{
// m_debug = (m_log.level() <= MSG::DEBUG); // use to control if output debug info.
@@ -516,7 +516,7 @@ StatusCode MdtROD_Decoder::fillCollections(const OFFLINE_FRAGMENTS_NAMESPACE::RO
return StatusCode::SUCCESS;
}
-std::pair<IdentifierHash, Identifier> MdtROD_Decoder::getHash ( Identifier ident) {
+std::pair<IdentifierHash, Identifier> MdtROD_Decoder::getHash ( Identifier ident) const {
//get hash from identifier.
IdentifierHash idHash;
Identifier regid;
diff --git a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.h b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.h
index 6e2bfed0ed5616853f14fd4b6ca0293f3e6a8381..319b71c7e7a9623aac9aeef70eedb0cebeac8c16 100755
--- a/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.h
+++ b/MuonSpectrometer/MuonCnv/MuonMDT_CnvTools/src/MdtROD_Decoder.h
@@ -7,6 +7,7 @@
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
+#include "CxxUtils/checker_macros.h"
#include "MdtRODReadOut.h"
#include "MdtCsmReadOut.h"
@@ -55,11 +56,11 @@ public:
MDT_Hid2RESrcID* getHid2RE() {return m_hid2re;}
StatusCode fillCollections(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag,
- MdtCsmContainer& rdoIDC);
+ MdtCsmContainer& rdoIDC) const;
int specialROBNumber() const {return m_specialROBNumber;}
- std::pair<IdentifierHash, Identifier> getHash (Identifier ident);
+ std::pair<IdentifierHash, Identifier> getHash (Identifier ident) const;
private:
MDT_Hid2RESrcID* m_hid2re;
@@ -82,8 +83,9 @@ private:
int m_BMGid;
// variables to count how often the caching kicks in
- unsigned int m_nCache = 0;
- unsigned int m_nNotCache = 0;
+ // Mutable as this is just to count calls of const function
+ mutable std::atomic_uint m_nCache ATLAS_THREAD_SAFE = 0 ;
+ mutable std::atomic_uint m_nNotCache ATLAS_THREAD_SAFE = 0 ;
};
#endif
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/MuonRPC_CnvTools/IRpcROD_Decoder.h b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/MuonRPC_CnvTools/IRpcROD_Decoder.h
index edd56b65e83063bbd9be12639cb442d9c1ed2049..06210c877ff3ee45b9d4ba6eec8bef6ad2d7c00a 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/MuonRPC_CnvTools/IRpcROD_Decoder.h
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/MuonRPC_CnvTools/IRpcROD_Decoder.h
@@ -27,11 +27,10 @@ public:
}
// enter declaration of your interface-defining member functions here
+ // bool decodeSL - Used to determine whether sector logic is being decoded too
virtual StatusCode fillCollections(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag,
- RpcPadContainer& rdoIdc,
- const std::vector<IdentifierHash> &collections, RpcSectorLogicContainer*) const = 0;
+ RpcPadContainer& rdoIdc, const std::vector<IdentifierHash> &collections, RpcSectorLogicContainer*, const bool& decodeSL) const = 0;
- virtual void setSLdecodingRequest() = 0;
};
} // end of namespace
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.cxx b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.cxx
index af3822f5fcbcb5a8bb42dcf0e540d3ef75dea652..7374cd874b5fb58689d64ec02c2e3f43f97b71c9 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.cxx
@@ -59,41 +59,65 @@ StatusCode Muon::RPC_RawDataProviderTool::initialize()
// the new one
StatusCode Muon::RPC_RawDataProviderTool::convert()
{
- SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey};
+ return this->convert( Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderTool::convert(const EventContext& ctx) const
+{
+ SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey, ctx};
const RpcCablingCondData* readCdo{*readHandle};
//CALLGRIND_START_INSTRUMENTATION
///
- m_decoder->setSLdecodingRequest();
+ //m_decoder->setSLdecodingRequest();
+ // We used to set a variable in decoder to turn on SL decoding, but not allowed with const functions
+ // So we will pass this through with EventContext and it was only active when running
+ // full decoding it seems
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
std::vector<uint32_t> robIds = readCdo->giveFullListOfRobIds();
m_robDataProvider->getROBData( robIds, vecOfRobf);
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecOfRobf); // using the old one
+ return convert(vecOfRobf, ctx); // using the old one
}
+
// the old one
StatusCode Muon::RPC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs)
+{
+ return this->convert( vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs, const EventContext& ctx) const
{
//CALLGRIND_START_INSTRUMENTATION
std::vector<IdentifierHash> collections;
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecRobs,collections);
+ return convert(vecRobs, collections, ctx);
}
// the new one
StatusCode Muon::RPC_RawDataProviderTool::convert(const std::vector<uint32_t>& robIds)
+{
+ return this->convert( robIds, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderTool::convert(const std::vector<uint32_t>& robIds, const EventContext& ctx) const
{
//CALLGRIND_START_INSTRUMENTATION
std::vector<IdentifierHash> collections;
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
m_robDataProvider->getROBData(robIds, vecOfRobf);
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecOfRobf,collections);
+ return convert(vecOfRobf, collections, ctx);
}
// the new one
StatusCode Muon::RPC_RawDataProviderTool::convert(const std::vector<IdentifierHash>& rdoIdhVect)
{
- SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey};
+ return this->convert( rdoIdhVect, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderTool::convert(const std::vector<IdentifierHash>& rdoIdhVect, const EventContext& ctx) const
+{
+ SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey, ctx};
const RpcCablingCondData* readCdo{*readHandle};
//CALLGRIND_START_INSTRUMENTATION
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
@@ -101,11 +125,16 @@ StatusCode Muon::RPC_RawDataProviderTool::convert(const std::vector<IdentifierHa
CHECK( readCdo->giveROB_fromRDO(rdoIdhVect, robIds) );
m_robDataProvider->getROBData(robIds, vecOfRobf);
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecOfRobf, rdoIdhVect); // using the old one
+ return convert(vecOfRobf, rdoIdhVect, ctx); // using the old one
}
+
// the old one
-StatusCode Muon::RPC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs,
- const std::vector<IdentifierHash>& collections)
+StatusCode Muon::RPC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& collections)
+{
+ return this->convert( vecRobs, collections, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& collections, const EventContext& ctx) const
{
//CALLGRIND_START_INSTRUMENTATION
@@ -119,8 +148,8 @@ StatusCode Muon::RPC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs
// on the user experience
}
- SG::WriteHandle<RpcPadContainer> rdoContainerHandle(m_containerKey);
- SG::WriteHandle<RpcSectorLogicContainer> logicHandle(m_sec);
+ SG::WriteHandle<RpcPadContainer> rdoContainerHandle(m_containerKey, ctx);
+ SG::WriteHandle<RpcSectorLogicContainer> logicHandle(m_sec, ctx);
RpcPadContainer* pad = 0;
RpcSectorLogicContainer* logic = 0;
@@ -146,7 +175,7 @@ StatusCode Muon::RPC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs
}
// pass the containers to the convertIntoContainers function in the RPC_RawDataProviderToolCore base class
- ATH_CHECK( convertIntoContainers(vecRobs, collections, pad, logic) );
+ ATH_CHECK( convertIntoContainers(vecRobs, collections, pad, logic, true) );
return StatusCode::SUCCESS;
}
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.h b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.h
index e4029a4431dce8785c959bf2a3fce4d0f54b2847..9fd8592ebd15805b3e0034100ad9eec74d77d5e3 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.h
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderTool.h
@@ -38,12 +38,18 @@ class ATLAS_NOT_THREAD_SAFE RPC_RawDataProviderTool : virtual public IMuonRawDat
/** Decoding method. - current methods: let's keep them! */
virtual StatusCode convert(const ROBFragmentList& vecRobs);
- virtual StatusCode convert(const ROBFragmentList& vecRobs,
- const std::vector<IdentifierHash>& coll);
+ virtual StatusCode convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& coll);
/** the new ones */
virtual StatusCode convert(); //!< for the entire event
virtual StatusCode convert(const std::vector<IdentifierHash>&); //!< for a selection of rdo collections
virtual StatusCode convert(const std::vector<uint32_t>&);
+ /** EventContext ones **/
+ virtual StatusCode convert(const ROBFragmentList&, const EventContext&) const override;
+ virtual StatusCode convert(const ROBFragmentList&, const std::vector<IdentifierHash>&, const EventContext&) const override;
+ virtual StatusCode convert(const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<IdentifierHash>&, const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<uint32_t>&, const EventContext&) const override;
+
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.cxx b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.cxx
index 5afd17ed95c4271b3c14a201cb05da72090bbfe4..a97d3dadc99295cbd6afd17cada68017220d6f5d 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.cxx
@@ -35,8 +35,7 @@ StatusCode Muon::RPC_RawDataProviderToolCore::initialize()
}
-StatusCode Muon::RPC_RawDataProviderToolCore::convertIntoContainers(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>& collections,
- RpcPadContainer* pad, RpcSectorLogicContainer* logic) const {
+StatusCode Muon::RPC_RawDataProviderToolCore::convertIntoContainers(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>& collections, RpcPadContainer* pad, RpcSectorLogicContainer* logic, const bool& decodeSL) const {
for (auto itFrag = vecRobs.begin(); itFrag != vecRobs.end(); itFrag++)
{
@@ -45,7 +44,7 @@ StatusCode Muon::RPC_RawDataProviderToolCore::convertIntoContainers(const std::v
{
std::vector<IdentifierHash> coll = to_be_converted(**itFrag,collections);
- if (m_decoder->fillCollections(**itFrag, *pad, coll, logic).isFailure())
+ if (m_decoder->fillCollections(**itFrag, *pad, coll, logic, decodeSL).isFailure())
{
// store the error conditions into the StatusCode and continue
}
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.h b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.h
index c6c202fb6bbefd38eebb538a173d3ecfeab120b5..5a69b577340079a414a42c3c3ab4165e7c3ddc5a 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.h
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolCore.h
@@ -40,8 +40,7 @@ namespace Muon
protected:
// This function does all the actual work of decoding the data
- StatusCode convertIntoContainers(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>& collections,
- RpcPadContainer* pad, RpcSectorLogicContainer* logic) const;
+ StatusCode convertIntoContainers(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, const std::vector<IdentifierHash>& collections, RpcPadContainer* pad, RpcSectorLogicContainer* logic, const bool& decodeSL) const;
std::vector<IdentifierHash> to_be_converted(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag,
const std::vector<IdentifierHash>& coll) const;
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.cxx b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.cxx
index ef8685c83753e9d16149d085a70bf786beb5d644..3faa1b3d682513aa82a2b228de189883ddcf5368 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.cxx
@@ -55,41 +55,60 @@ StatusCode Muon::RPC_RawDataProviderToolMT::initialize()
// the new one
StatusCode Muon::RPC_RawDataProviderToolMT::convert()
{
- SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey};
+ return this->convert( Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderToolMT::convert(const EventContext& ctx) const
+{
+ SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey, ctx};
const RpcCablingCondData* readCdo{*readHandle};
//CALLGRIND_START_INSTRUMENTATION
///
- m_decoder->setSLdecodingRequest();
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
std::vector<uint32_t> robIds = readCdo->giveFullListOfRobIds();
m_robDataProvider->getROBData( robIds, vecOfRobf);
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecOfRobf); // using the old one
+ return convert(vecOfRobf, ctx); // using the old one
}
// the old one
StatusCode Muon::RPC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs)
+{
+ return this->convert( vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs, const EventContext& ctx) const
{
//CALLGRIND_START_INSTRUMENTATION
std::vector<IdentifierHash> collections;
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecRobs,collections);
+ return convert(vecRobs,collections, ctx);
}
// the new one
StatusCode Muon::RPC_RawDataProviderToolMT::convert(const std::vector<uint32_t>& robIds)
+{
+ return this->convert( robIds, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderToolMT::convert(const std::vector<uint32_t>& robIds, const EventContext& ctx) const
{
//CALLGRIND_START_INSTRUMENTATION
std::vector<IdentifierHash> collections;
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
m_robDataProvider->getROBData(robIds, vecOfRobf);
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecOfRobf,collections);
+ return convert(vecOfRobf,collections, ctx);
}
// the new one
StatusCode Muon::RPC_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& rdoIdhVect)
{
- SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey};
+ return this->convert( rdoIdhVect, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& rdoIdhVect, const EventContext& ctx) const
+{
+ SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey, ctx};
const RpcCablingCondData* readCdo{*readHandle};
//CALLGRIND_START_INSTRUMENTATION
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
@@ -97,16 +116,20 @@ StatusCode Muon::RPC_RawDataProviderToolMT::convert(const std::vector<Identifier
CHECK( readCdo->giveROB_fromRDO(rdoIdhVect, robIds) );
m_robDataProvider->getROBData(robIds, vecOfRobf);
//CALLGRIND_STOP_INSTRUMENTATION
- return convert(vecOfRobf, rdoIdhVect); // using the old one
+ return convert(vecOfRobf, rdoIdhVect, ctx); // using the old one
}
// the old one
-StatusCode Muon::RPC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs,
- const std::vector<IdentifierHash>& collections)
+StatusCode Muon::RPC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& collections)
+{
+ return this->convert( vecRobs, collections, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::RPC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& collections, const EventContext& ctx) const
{
//CALLGRIND_START_INSTRUMENTATION
- SG::WriteHandle<RpcPadContainer> rdoContainerHandle(m_containerKey);
- SG::WriteHandle<RpcSectorLogicContainer> logicHandle(m_sec);
+ SG::WriteHandle<RpcPadContainer> rdoContainerHandle(m_containerKey, ctx);
+ SG::WriteHandle<RpcSectorLogicContainer> logicHandle(m_sec, ctx);
// run 3 mode, here we always try to write the containers
@@ -117,7 +140,7 @@ StatusCode Muon::RPC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRo
ATH_MSG_DEBUG( "Created RpcPadContainer" );
}
else{
- SG::UpdateHandle<RpcPad_Cache> update(m_rdoContainerCacheKey);
+ SG::UpdateHandle<RpcPad_Cache> update(m_rdoContainerCacheKey, ctx);
ATH_CHECK(update.isValid());
ATH_CHECK(rdoContainerHandle.record (std::make_unique<RpcPadContainer>( update.ptr() )));
ATH_MSG_DEBUG("Created container using cache for " << m_rdoContainerCacheKey.key());
@@ -132,7 +155,7 @@ StatusCode Muon::RPC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRo
}
// pass the containers to the convertIntoContainers function in the RPC_RawDataProviderToolCore base class
- ATH_CHECK( convertIntoContainers(vecRobs, collections, pad, logic) );
+ ATH_CHECK( convertIntoContainers(vecRobs, collections, pad, logic, true) );
return StatusCode::SUCCESS;
}
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.h b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.h
index 4dab40fd082290c4d7368b3aa51be4a0ceb75545..8b5124c200909fcd3badddca4cced92ac29ccb70 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.h
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RPC_RawDataProviderToolMT.h
@@ -41,13 +41,17 @@ class RPC_RawDataProviderToolMT : virtual public IMuonRawDataProviderTool,
/** Decoding method. - current methods: let's keep them! */
virtual StatusCode convert(const ROBFragmentList& vecRobs);
- virtual StatusCode convert(const ROBFragmentList& vecRobs,
- const std::vector<IdentifierHash>& coll);
+ virtual StatusCode convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& coll);
/** the new ones */
virtual StatusCode convert(); //!< for the entire event
virtual StatusCode convert(const std::vector<IdentifierHash>&); //!< for a selection of rdo collections
virtual StatusCode convert(const std::vector<uint32_t>&);
-
+ /** EventContext ones **/
+ virtual StatusCode convert(const ROBFragmentList&, const EventContext&) const override;
+ virtual StatusCode convert(const ROBFragmentList&, const std::vector<IdentifierHash>&, const EventContext&) const override;
+ virtual StatusCode convert(const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<IdentifierHash>&, const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<uint32_t>&, const EventContext&) const override;
private:
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.cxx b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.cxx
index e5460e358c54a069e5c3b0215206a5ea93ca74d9..55336736a6b72003bc97b262af13a6cefdc355db 100755
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.cxx
@@ -16,8 +16,7 @@
#include "AthenaBaseComps/AthAlgTool.h"
Muon::RpcROD_Decoder::RpcROD_Decoder (const std::string& type, const std::string& name, const IInterface* parent) :
- AthAlgTool(type,name,parent),
- m_decodeSL(false) {
+ AthAlgTool(type,name,parent) {
declareInterface< IRpcROD_Decoder >( this );
declareProperty("SpecialROBNumber",m_specialROBNumber=-1);
declareProperty("Sector13Data",m_sector13Data=false);
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.h b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.h
index b5a1d27b5826924caa3b65824fd8c2321e48b51d..a71df809bef9cb5091f2c21a05b2cc33cae0607d 100755
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.h
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder.h
@@ -71,18 +71,15 @@ namespace Muon
// implementation of the abstract interface
StatusCode fillCollections(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag,
RpcPadContainer& rdoIdc,
- const std::vector<IdentifierHash> &collections, RpcSectorLogicContainer*) const override;
+ const std::vector<IdentifierHash> &collections, RpcSectorLogicContainer*, const bool& decodeSL) const override;
int specialROBNumber() const {return m_specialROBNumber;}
bool isSector13Data() const {return m_sector13Data;}
- virtual void setSLdecodingRequest() override {m_decodeSL=true;}
private:
- bool m_decodeSL;
-
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType BS;
@@ -94,12 +91,12 @@ namespace Muon
// decoding of real data - 2010 & 2011 _v302
StatusCode fillCollection_v302new(BS data, const uint32_t data_size, RpcPad& v,
- const uint32_t& sourceId, RpcSectorLogicContainer* ) const;
+ const uint32_t& sourceId, RpcSectorLogicContainer*, const bool& ) const;
StatusCode fillCollection_v302(BS data, const uint32_t data_size, RpcPad& v,
const uint32_t& sourceId,RpcSectorLogicContainer* ) const;
// decoding of real data - 2010 & 2011 _v302
StatusCode fillCollectionsFromRob_v302(BS data, const uint32_t data_size, std::map<Identifier,RpcPad*>& vmap,
- const uint32_t& sourceId, RpcSectorLogicContainer* ) const;
+ const uint32_t& sourceId, RpcSectorLogicContainer*, const bool& decodeSL) const;
// fragment each of the 32 bit words into 2 16 bit words!
@@ -354,7 +351,7 @@ namespace Muon
inline StatusCode
RpcROD_Decoder::fillCollections(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag,
RpcPadContainer& rdoIdc,
- const std::vector<IdentifierHash> &collections, RpcSectorLogicContainer* RPC_SECTORLOGIC) const
+ const std::vector<IdentifierHash> &collections, RpcSectorLogicContainer* RPC_SECTORLOGIC, const bool& decodeSL) const
{
try
@@ -411,6 +408,7 @@ namespace Muon
{
type = 2;
ATH_MSG_VERBOSE("choosing fillCollection_v302");
+ ATH_MSG_VERBOSE("with decodeSL when decoding from ROB " << decodeSL); // Only meaningful for this function
}
@@ -457,7 +455,7 @@ namespace Muon
}
// RpcPadCollections not decoded and in container are identified and passed explicitly to decoder
- cnv_sc = fillCollectionsFromRob_v302(data,robFrag.rod_ndata(),mapOfCollections,rod_sourceId, RPC_SECTORLOGIC);
+ cnv_sc = fillCollectionsFromRob_v302(data,robFrag.rod_ndata(),mapOfCollections,rod_sourceId, RPC_SECTORLOGIC, decodeSL);
if (cnv_sc!=StatusCode::SUCCESS)
{
if (cnv_sc==StatusCode::RECOVERABLE)
diff --git a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder_v302.C b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder_v302.C
index d864e4c506dfc58d37e61392b0526bf23a0e48ff..58b97a6c4a4c7118ef5c0b52961e2dfe06347e5b 100644
--- a/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder_v302.C
+++ b/MuonSpectrometer/MuonCnv/MuonRPC_CnvTools/src/RpcROD_Decoder_v302.C
@@ -3,13 +3,13 @@
*/
StatusCode Muon::RpcROD_Decoder::fillCollection_v302new(BS data, const uint32_t data_size, RpcPad& v,
- const uint32_t& sourceId, RpcSectorLogicContainer* sectorLogicContainer ) const
+ const uint32_t& sourceId, RpcSectorLogicContainer* sectorLogicContainer, const bool& decodeSL) const
{
ATH_MSG_VERBOSE("in fillCollection_v302new");
std::map<Identifier,RpcPad*> vmap;
vmap[v.identify()]=&v;
- StatusCode cnvsc= fillCollectionsFromRob_v302(data,data_size,vmap,sourceId, sectorLogicContainer);
+ StatusCode cnvsc= fillCollectionsFromRob_v302(data,data_size,vmap,sourceId, sectorLogicContainer, decodeSL);
if (cnvsc!=StatusCode::SUCCESS)
{
ATH_MSG_DEBUG("Some decoding problem observed");
@@ -18,8 +18,7 @@ StatusCode Muon::RpcROD_Decoder::fillCollection_v302new(BS data, const uint32_t
}
-StatusCode Muon::RpcROD_Decoder::fillCollectionsFromRob_v302(BS data, const uint32_t data_size, std::map<Identifier,RpcPad*>& vmap, const uint32_t& sourceId,
- RpcSectorLogicContainer* sectorLogicContainer ) const
+StatusCode Muon::RpcROD_Decoder::fillCollectionsFromRob_v302(BS data, const uint32_t data_size, std::map<Identifier,RpcPad*>& vmap, const uint32_t& sourceId, RpcSectorLogicContainer* sectorLogicContainer, const bool& decodeSL ) const
{
bool skipSectorLogicDecoding = (sectorLogicContainer == nullptr);
@@ -617,7 +616,7 @@ StatusCode Muon::RpcROD_Decoder::fillCollectionsFromRob_v302(BS data, const uint
if ((unsigned int)nDecodedPads==vmap.size())
{
ATH_MSG_DEBUG("All pads requested are found and decoded");
- if (!m_decodeSL)
+ if (!decodeSL)
{
ATH_MSG_DEBUG("... since no SL decoding is requested exit here");
return StatusCode::SUCCESS;
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/MuonTGC_CnvTools/ITGC_RodDecoder.h b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/MuonTGC_CnvTools/ITGC_RodDecoder.h
index d32d66a3a4d5ac78a5f4954f1b4e22e5fb450245..9d9a7dd290dd5606ed572d50b53a8cb0db4cdbc0 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/MuonTGC_CnvTools/ITGC_RodDecoder.h
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/MuonTGC_CnvTools/ITGC_RodDecoder.h
@@ -35,7 +35,7 @@ namespace Muon
}
/** Convert ROBFragments to RDOs */
- virtual StatusCode fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdoContainer& rdoIdc) = 0;
+ virtual StatusCode fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const = 0;
};
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.cxx b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.cxx
index 6897e9767406b27c3071feef18e3a111ec61f3a8..5c49d5c5f83a029e4fe4c92645002c5cf0511b70 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.cxx
@@ -41,7 +41,7 @@ uint32_t Muon::TGC_Hid2RESrcID::getRodID(uint16_t subDetectorId, uint16_t rodId)
}
// get source ID for an TgcDigitCollection
-uint32_t Muon::TGC_Hid2RESrcID::getRodID(const Identifier& offlineId)
+uint32_t Muon::TGC_Hid2RESrcID::getRodID(const Identifier& offlineId) const
{
int subDetectorId;
int rodId;
@@ -56,7 +56,7 @@ uint32_t Muon::TGC_Hid2RESrcID::getRodID(const Identifier& offlineId)
}
// mapping SrcID from ROD to ROB
-uint32_t Muon::TGC_Hid2RESrcID::getRobID(uint32_t rod_id)
+uint32_t Muon::TGC_Hid2RESrcID::getRobID(uint32_t rod_id) const
{
// return Source ID.
// ROD source ID and ROB source ID are identical for TGC.
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.h b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.h
index 3a7805dde0af56af84b4f9205d736330d7813947..bdfc65c1dd5d6117fe5dd89cef1cc74402b0bc47 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.h
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_Hid2RESrcID.h
@@ -43,16 +43,16 @@ namespace Muon
/** Make a ROD Source ID for SubDetector ID and ROD ID. */
uint32_t getRodID(uint16_t subDetectorId, uint16_t rodId);
/** Make a ROD Source ID for TgcDigitCollection. */
- uint32_t getRodID(const Identifier & offlineId);
+ uint32_t getRodID(const Identifier & offlineId) const;
/** Make a ROB Source ID from a ROD source ID. */
- uint32_t getRobID (uint32_t rod_id);
+ uint32_t getRobID (uint32_t rod_id) const;
/** Make a ROS Source ID from a ROB source ID. */
uint32_t getRosID (uint32_t rob_id);
/** Make a SubDetector ID from ROS source ID. */
uint32_t getDetID (uint32_t ros_id);
/** Return all the ROB IDs. */
- const std::vector<uint32_t>& allRobIds() { return m_robIDs; }
+ const std::vector<uint32_t>& allRobIds() const { return m_robIDs; }
private:
/** Fill all the ROB IDs. */
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.cxx b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.cxx
index e71b11aaaa0ff98f486300a33893b38ad4e5735c..811ae265151bc70dfc373a77dd42e7826b847cb3 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.cxx
@@ -30,10 +30,14 @@ StatusCode Muon::TGC_RawDataProviderTool::initialize()
//============================================================================================
-StatusCode Muon::TGC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs)
+StatusCode Muon::TGC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs){
+ return this->convert( vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::TGC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs, const EventContext& ctx) const
{
- SG::WriteHandle<TgcRdoContainer> rdoContainerHandle(m_rdoContainerKey);
+ SG::WriteHandle<TgcRdoContainer> rdoContainerHandle(m_rdoContainerKey, ctx);
TgcRdoContainer* rdoContainer = 0;
@@ -57,17 +61,25 @@ StatusCode Muon::TGC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs
return convertIntoContainer(vecRobs, *rdoContainer);
}
-StatusCode Muon::TGC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs,
- const std::vector<IdentifierHash>&)
+StatusCode Muon::TGC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>&){
+ // This function does not use the IdentifierHash so we pass to the EventContext function which also does not use it
+ return this->convert( vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::TGC_RawDataProviderTool::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& /*ids*/, const EventContext& ctx) const
{
- return convert(vecRobs);
+ return convert(vecRobs, ctx);
+}
+
+StatusCode Muon::TGC_RawDataProviderTool::convert(){
+ return this->convert( Gaudi::Hive::currentContext() );
}
-StatusCode Muon::TGC_RawDataProviderTool::convert()
+StatusCode Muon::TGC_RawDataProviderTool::convert(const EventContext& ctx) const
{
if(!m_cabling) {
- StatusCode sc = getCabling();
- if(sc.isFailure()) return sc;
+ ATH_MSG_ERROR("Tgc cabling is not available and needs to be set in initialise");
+ return StatusCode::FAILURE;
}
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
@@ -75,13 +87,18 @@ StatusCode Muon::TGC_RawDataProviderTool::convert()
m_robDataProvider->getROBData(robIds, vecOfRobf);
- return convert(vecOfRobf);
+ return convert(vecOfRobf, ctx);
}
-StatusCode Muon::TGC_RawDataProviderTool::convert(const std::vector<IdentifierHash>& rdoIdhVect)
+StatusCode Muon::TGC_RawDataProviderTool::convert(const std::vector<IdentifierHash>& rdoIdhVect){
+ return this->convert( rdoIdhVect, Gaudi::Hive::currentContext() );
+}
+
+
+StatusCode Muon::TGC_RawDataProviderTool::convert(const std::vector<IdentifierHash>& rdoIdhVect, const EventContext& ctx) const
{
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf = getROBData(rdoIdhVect);
- return convert(vecOfRobf, rdoIdhVect);
+ return convert(vecOfRobf, rdoIdhVect, ctx);
}
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.h b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.h
index 6e047c09dc90af52e94e6b77636f94271bb1cbc6..60fe7f011285640a5dbe714e5ac3f88769ef378d 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.h
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderTool.h
@@ -43,11 +43,20 @@ namespace Muon
virtual StatusCode convert();
/** New decoding methods which do not use IROBDataProviderSvc in TgcRdoToPrepDataTool with ID Hash vector */
virtual StatusCode convert(const std::vector<IdentifierHash>& rdoIdhVect);
+
+ /** EventContext ones **/
+ virtual StatusCode convert(const ROBFragmentList&, const EventContext&) const override;
+ virtual StatusCode convert(const ROBFragmentList&, const std::vector<IdentifierHash>&, const EventContext&) const override;
+ virtual StatusCode convert(const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<IdentifierHash>&, const EventContext&) const override;
private:
/** convert from vector of ROB IDs is not available */
virtual StatusCode convert(const std::vector<uint32_t>&) {return StatusCode::FAILURE;}
+ /** EventContext ones **/
+ virtual StatusCode convert(const std::vector<uint32_t>&, const EventContext&) const override {return StatusCode::FAILURE;}
+
};
} // end of namespace
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.cxx b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.cxx
index 4b8e574f5ccd6775ea896a5077ce6f3841f27f33..b434fb4ef41020675356f0dad0f15266da5fbee2 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.cxx
@@ -40,7 +40,8 @@ StatusCode Muon::TGC_RawDataProviderToolCore::initialize()
//try to configure the cabling service
StatusCode sc = getCabling();
if(sc.isFailure()) {
- ATH_MSG_INFO( "TGCcablingServerSvc not yet configured; postone TGCcabling initialization at first event. " );
+ ATH_MSG_ERROR( "TGCcablingServerSvc not yet configured, but this needs to be available when TGC_RawDataProviderToolCore is initalised as we cannot create it on the fly during event processing inside const decode functions.");
+ return StatusCode::FAILURE;
}
return StatusCode::SUCCESS;
@@ -48,7 +49,7 @@ StatusCode Muon::TGC_RawDataProviderToolCore::initialize()
//============================================================================================
-StatusCode Muon::TGC_RawDataProviderToolCore::convertIntoContainer(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, TgcRdoContainer& tgcRdoContainer)
+StatusCode Muon::TGC_RawDataProviderToolCore::convertIntoContainer(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, TgcRdoContainer& tgcRdoContainer) const
{
/// Static variables are not thread safe
@@ -84,7 +85,6 @@ StatusCode Muon::TGC_RawDataProviderToolCore::getCabling() {
sc = TgcCabGet->giveCabling(m_cabling);
if(sc.isFailure()) {
ATH_MSG_FATAL( "Could not get ITGCcablingSvc from the Server !" );
- m_cabling = 0;
return StatusCode::FAILURE;
} else {
ATH_MSG_VERBOSE( "ITGCcablingSvc obtained" );
@@ -96,14 +96,12 @@ StatusCode Muon::TGC_RawDataProviderToolCore::getCabling() {
}
-std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> Muon::TGC_RawDataProviderToolCore::getROBData(const std::vector<IdentifierHash>& rdoIdhVect) {
+std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> Muon::TGC_RawDataProviderToolCore::getROBData(const std::vector<IdentifierHash>& rdoIdhVect) const {
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
if(!m_cabling) {
- if( getCabling().isFailure() ) {
ATH_MSG_ERROR("Could not get cabling, return empty vector of ROB fragments");
return vecOfRobf;
- }
}
IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.h b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.h
index 973c6464116330f1781799d10316acbd49a39cd6..cde75104c7626f67c5ac5732b59ef929a8c7bf81 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.h
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolCore.h
@@ -39,12 +39,12 @@ namespace Muon {
virtual StatusCode initialize();
/** Method that converts the ROBFragments into the passed container */
- virtual StatusCode convertIntoContainer(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, TgcRdoContainer& tgcRdoContainer);
+ virtual StatusCode convertIntoContainer(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vecRobs, TgcRdoContainer& tgcRdoContainer) const;
protected:
/** Function to get the ROB data from a vector of IdentifierHash **/
- std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> getROBData(const std::vector<IdentifierHash>& rdoIdhVect);
+ std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> getROBData(const std::vector<IdentifierHash>& rdoIdhVect) const;
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
/** Decoder for ROB fragment RDO conversion */
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.cxx b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.cxx
index 75a89d01873e6da1bcb46217e106da72e2e48831..ee6595596ffcf9959ea3cc6b74af09414200a7b5 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.cxx
@@ -34,10 +34,14 @@ StatusCode Muon::TGC_RawDataProviderToolMT::initialize()
//============================================================================================
-StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs)
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs){
+ return this->convert( vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs, const EventContext& ctx) const
{
- SG::WriteHandle<TgcRdoContainer> rdoContainerHandle(m_rdoContainerKey);
+ SG::WriteHandle<TgcRdoContainer> rdoContainerHandle(m_rdoContainerKey, ctx);
// Split the methods to have one where we use the cache and one where we just setup the container
const bool externalCacheRDO = !m_rdoContainerCacheKey.key().empty();
@@ -46,7 +50,7 @@ StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRo
ATH_MSG_DEBUG( "Created TGC container" );
}
else{
- SG::UpdateHandle<TgcRdo_Cache> update(m_rdoContainerCacheKey);
+ SG::UpdateHandle<TgcRdo_Cache> update(m_rdoContainerCacheKey, ctx);
ATH_CHECK(update.isValid());
ATH_CHECK(rdoContainerHandle.record (std::make_unique<TgcRdoContainer>( update.ptr() )));
ATH_MSG_DEBUG("Created container using cache for " << m_rdoContainerCacheKey.key());
@@ -63,17 +67,25 @@ StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRo
return convertIntoContainer(vecRobs, *rdoContainer);
}
-StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs,
- const std::vector<IdentifierHash>&)
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>&){
+ // This function does not use the IdentifierHash so we pass to the EventContext function which also does not use it
+ return this->convert( vecRobs, Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(const ROBFragmentList& vecRobs, const std::vector<IdentifierHash>& /*ids*/, const EventContext& ctx) const
{
- return convert(vecRobs);
+ return convert(vecRobs, ctx);
}
-StatusCode Muon::TGC_RawDataProviderToolMT::convert()
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(){
+ return this->convert( Gaudi::Hive::currentContext() );
+}
+
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(const EventContext& ctx) const
{
if(!m_cabling) {
- StatusCode sc = getCabling();
- if(sc.isFailure()) return sc;
+ ATH_MSG_ERROR("Tgc cabling is not available and needs to be set in initialise");
+ return StatusCode::FAILURE;
}
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf;
@@ -81,13 +93,17 @@ StatusCode Muon::TGC_RawDataProviderToolMT::convert()
m_robDataProvider->getROBData(robIds, vecOfRobf);
- return convert(vecOfRobf);
+ return convert(vecOfRobf, ctx);
+}
+
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& rdoIdhVect){
+ return this->convert( rdoIdhVect, Gaudi::Hive::currentContext() );
}
-StatusCode Muon::TGC_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& rdoIdhVect)
+StatusCode Muon::TGC_RawDataProviderToolMT::convert(const std::vector<IdentifierHash>& rdoIdhVect, const EventContext& ctx) const
{
std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*> vecOfRobf = getROBData(rdoIdhVect);
- return convert(vecOfRobf, rdoIdhVect);
+ return convert(vecOfRobf, rdoIdhVect, ctx);
}
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.h b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.h
index 7bcd24af68d54e00323ca017d77a4ea1da43e20c..1fbada24c0072627d4ee031f1b5d6c0f39012b06 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.h
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RawDataProviderToolMT.h
@@ -43,12 +43,20 @@ namespace Muon
/** New decoding methods which do not use IROBDataProviderSvc in TgcRdoToPrepDataTool with ID Hash vector */
virtual StatusCode convert(const std::vector<IdentifierHash>& rdoIdhVect);
+ /** EventContext ones **/
+ virtual StatusCode convert(const ROBFragmentList&, const EventContext&) const override;
+ virtual StatusCode convert(const ROBFragmentList&, const std::vector<IdentifierHash>&, const EventContext&) const override;
+ virtual StatusCode convert(const EventContext&) const override;
+ virtual StatusCode convert(const std::vector<IdentifierHash>&, const EventContext&) const override;
+
private:
// TGC container cache key
SG::UpdateHandleKey<TgcRdo_Cache> m_rdoContainerCacheKey ;
/** convert from vector of ROB IDs is not available */
virtual StatusCode convert(const std::vector<uint32_t>&) {return StatusCode::FAILURE;}
+ /** EventContext ones **/
+ virtual StatusCode convert(const std::vector<uint32_t>&, const EventContext&) const override {return StatusCode::FAILURE;}
};
} // end of namespace
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.cxx b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.cxx
index 232576c5b5812c643a7b18e639eab598aac5354f..da05c97c1562ae7e6c343f6b73bce69880857f8c 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.cxx
@@ -65,7 +65,7 @@ StatusCode Muon::TGC_RodDecoderRawdata::finalize()
//================ fillCollection ===============================================
-StatusCode Muon::TGC_RodDecoderRawdata::fillCollection(const ROBFragment& robFrag, TgcRdoContainer& rdoIdc)
+StatusCode Muon::TGC_RodDecoderRawdata::fillCollection(const ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const
{
try
{
@@ -164,7 +164,7 @@ TgcRdo* Muon::TGC_RodDecoderRawdata::getCollection(const ROBFragment& robFrag, T
void Muon::TGC_RodDecoderRawdata::byteStream2Rdo(OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs,
TgcRdo& rdo,
- uint32_t source_id)
+ uint32_t source_id) const
{
ATH_MSG_DEBUG( "Muon::TGC_RodDecoder::byteStream2Rdo" );
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.h b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.h
index fa81a39e4a099c5e663622b4b15a76de744dcd4f..12f81dbc4536c0e7142f758ca0422ad9ebfd0932 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.h
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderRawdata.h
@@ -43,14 +43,14 @@ namespace Muon
/** Standard AlgTool method */
virtual StatusCode finalize();
/** Convert ROBFragment to RDO */
- virtual StatusCode fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdoContainer& rdoIdc);
+ virtual StatusCode fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const;
private:
/** Retrieve header of ROBFragment */
TgcRdo* getCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const;
/** Convert data contents of ROBFragment to RDO
* The same byteStream2Rdo method in TGC_RodDecoderReadout is used for checking conversion validation */
- void byteStream2Rdo(OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs, TgcRdo& rdo, uint32_t source_id);
+ void byteStream2Rdo(OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs, TgcRdo& rdo, uint32_t source_id) const;
/** Show status words */
void showStatusWords(const uint32_t source_id, const uint16_t rdoId, const int idHash,
const uint32_t nstatus, const uint32_t* status) const;
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.cxx b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.cxx
index ca202ea2db5c52dc03b7a7bd2911021104c92510..e6665987f932ee80758930f40cc92b7f576ee68c 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.cxx
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.cxx
@@ -76,7 +76,7 @@ StatusCode Muon::TGC_RodDecoderReadout::finalize()
//================ fillCollection ===============================================
-StatusCode Muon::TGC_RodDecoderReadout::fillCollection(const ROBFragment& robFrag, TgcRdoContainer& rdoIdc)
+StatusCode Muon::TGC_RodDecoderReadout::fillCollection(const ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const
{
try
{
@@ -164,7 +164,7 @@ void Muon::TGC_RodDecoderReadout::getCollection(const ROBFragment& robFrag, TgcR
void Muon::TGC_RodDecoderReadout::byteStream2Rdo(OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs,
TgcRdo* rdo,
- uint32_t source_id)
+ uint32_t source_id) const
{
ATH_MSG_DEBUG( "Muon::TGC_RodDecoderReadout::byteStream2Rdo" );
diff --git a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.h b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.h
index 2e3225e3199c6ef75baa622998b0ae678433d87a..f1f4805d6c39fa47b07a563e7d61b1e68b9ffa9c 100644
--- a/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.h
+++ b/MuonSpectrometer/MuonCnv/MuonTGC_CnvTools/src/TGC_RodDecoderReadout.h
@@ -38,7 +38,7 @@ namespace Muon
/** Standard AlgTool method */
virtual StatusCode finalize();
/** Convert ROBFragment to RDO */
- virtual StatusCode fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdoContainer& rdoIdc);
+ virtual StatusCode fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const;
private:
/** TGC ID helper */
@@ -47,7 +47,7 @@ namespace Muon
/** Retrieve header of ROBFragment */
void getCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment& robFrag, TgcRdo* rdo) const;
/** Convert data contents of ROBFragment to RDO */
- void byteStream2Rdo(OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs, TgcRdo* rdo, uint32_t source_id);
+ void byteStream2Rdo(OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs, TgcRdo* rdo, uint32_t source_id) const;
/** Show status words */
void showStatusWords(const uint32_t source_id, const uint16_t rdoId, const int idHash,
const uint32_t nstatus, const uint32_t* status) const;
@@ -57,8 +57,8 @@ namespace Muon
bool m_skipCoincidence;
// counters to see how often we use the cache for the raw data collections
- unsigned int m_nCache = 0;
- unsigned int m_nNotCache = 0;
+ mutable unsigned int m_nCache ATLAS_THREAD_SAFE = 0 ;
+ mutable unsigned int m_nNotCache ATLAS_THREAD_SAFE = 0 ;
};
} // end of namespace