ATLAS Offline Software
TileRawChannelContByteStreamCnv.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // Gaudi includes
6 #include "GaudiKernel/MsgStream.h"
7 #include "GaudiKernel/StatusCode.h"
8 #include "GaudiKernel/DataObject.h"
9 #include "GaudiKernel/IRegistry.h"
10 #include "GaudiKernel/IToolSvc.h"
11 #include "GaudiKernel/ServiceHandle.h"
12 
13 // Athena includes
16 
20 #include "ByteStreamData/RawEvent.h"
21 
23 #include "AthenaKernel/CLASS_DEF.h"
24 
25 // Tile includes
31 
32 
33 #include <string>
34 #include <stdint.h>
35 
37  : AthConstConverter(storageType(), classID(), svcloc, "TileRawChannelContByteStreamCnv")
38  , m_tool("TileRawChannelContByteStreamTool")
39  , m_byteStreamCnvSvc("ByteStreamCnvSvc", name())
40  , m_robSvc("ROBDataProviderSvc", name())
41  , m_decoder("TileROD_Decoder")
42  , m_hid2re(0)
43 {
44 }
45 
47 
49 
51 
52  ATH_MSG_DEBUG(" initialize ");
53 
55 
56  // Get ByteStreamCnvSvc
57  ATH_CHECK( m_byteStreamCnvSvc.retrieve() );
58 
59  // retrieve Tool
60  ATH_CHECK( m_decoder.retrieve() );
61  m_hid2re = m_decoder->getHid2re();
62 
63  ATH_CHECK( m_tool.retrieve() );
64 
65  ATH_CHECK( m_robSvc.retrieve() );
66 
67  return StatusCode::SUCCESS;
68 }
69 
70 StatusCode TileRawChannelContByteStreamCnv::createObjConst(IOpaqueAddress* pAddr, DataObject*& pObj) const
71 {
72  ATH_MSG_DEBUG(" Executing createObj method ");
73 
74  ByteStreamAddress *pRE_Addr;
75  pRE_Addr = dynamic_cast<ByteStreamAddress*>(pAddr);
76 
77  if(!pRE_Addr) {
78  ATH_MSG_ERROR(" Can not cast to ByteStreamAddress ");
79  return StatusCode::FAILURE;
80  }
81 
82  const std::string containerName(*(pRE_Addr->par()));
83  bool isTMDB(containerName == std::string("MuRcvRawChCnt"));
84 
85  uint32_t newrob = 0x0;
86 
87 
88  std::vector<uint32_t> robid(1);
89  robid[0] = 0;
90  std::vector<const ROBDataProviderSvc::ROBF*> robf;
91 
92  TileMutableRawChannelContainer* cont = m_queue.get (true);
93  ATH_CHECK( cont->status() );
94 
95  if (isTMDB) {
96  cont->set_type (TileFragHash::MF);
97  } else {
98  cont->set_type (TileFragHash::OptFilterDsp);
99  }
100 
101  std::unordered_map<uint32_t,int> bsflags;
102  uint32_t flag;
103 
104  // iterate over all collections in a container and fill them
105  for (IdentifierHash hash : cont->GetAllCurrentHashes()) {
106  TileRawChannelCollection* rawChannelCollection = cont->indexFindPtr (hash);
107  rawChannelCollection->clear();
108  TileRawChannelCollection::ID collID = rawChannelCollection->identify();
109 
110  // find ROB
111  if (isTMDB) {
112  newrob = m_hid2re->getRobFromTileMuRcvFragID(collID);
113  } else {
114  newrob = m_hid2re->getRobFromFragID(collID);
115  }
116 
117  if (newrob != robid[0]) {
118  robid[0] = newrob;
119  robf.clear();
120  m_robSvc->getROBData(Gaudi::Hive::currentContext(), robid, robf);
121  }
122 
123  // unpack ROB data
124  if (robf.size() > 0 ) {
125  if (isTMDB) {// reid for TMDB 0x5x010x
126  m_decoder->fillCollection_TileMuRcv_RawChannel(robf[0], *rawChannelCollection);
127  } else {
128  m_decoder->fillCollection(robf[0], *rawChannelCollection, cont);
129  }
130  flag = cont->get_bsflags();
131  auto result = bsflags.insert(std::pair<uint32_t, int>(flag, 1));
132  if (result.second == false) result.first->second++;
133  } else {
134  ATH_MSG_DEBUG( "ROB for " << ((isTMDB)?"TMDB ":"") << "drawer 0x" << MSG::hex << collID << MSG::dec << " not found in BS" );
136  rawChannelCollection->setFragGlobalCRC(status);
137  ATH_MSG_DEBUG( "Status for " << ((isTMDB)?"TMDB ":"") << "drawer 0x" << MSG::hex << collID << " is 0x" << status << MSG::dec);
138  }
139  }
140 
141  if (bsflags.size() > 1) {
142  int n=0;
143  for (const auto & elem : bsflags) {
144  if (elem.second > n) {
145  n = elem.second;
146  flag = elem.first;
147  }
148  }
149 
150  if (flag != cont->get_bsflags()) {
151 
152  uint32_t unit = ((flag & 0xC0000000) >> 30);
153  if ((flag & 0x30000000) < 0x30000000) unit += TileRawChannelUnit::OnlineOffset; // Online units in real data
154 
155  ATH_MSG_DEBUG( "Changing units for " << ((isTMDB)?"TMDB ":"") << "RawChannelContainer from "
156  << cont->get_unit() << " to " << unit << MSG::hex
157  << " and BS flags from 0x" << cont->get_bsflags() << " to 0x" << flag << MSG::dec);
158 
159  cont->set_unit((TileRawChannelUnit::UNIT)unit);
160  cont->set_bsflags(flag);
161  }
162  }
163 
164  ATH_MSG_DEBUG( "Creating raw channel container: " << containerName );
165 
166  TileRawChannelContainer* basecont = cont;
167  pObj = SG::asStorable( basecont );
168 
169 
170  return StatusCode::SUCCESS;
171 }
172 
173 StatusCode TileRawChannelContByteStreamCnv::createRepConst(DataObject* pObj, IOpaqueAddress*& pAddr) const
174 {
175  // convert TileRawChannels in the container into ByteStream
176 
177  ATH_MSG_DEBUG(" Executing createRep method ");
178 
179  // uint32_t runnum = re->header()->specific_part()->run_no();
180 
181  std::string key("Tile");
182 
183  // get Full Event Assembler
185  ATH_CHECK( m_byteStreamCnvSvc->getFullEventAssembler(fea, key) );
186 
187  // create TileRawChannelContainer
188  TileRawChannelContainer* rccont(0) ;
189  SG::fromStorable(pObj, rccont );
190  if(!rccont){
191  ATH_MSG_ERROR(" Can not cast to TileRawChannelContainer ");
192  return StatusCode::FAILURE;
193  }
194 
195  std::string name = pObj->registry()->name();
196 
197  if ( pAddr != nullptr ) pAddr->release();
198  ByteStreamAddress* addr = new ByteStreamAddress(classID(), name, "");
199  pAddr = addr;
200  pAddr->addRef();
201 
202  ATH_CHECK( m_tool->convert(rccont, fea) );
203 
204  return StatusCode::SUCCESS;
205 }
206 
208 {
209  return Converter::finalize();
210 }
211 
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
get_generator_info.result
result
Definition: get_generator_info.py:21
FullEventAssembler
Template class for assembling a full atlas raw event from subfragments.
Definition: FullEventAssembler.h:40
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::fromStorable
bool fromStorable(DataObject *pDObj, T *&pTrans, bool quiet=false, IRegisterTransient *irt=0, bool isConst=true)
Definition: StorableConversions.h:167
StorableConversions.h
convert to and from a SG storable
TileMutableDataContainer::status
StatusCode status() const
Return the error status from the constructors.
initialize
void initialize()
Definition: run_EoverP.cxx:894
TileHid2RESrcID::getRobFromFragID
uint32_t getRobFromFragID(int frag_id) const
make a ROB SrcID for a fragment ID
Definition: TileHid2RESrcID.cxx:457
TileRawChannelContByteStreamCnv::finalize
virtual StatusCode finalize() override
Definition: TileRawChannelContByteStreamCnv.cxx:207
TileRawChannelCollection::setFragGlobalCRC
void setFragGlobalCRC(uint32_t globalcrc)
Various set methods.
Definition: TileRawChannelCollection.h:81
TileRawChannelContByteStreamCnv::m_hid2re
const TileHid2RESrcID * m_hid2re
Pointer to TileHid2RESrcID.
Definition: TileRawChannelContByteStreamCnv.h:70
TileRawChannelContByteStreamCnv::m_decoder
ToolHandle< TileROD_Decoder > m_decoder
Pointer to TileROD_Decoder.
Definition: TileRawChannelContByteStreamCnv.h:67
TileHid2RESrcID::getRobFromTileMuRcvFragID
uint32_t getRobFromTileMuRcvFragID(int frag_id) const
Definition: TileHid2RESrcID.cxx:579
TileRawChannelContByteStreamCnv::m_tool
ToolHandle< TileRawChannelContByteStreamTool > m_tool
Definition: TileRawChannelContByteStreamCnv.h:59
ROBDataProviderSvc.h
AthConstConverter
Gaudi converter base class with const interfaces.
Definition: AthConstConverter.h:33
TileFragHash::OptFilterDsp
@ OptFilterDsp
Definition: TileFragHash.h:34
TileRawChannelContByteStreamCnv::createRepConst
virtual StatusCode createRepConst(DataObject *pObj, IOpaqueAddress *&pAddr) const override
Convert the transient object to the requested representation.
Definition: TileRawChannelContByteStreamCnv.cxx:173
TileRawChannelContByteStreamCnv.h
TileRawChannelContainer.h
TileRawChannelContByteStreamCnv::createObjConst
virtual StatusCode createObjConst(IOpaqueAddress *pAddr, DataObject *&pObj) const override
Create the transient representation of an object.
Definition: TileRawChannelContByteStreamCnv.cxx:70
SG::asStorable
DataObject * asStorable(SG::DataObjectSharedPtr< T > pObject)
Definition: DataObjectSharedPtr.h:65
ClassID_traits::ID
static const CLID & ID()
the CLID of T
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:50
TileRawChannelCollection::ID
MyBase::ID ID
Definition: TileRawChannelCollection.h:17
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileROD_Decoder.h
beamspotman.n
n
Definition: beamspotman.py:731
RawEvent.h
TileRawChannelContByteStreamCnv::TileRawChannelContByteStreamCnv
TileRawChannelContByteStreamCnv(ISvcLocator *svcloc)
Definition: TileRawChannelContByteStreamCnv.cxx:36
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TileMutableDataContainer
Helper for holding non-const raw data prior to recording in SG.
Definition: TileMutableDataContainer.h:52
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileRawChannelUnit::OnlineOffset
@ OnlineOffset
Definition: TileRawChannelUnit.h:25
master.flag
bool flag
Definition: master.py:29
ByteStreamAddress
IOpaqueAddress for ByteStreamCnvSvc, with ROB ids.
Definition: ByteStreamAddress.h:28
TileROD_Decoder::CRC_ERR
@ CRC_ERR
Definition: TileROD_Decoder.h:226
TileRawChannelContByteStreamCnv::storageType
static long storageType()
Definition: TileRawChannelContByteStreamCnv.cxx:48
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ByteStreamAddress.h
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
TileROD_Decoder::NO_ROB
@ NO_ROB
Definition: TileROD_Decoder.h:226
TileRawDataCollection::identify
ID identify() const
Definition: TileRawDataCollection.h:71
TileHid2RESrcID.h
ByteStreamAddress::storageType
static constexpr long storageType()
Definition: ByteStreamAddress.h:51
TileRawChannelContByteStreamCnv::m_byteStreamCnvSvc
ServiceHandle< IByteStreamCnvSvc > m_byteStreamCnvSvc
Definition: TileRawChannelContByteStreamCnv.h:61
TileMutableDataContainer::indexFindPtr
Collection * indexFindPtr(IdentifierHash hash)
Look up a (non-const) collection via hash.
TileRawChannelContByteStreamCnv::m_robSvc
ServiceHandle< IROBDataProviderSvc > m_robSvc
Pointer to IROBDataProviderSvc.
Definition: TileRawChannelContByteStreamCnv.h:64
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TileFragHash::MF
@ MF
Definition: TileFragHash.h:35
errorcheck.h
Helpers for checking error return status codes and reporting errors.
TileRawChannelCollection
Definition: TileRawChannelCollection.h:12
AthConstConverter::name
const std::string & name() const
Definition: AthConstConverter.h:67
StoreClearedIncident.h
Incident sent after a store is cleared.
TileRawChannelCollection::clear
void clear()
Clear everything for next event.
Definition: TileRawChannelCollection.cxx:52
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
unit
const PlainObject unit() const
This is a plugin that makes Eigen look like CLHEP & defines some convenience methods.
Definition: AmgMatrixBasePlugin.h:21
ByteStreamCnvSvcBase.h
TileRawChannelContByteStreamTool.h
merge.status
status
Definition: merge.py:17
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
TileRawChannelContByteStreamCnv::initialize
virtual StatusCode initialize() override
Definition: TileRawChannelContByteStreamCnv.cxx:50
CLASS_DEF.h
macros to associate a CLID to a type
TileRawChannelContByteStreamCnv::classID
static const CLID & classID()
Definition: TileRawChannelContByteStreamCnv.cxx:46
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37