ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
LVL1BS::CpByteStreamV2Tool Class Reference

Tool to perform ROB fragments to CPM towers, CMX-CP TOBs and CMX-CP hits, and CP container to raw data conversions. More...

#include <CpByteStreamV2Tool.h>

Inheritance diagram for LVL1BS::CpByteStreamV2Tool:
Collaboration diagram for LVL1BS::CpByteStreamV2Tool:

Classes

struct  CmxCpHitsData
struct  CmxCpTobData
struct  CpByteStreamToolData
struct  CpmTowerData
struct  LocalData

Public Member Functions

 CpByteStreamV2Tool (const std::string &type, const std::string &name, const IInterface *parent)
virtual ~CpByteStreamV2Tool ()
virtual StatusCode initialize () override
StatusCode convert (const std::string &sgKey, DataVector< LVL1::CPMTower > *ttCollection) const
 Convert ROB fragments to CPM towers.
StatusCode convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CPMTower > *ttCollection) const
StatusCode convert (const std::string &sgKey, DataVector< LVL1::CMXCPTob > *tobCollection) const
 Convert ROB fragments to CMX-CP TOBs.
StatusCode convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CMXCPTob > *tobCollection) const
StatusCode convert (const std::string &sgKey, DataVector< LVL1::CMXCPHits > *hitCollection) const
 Convert ROB fragments to CMX-CP hits.
StatusCode convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CMXCPHits > *hitCollection) const
StatusCode convert (const LVL1::CPBSCollectionV2 *cp) const
 Convert CP Container to bytestream.
const std::vector< uint32_t > & sourceIDs () const
 Return reference to vector with all possible Source Identifiers.
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Static Public Member Functions

static const InterfaceID & interfaceID ()
 AlgTool InterfaceID.

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Private Types

enum  CollectionType { CPM_TOWERS , CMX_CP_TOBS , CMX_CP_HITS }
typedef DataVector< LVL1::CPMTower > CpmTowerCollection
typedef DataVector< LVL1::CMXCPTob > CmxCpTobCollection
typedef DataVector< LVL1::CMXCPHits > CmxCpHitsCollection
typedef std::map< unsigned int, LVL1::CPMTower * > CpmTowerMap
typedef std::map< unsigned int, const LVL1::CPMTower * > ConstCpmTowerMap
typedef std::map< int, LVL1::CMXCPTob * > CmxCpTobMap
typedef std::map< int, const LVL1::CMXCPTob * > ConstCmxCpTobMap
typedef std::map< int, LVL1::CMXCPHits * > CmxCpHitsMap
typedef std::map< int, const LVL1::CMXCPHits * > ConstCmxCpHitsMap
typedef IROBDataProviderSvc::VROBFRAG::const_iterator ROBIterator
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType ROBPointer
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType RODPointer
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

std::vector< uint32_t > makeSourceIDs () const
 Create list of all source IDs.
StatusCode convertBs (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, CpByteStreamToolData &data) const
 Convert bytestream to given container type.
void decodeCmxCp (CmxCpSubBlock *subBlock, int trigCpm, CpByteStreamToolData &data, LocalData &ld) const
 Unpack CMX-CP sub-block.
void decodeCpm (CpmSubBlockV2 *subBlock, int trigCpm, CpmTowerData &data, LocalData &ld) const
 Unpack CPM sub-block.
const LVL1::CPMTower * findCpmTower (unsigned int key, const ConstCpmTowerMap &ttMap) const
 Find a CPM tower for given key.
LVL1::CPMTower * findCpmTower (const CpmTowerData &data, unsigned int key) const
const LVL1::CMXCPTob * findCmxCpTob (int key, const ConstCmxCpTobMap &tobMap) const
 Find CMX-CP TOB for given key.
LVL1::CMXCPTob * findCmxCpTob (const CmxCpTobData &data, int key) const
const LVL1::CMXCPHits * findCmxCpHits (int key, const ConstCmxCpHitsMap &hitsMap) const
 Find CMX-CP hits for given key.
LVL1::CMXCPHits * findCmxCpHits (const CmxCpHitsData &data, int key) const
void setupCpmTowerMap (const CpmTowerCollection *ttCollection, ConstCpmTowerMap &ttMap, LVL1::TriggerTowerKey &towerKey) const
 Set up CPM tower map.
void setupCmxCpTobMap (const CmxCpTobCollection *tobCollection, ConstCmxCpTobMap &tobMap) const
 Set up CMX-CP TOB map.
void setupCmxCpHitsMap (const CmxCpHitsCollection *hitCollection, ConstCmxCpHitsMap &hitsMap) const
 Set up CMX-CP hits map.
int tobKey (int crate, int cmx, int cpm, int chip, int loc) const
 Key for TOBs.
int hitsKey (int crate, int cmx, int source) const
 Key for Hits.
bool slinkSlices (int crate, int module, int modulesPerSlink, int &timeslices, int &trigJem, const ConstCpmTowerMap &ttMap, const ConstCmxCpTobMap &tobMap, const ConstCmxCpHitsMap &hitsMap, LVL1::TriggerTowerKey &towerKey) const
 Get number of slices and triggered slice offset for next slink.
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

Gaudi::Property< bool > m_enableEncoding
SmartIF< IByteStreamCnvSvc > m_byteStreamCnvSvc
ToolHandle< LVL1::IL1CaloMappingTool > m_cpmMaps
 Channel mapping tool.
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool > m_errorTool
 Error collection tool.
ServiceHandle< IROBDataProviderSvc > m_robDataProvider
int m_crateOffsetHw
 Property: Hardware crate number offset.
int m_crateOffsetSw
 Property: Software crate number offset.
int m_version
 Property: Sub_block header version.
int m_dataFormat
 Property: Data compression format.
const int m_channels
 Number of channels per module.
int m_crates
 Property: Number of crates.
const int m_modules
 Number of CPM modules per crate.
const int m_cmxs
 Number of CMXs per crate.
const int m_maxTobs
 Maximum number of TOBS per module.
const int m_chips
 Number of chips.
const int m_locs
 Number of Local coordinates.
int m_slinks
 Property: Number of slinks per crate when writing out bytestream.
int m_dfltSlices
 Property: Default number of slices in simulation.
int m_forceSlices
 Property: Force number of slices in bytestream.
int m_crateMin
 Property: Minimum crate number when writing out bytestream.
int m_crateMax
 Property: Maximum crate number when writing out bytestream.
const eformat::SubDetector m_subDetector
 Sub-detector type.
const L1CaloSrcIdMap m_srcIdMap
 Source ID converter.
std::vector< uint32_t > m_sourceIDsProp
 Property: ROB source IDs.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Tool to perform ROB fragments to CPM towers, CMX-CP TOBs and CMX-CP hits, and CP container to raw data conversions.

Based on ROD document version X_xxx.

Author
Peter Faulkner

Definition at line 54 of file CpByteStreamV2Tool.h.

Member Typedef Documentation

◆ CmxCpHitsCollection

typedef DataVector<LVL1::CMXCPHits> LVL1BS::CpByteStreamV2Tool::CmxCpHitsCollection
private

Definition at line 135 of file CpByteStreamV2Tool.h.

◆ CmxCpHitsMap

typedef std::map<int, LVL1::CMXCPHits*> LVL1BS::CpByteStreamV2Tool::CmxCpHitsMap
private

Definition at line 140 of file CpByteStreamV2Tool.h.

◆ CmxCpTobCollection

typedef DataVector<LVL1::CMXCPTob> LVL1BS::CpByteStreamV2Tool::CmxCpTobCollection
private

Definition at line 134 of file CpByteStreamV2Tool.h.

◆ CmxCpTobMap

typedef std::map<int, LVL1::CMXCPTob*> LVL1BS::CpByteStreamV2Tool::CmxCpTobMap
private

Definition at line 138 of file CpByteStreamV2Tool.h.

◆ ConstCmxCpHitsMap

typedef std::map<int, const LVL1::CMXCPHits*> LVL1BS::CpByteStreamV2Tool::ConstCmxCpHitsMap
private

Definition at line 141 of file CpByteStreamV2Tool.h.

◆ ConstCmxCpTobMap

typedef std::map<int, const LVL1::CMXCPTob*> LVL1BS::CpByteStreamV2Tool::ConstCmxCpTobMap
private

Definition at line 139 of file CpByteStreamV2Tool.h.

◆ ConstCpmTowerMap

typedef std::map<unsigned int, const LVL1::CPMTower*> LVL1BS::CpByteStreamV2Tool::ConstCpmTowerMap
private

Definition at line 137 of file CpByteStreamV2Tool.h.

◆ CpmTowerCollection

typedef DataVector<LVL1::CPMTower> LVL1BS::CpByteStreamV2Tool::CpmTowerCollection
private

Definition at line 133 of file CpByteStreamV2Tool.h.

◆ CpmTowerMap

typedef std::map<unsigned int, LVL1::CPMTower*> LVL1BS::CpByteStreamV2Tool::CpmTowerMap
private

Definition at line 136 of file CpByteStreamV2Tool.h.

◆ ROBIterator

typedef IROBDataProviderSvc::VROBFRAG::const_iterator LVL1BS::CpByteStreamV2Tool::ROBIterator
private

Definition at line 142 of file CpByteStreamV2Tool.h.

◆ ROBPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::CpByteStreamV2Tool::ROBPointer
private

Definition at line 143 of file CpByteStreamV2Tool.h.

◆ RODPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::CpByteStreamV2Tool::RODPointer
private

Definition at line 144 of file CpByteStreamV2Tool.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ CollectionType

enum LVL1BS::CpByteStreamV2Tool::CollectionType
private
Enumerator
CPM_TOWERS 
CMX_CP_TOBS 
CMX_CP_HITS 

Definition at line 131 of file CpByteStreamV2Tool.h.

131{ CPM_TOWERS, CMX_CP_TOBS, CMX_CP_HITS };

Constructor & Destructor Documentation

◆ CpByteStreamV2Tool()

LVL1BS::CpByteStreamV2Tool::CpByteStreamV2Tool ( const std::string & type,
const std::string & name,
const IInterface * parent )

Definition at line 49 of file CpByteStreamV2Tool.cxx.

52 : AthAlgTool(type, name, parent),
53 m_cpmMaps("LVL1::CpmMappingTool/CpmMappingTool"),
54 m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
55 m_robDataProvider("ROBDataProviderSvc", name),
56 m_channels(80), m_crates(4), m_modules(14), m_cmxs(2), m_maxTobs(5),
57 m_chips(16), m_locs(4),
58 m_subDetector(eformat::TDAQ_CALO_CLUSTER_PROC_DAQ)
59{
60 declareInterface<CpByteStreamV2Tool>(this);
61
62 declareProperty("CpmMappingTool", m_cpmMaps,
63 "Crate/Module/Channel to Eta/Phi/Layer mapping tool");
64 declareProperty("ErrorTool", m_errorTool,
65 "Tool to collect errors for monitoring");
66
67 declareProperty("CrateOffsetHw", m_crateOffsetHw = 8,
68 "Offset of CP crate numbers in bytestream");
69 declareProperty("CrateOffsetSw", m_crateOffsetSw = 0,
70 "Offset of CP crate numbers in RDOs");
71
72 // Properties for reading bytestream only
73 declareProperty("ROBSourceIDs", m_sourceIDsProp,
74 "ROB fragment source identifiers");
75
76 // Properties for writing bytestream only
77 declareProperty("DataVersion", m_version = 2, // <<== CHECK
78 "Format version number in sub-block header");
79 declareProperty("DataFormat", m_dataFormat = 1,
80 "Format identifier (0-1) in sub-block header");
81 declareProperty("SlinksPerCrate", m_slinks = 2,
82 "The number of S-Links per crate");
83 declareProperty("SimulSlices", m_dfltSlices = 1,
84 "The number of slices in the simulation");
85 declareProperty("ForceSlices", m_forceSlices = 0,
86 "If >0, the number of slices in bytestream");
87 declareProperty("CrateMin", m_crateMin = 0,
88 "Minimum crate number, allows partial output");
89 declareProperty("CrateMax", m_crateMax = m_crates - 1,
90 "Maximum crate number, allows partial output");
91
92}
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
LVL1BS::CpByteStreamV2Tool::m_subDetector
const eformat::SubDetector m_subDetector
Sub-detector type.
Definition CpByteStreamV2Tool.h:263
LVL1BS::CpByteStreamV2Tool::m_cmxs
const int m_cmxs
Number of CMXs per crate.
Definition CpByteStreamV2Tool.h:245
LVL1BS::CpByteStreamV2Tool::m_channels
const int m_channels
Number of channels per module.
Definition CpByteStreamV2Tool.h:239
LVL1BS::CpByteStreamV2Tool::m_crateMax
int m_crateMax
Property: Maximum crate number when writing out bytestream.
Definition CpByteStreamV2Tool.h:261
LVL1BS::CpByteStreamV2Tool::m_crateMin
int m_crateMin
Property: Minimum crate number when writing out bytestream.
Definition CpByteStreamV2Tool.h:259
LVL1BS::CpByteStreamV2Tool::m_maxTobs
const int m_maxTobs
Maximum number of TOBS per module.
Definition CpByteStreamV2Tool.h:247
LVL1BS::CpByteStreamV2Tool::m_locs
const int m_locs
Number of Local coordinates.
Definition CpByteStreamV2Tool.h:251
LVL1BS::CpByteStreamV2Tool::m_version
int m_version
Property: Sub_block header version.
Definition CpByteStreamV2Tool.h:235
LVL1BS::CpByteStreamV2Tool::m_dataFormat
int m_dataFormat
Property: Data compression format.
Definition CpByteStreamV2Tool.h:237
LVL1BS::CpByteStreamV2Tool::m_errorTool
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool > m_errorTool
Error collection tool.
Definition CpByteStreamV2Tool.h:228
LVL1BS::CpByteStreamV2Tool::m_forceSlices
int m_forceSlices
Property: Force number of slices in bytestream.
Definition CpByteStreamV2Tool.h:257
LVL1BS::CpByteStreamV2Tool::m_slinks
int m_slinks
Property: Number of slinks per crate when writing out bytestream.
Definition CpByteStreamV2Tool.h:253
LVL1BS::CpByteStreamV2Tool::m_crateOffsetHw
int m_crateOffsetHw
Property: Hardware crate number offset.
Definition CpByteStreamV2Tool.h:231
LVL1BS::CpByteStreamV2Tool::m_dfltSlices
int m_dfltSlices
Property: Default number of slices in simulation.
Definition CpByteStreamV2Tool.h:255
LVL1BS::CpByteStreamV2Tool::m_chips
const int m_chips
Number of chips.
Definition CpByteStreamV2Tool.h:249
LVL1BS::CpByteStreamV2Tool::m_modules
const int m_modules
Number of CPM modules per crate.
Definition CpByteStreamV2Tool.h:243
LVL1BS::CpByteStreamV2Tool::m_crates
int m_crates
Property: Number of crates.
Definition CpByteStreamV2Tool.h:241
LVL1BS::CpByteStreamV2Tool::m_crateOffsetSw
int m_crateOffsetSw
Property: Software crate number offset.
Definition CpByteStreamV2Tool.h:233
LVL1BS::CpByteStreamV2Tool::m_robDataProvider
ServiceHandle< IROBDataProviderSvc > m_robDataProvider
Definition CpByteStreamV2Tool.h:229
LVL1BS::CpByteStreamV2Tool::m_sourceIDsProp
std::vector< uint32_t > m_sourceIDsProp
Property: ROB source IDs.
Definition CpByteStreamV2Tool.h:267
LVL1BS::CpByteStreamV2Tool::m_cpmMaps
ToolHandle< LVL1::IL1CaloMappingTool > m_cpmMaps
Channel mapping tool.
Definition CpByteStreamV2Tool.h:226

◆ ~CpByteStreamV2Tool()

LVL1BS::CpByteStreamV2Tool::~CpByteStreamV2Tool ( )
virtual

Definition at line 96 of file CpByteStreamV2Tool.cxx.

97{
98}

Member Function Documentation

◆ convert() [1/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert ( const LVL1::CPBSCollectionV2 * cp) const

Convert CP Container to bytestream.

Definition at line 186 of file CpByteStreamV2Tool.cxx.

187{
188 if (not m_enableEncoding.value()) {
189 ATH_MSG_ERROR("Encoding method called while " << m_enableEncoding.name() << "=False");
190 return StatusCode::FAILURE;
191 }
192
193 const bool debug = msgLvl(MSG::DEBUG);
194 if (debug) msg(MSG::DEBUG);
195
196 // Get the event assembler
197 FullEventAssembler<L1CaloSrcIdMap>* fea = nullptr;
198 ATH_CHECK( m_byteStreamCnvSvc->getFullEventAssembler (fea,
199 "CpByteStreamV2") );
200 const uint16_t minorVersion = m_srcIdMap.minorVersion();
201 fea->setRodMinorVersion(minorVersion);
202
203 // Pointer to ROD data vector
204
205 FullEventAssembler<L1CaloSrcIdMap>::RODDATA *theROD = 0;
206
207 LVL1::TriggerTowerKey towerKey;
208
209 // Set up the container maps
210
211 // CPM tower map
212 ConstCpmTowerMap ttMap;
213 setupCpmTowerMap(cp->towers(), ttMap, towerKey);
214
215 // CMX-CP TOB map
216 ConstCmxCpTobMap tobMap;
217 setupCmxCpTobMap(cp->tobs(), tobMap);
218
219 // CMX-CP hits map
220 ConstCmxCpHitsMap hitsMap;
221 setupCmxCpHitsMap(cp->hits(), hitsMap);
222
223 // Loop over data
224
225 const bool neutralFormat = m_dataFormat == L1CaloSubBlock::NEUTRAL;
226 const int modulesPerSlink = m_modules / m_slinks;
227 int timeslices = 1;
228 int trigCpm = 0;
229 int timeslicesNew = 1;
230 int trigCpmNew = 0;
231 for (int crate = m_crateMin; crate <= m_crateMax; ++crate)
232 {
233 const int hwCrate = crate + m_crateOffsetHw;
234
235 // CPM modules are numbered 1 to m_modules
236 for (int module = 1; module <= m_modules; ++module)
237 {
238 const int mod = module - 1;
239
240 // Pack required number of modules per slink
241
242 if (mod % modulesPerSlink == 0)
243 {
244 const int daqOrRoi = 0;
245 const int slink = (m_slinks == 2) ? 2 * (mod / modulesPerSlink)
246 : mod / modulesPerSlink;
247 if (debug)
248 {
249 msg() << "Treating crate " << hwCrate
250 << " slink " << slink << endmsg;
251 }
252 // Get number of CPM slices and triggered slice offset
253 // for this slink
254 if ( ! slinkSlices(crate, module, modulesPerSlink,
255 timeslices, trigCpm,
256 ttMap,
257 tobMap,
258 hitsMap,
259 towerKey))
260 {
261 msg(MSG::ERROR) << "Inconsistent number of slices or "
262 << "triggered slice offsets in data for crate "
263 << hwCrate << " slink " << slink << endmsg;
264 return StatusCode::FAILURE;
265 }
266 timeslicesNew = (m_forceSlices) ? m_forceSlices : timeslices;
267 trigCpmNew = ModifySlices::peak(trigCpm, timeslices, timeslicesNew);
268 if (debug)
269 {
270 msg() << "Data Version/Format: " << m_version
271 << " " << m_dataFormat << endmsg
272 << "Slices/offset: " << timeslices << " " << trigCpm;
273 if (timeslices != timeslicesNew)
274 {
275 msg() << " modified to " << timeslicesNew << " " << trigCpmNew;
276 }
277 msg() << endmsg;
278 }
279 L1CaloUserHeader userHeader;
280 userHeader.setCpm(trigCpmNew);
281 const uint32_t rodIdCpm = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
282 m_subDetector);
283 theROD = fea->getRodData(rodIdCpm);
284 theROD->push_back(userHeader.header());
285 }
286 if (debug) msg() << "Module " << module << endmsg;
287
288 // Create a sub-block for each slice (except Neutral format)
289
290 DataVector<CpmSubBlockV2> cpmBlocks;
291 for (int slice = 0; slice < timeslicesNew; ++slice)
292 {
293 CpmSubBlockV2 *const subBlock = new CpmSubBlockV2();
294 subBlock->setCpmHeader(m_version, m_dataFormat, slice,
295 hwCrate, module, timeslicesNew);
296 cpmBlocks.push_back(subBlock);
297 if (neutralFormat) break;
298 }
299
300 // Find CPM towers corresponding to each eta/phi pair and fill
301 // sub-blocks
302
303 for (int chan = 0; chan < m_channels; ++chan)
304 {
305 double eta = 0.;
306 double phi = 0.;
307 int layer = 0;
308 if (m_cpmMaps->mapping(crate, module, chan, eta, phi, layer))
309 {
310 const unsigned int key = towerKey.ttKey(phi, eta);
311 const LVL1::CPMTower *const tt = findCpmTower(key, ttMap);
312 if (tt )
313 {
314 std::vector<int> emData;
315 std::vector<int> hadData;
316 std::vector<int> emError;
317 std::vector<int> hadError;
318 ModifySlices::data(tt->emEnergyVec(), emData, timeslicesNew);
319 ModifySlices::data(tt->hadEnergyVec(), hadData, timeslicesNew);
320 ModifySlices::data(tt->emErrorVec(), emError, timeslicesNew);
321 ModifySlices::data(tt->hadErrorVec(), hadError, timeslicesNew);
322 for (int slice = 0; slice < timeslicesNew; ++slice)
323 {
324 const LVL1::DataError emErrBits(emError[slice]);
325 const LVL1::DataError hadErrBits(hadError[slice]);
326 const int emErr =
327 (emErrBits.get(LVL1::DataError::LinkDown) << 1) |
328 emErrBits.get(LVL1::DataError::Parity);
329 const int hadErr =
330 (hadErrBits.get(LVL1::DataError::LinkDown) << 1) |
331 hadErrBits.get(LVL1::DataError::Parity);
332 const int index = ( neutralFormat ) ? 0 : slice;
333 CpmSubBlockV2 *const subBlock = cpmBlocks[index];
334 subBlock->fillTowerData(slice, chan, emData[slice],
335 hadData[slice], emErr, hadErr);
336 if ((emErrBits.error() >> LVL1::DataError::GLinkParity))
337 {
338 int gLinkParity = emErrBits.get(LVL1::DataError::GLinkParity);
339 int gLinkProtocol = emErrBits.get(LVL1::DataError::GLinkProtocol);
340 int bCNMismatch = emErrBits.get(LVL1::DataError::BCNMismatch);
341 int fIFOOverflow = emErrBits.get(LVL1::DataError::FIFOOverflow);
342 int moduleError = emErrBits.get(LVL1::DataError::ModuleError);
343 int gLinkDown = emErrBits.get(LVL1::DataError::GLinkDown);
344 int gLinkTimeout = emErrBits.get(LVL1::DataError::GLinkTimeout);
345 uint32_t failingBCN = emErrBits.get(LVL1::DataError::FailingBCN);
346 subBlock->setStatus(failingBCN, gLinkTimeout, gLinkDown,
347 moduleError, fIFOOverflow, bCNMismatch,
348 gLinkProtocol, gLinkParity);
349 }
350 }
351 }
352 }
353 }
354
355 // Pack and write the sub-blocks
356
357 DataVector<CpmSubBlockV2>::iterator pos;
358 for (pos = cpmBlocks.begin(); pos != cpmBlocks.end(); ++pos)
359 {
360 CpmSubBlockV2 *const subBlock = *pos;
361 if ( !subBlock->pack())
362 {
363 msg(MSG::ERROR) << "CPM sub-block packing failed" << endmsg;
364 return StatusCode::FAILURE;
365 }
366 if (debug)
367 {
368 msg() << "CPM sub-block data words: "
369 << subBlock->dataWords() << endmsg;
370 }
371 subBlock->write(theROD);
372 }
373 }
374
375 // Append CMXs to last S-Link of the crate
376
377 for (int cmx = 0; cmx < m_cmxs; ++cmx)
378 {
379
380 // Create a sub-block for each slice (except Neutral format)
381
382 DataVector<CmxCpSubBlock> cmxBlocks;
383 const int summing = (crate == m_crates - 1) ? CmxSubBlock::SYSTEM
384 : CmxSubBlock::CRATE;
385 for (int slice = 0; slice < timeslicesNew; ++slice)
386 {
387 CmxCpSubBlock *const block = new CmxCpSubBlock();
388 block->setCmxHeader(m_version, m_dataFormat, slice, hwCrate,
389 summing, CmxSubBlock::CMX_CP, cmx, timeslicesNew);
390 cmxBlocks.push_back(block);
391 if (neutralFormat) break;
392 }
393
394 // CMX-CP Tobs
395
396 for (int cpm = 1; cpm <= m_modules; ++cpm)
397 {
398 for (int chip = 0; chip < m_chips; ++chip)
399 {
400 for (int loc = 0; loc < m_locs; ++loc)
401 {
402 const int key = tobKey(crate, cmx, cpm, chip, loc);
403 const LVL1::CMXCPTob *const ct = findCmxCpTob(key,
404 tobMap);
405 if ( ct )
406 {
407 std::vector<int> energy;
408 std::vector<int> isolation;
409 std::vector<int> error;
410 std::vector<unsigned int> presence;
411 ModifySlices::data(ct->energyVec(), energy, timeslicesNew);
412 ModifySlices::data(ct->isolationVec(), isolation, timeslicesNew);
413 ModifySlices::data(ct->errorVec(), error, timeslicesNew);
414 ModifySlices::data(ct->presenceMapVec(), presence, timeslicesNew);
415 for (int slice = 0; slice < timeslicesNew; ++slice)
416 {
417 const LVL1::DataError errBits(error[slice]);
418 int err = errBits.get(LVL1::DataError::ParityMerge);
419 err |= (errBits.get(LVL1::DataError::ParityPhase0)) << 1;
420 err |= (errBits.get(LVL1::DataError::ParityPhase1)) << 2;
421 err |= (errBits.get(LVL1::DataError::ParityPhase2)) << 3;
422 err |= (errBits.get(LVL1::DataError::ParityPhase3)) << 4;
423 err |= (errBits.get(LVL1::DataError::Overflow)) << 5;
424 const int index = ( neutralFormat ) ? 0 : slice;
425 CmxCpSubBlock *const subBlock = cmxBlocks[index];
426 subBlock->setTob(slice, cpm, chip, loc, energy[slice],
427 isolation[slice], err);
428 subBlock->setPresenceMap(slice, cpm, presence[slice]);
429 }
430 }
431 }
432 }
433 }
434
435 // CMX-CP Hits
436
437 for (int source = 0; source < LVL1::CMXCPHits::MAXSOURCE; ++source)
438 {
439 const int key = hitsKey(crate, cmx, source);
440 const LVL1::CMXCPHits *const ch = findCmxCpHits(key, hitsMap);
441 if ( ch )
442 {
443 std::vector<unsigned int> hits0;
444 std::vector<unsigned int> hits1;
445 std::vector<int> err0;
446 std::vector<int> err1;
447 ModifySlices::data(ch->hitsVec0(), hits0, timeslicesNew);
448 ModifySlices::data(ch->hitsVec1(), hits1, timeslicesNew);
449 ModifySlices::data(ch->errorVec0(), err0, timeslicesNew);
450 ModifySlices::data(ch->errorVec1(), err1, timeslicesNew);
451 for (int slice = 0; slice < timeslicesNew; ++slice)
452 {
453 const LVL1::DataError err0Bits(err0[slice]);
454 const LVL1::DataError err1Bits(err1[slice]);
455 const int index = ( neutralFormat ) ? 0 : slice;
456 CmxCpSubBlock *const subBlock = cmxBlocks[index];
457 subBlock->setHits(slice, source, 0, hits0[slice], // Assuming CMXCPHits::source == CmxCpSubBlock::source
458 err0Bits.get(LVL1::DataError::Parity));
459 subBlock->setHits(slice, source, 1, hits1[slice],
460 err1Bits.get(LVL1::DataError::Parity));
461 if (neutralFormat) // Neutral format wants RoI overflow bit
462 {
463 subBlock->setRoiOverflow(slice, source,
464 err0Bits.get(LVL1::DataError::Overflow));
465 }
466 }
467 }
468 }
469 for (CmxCpSubBlock* subBlock : cmxBlocks)
470 {
471 if ( !subBlock->pack())
472 {
473 msg(MSG::ERROR) << "CMX-Cp sub-block packing failed" << endmsg;
474 return StatusCode::FAILURE;
475 }
476 if (debug)
477 {
478 msg() << "CMX-Cp sub-block data words: "
479 << subBlock->dataWords() << endmsg;
480 }
481 subBlock->write(theROD);
482 }
483 }
484 }
485
486 return StatusCode::SUCCESS;
487}
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
debug
const bool debug
Definition MakeUncertaintyPlots.cxx:53
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition AthCommonMsg.h:30
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
DataVector::iterator
DataModel_detail::iterator< DataVector > iterator
Standard iterator.
Definition DataVector.h:842
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
FullEventAssembler::setRodMinorVersion
void setRodMinorVersion(uint16_t m)
change the ROD minor version
FullEventAssembler::RODDATA
std::vector< uint32_t > RODDATA
ROD data as a vector of unsigned int.
Definition FullEventAssembler.h:52
FullEventAssembler::getRodData
RODDATA * getRodData(uint32_t id)
get a block of ROD data
LVL1BS::CpByteStreamV2Tool::findCpmTower
const LVL1::CPMTower * findCpmTower(unsigned int key, const ConstCpmTowerMap &ttMap) const
Find a CPM tower for given key.
Definition CpByteStreamV2Tool.cxx:1129
LVL1BS::CpByteStreamV2Tool::findCmxCpHits
const LVL1::CMXCPHits * findCmxCpHits(int key, const ConstCmxCpHitsMap &hitsMap) const
Find CMX-CP hits for given key.
Definition CpByteStreamV2Tool.cxx:1167
LVL1BS::CpByteStreamV2Tool::setupCpmTowerMap
void setupCpmTowerMap(const CpmTowerCollection *ttCollection, ConstCpmTowerMap &ttMap, LVL1::TriggerTowerKey &towerKey) const
Set up CPM tower map.
Definition CpByteStreamV2Tool.cxx:1185
LVL1BS::CpByteStreamV2Tool::hitsKey
int hitsKey(int crate, int cmx, int source) const
Key for Hits.
Definition CpByteStreamV2Tool.cxx:1262
LVL1BS::CpByteStreamV2Tool::m_srcIdMap
const L1CaloSrcIdMap m_srcIdMap
Source ID converter.
Definition CpByteStreamV2Tool.h:265
LVL1BS::CpByteStreamV2Tool::m_byteStreamCnvSvc
SmartIF< IByteStreamCnvSvc > m_byteStreamCnvSvc
Definition CpByteStreamV2Tool.h:95
LVL1BS::CpByteStreamV2Tool::findCmxCpTob
const LVL1::CMXCPTob * findCmxCpTob(int key, const ConstCmxCpTobMap &tobMap) const
Find CMX-CP TOB for given key.
Definition CpByteStreamV2Tool.cxx:1148
LVL1BS::CpByteStreamV2Tool::m_enableEncoding
Gaudi::Property< bool > m_enableEncoding
Definition CpByteStreamV2Tool.h:93
LVL1BS::CpByteStreamV2Tool::ConstCpmTowerMap
std::map< unsigned int, const LVL1::CPMTower * > ConstCpmTowerMap
Definition CpByteStreamV2Tool.h:137
LVL1BS::CpByteStreamV2Tool::ConstCmxCpHitsMap
std::map< int, const LVL1::CMXCPHits * > ConstCmxCpHitsMap
Definition CpByteStreamV2Tool.h:141
LVL1BS::CpByteStreamV2Tool::setupCmxCpHitsMap
void setupCmxCpHitsMap(const CmxCpHitsCollection *hitCollection, ConstCmxCpHitsMap &hitsMap) const
Set up CMX-CP hits map.
Definition CpByteStreamV2Tool.cxx:1231
LVL1BS::CpByteStreamV2Tool::setupCmxCpTobMap
void setupCmxCpTobMap(const CmxCpTobCollection *tobCollection, ConstCmxCpTobMap &tobMap) const
Set up CMX-CP TOB map.
Definition CpByteStreamV2Tool.cxx:1206
LVL1BS::CpByteStreamV2Tool::ConstCmxCpTobMap
std::map< int, const LVL1::CMXCPTob * > ConstCmxCpTobMap
Definition CpByteStreamV2Tool.h:139
LVL1BS::CpByteStreamV2Tool::slinkSlices
bool slinkSlices(int crate, int module, int modulesPerSlink, int &timeslices, int &trigJem, const ConstCpmTowerMap &ttMap, const ConstCmxCpTobMap &tobMap, const ConstCmxCpHitsMap &hitsMap, LVL1::TriggerTowerKey &towerKey) const
Get number of slices and triggered slice offset for next slink.
Definition CpByteStreamV2Tool.cxx:1270
LVL1BS::CpByteStreamV2Tool::tobKey
int tobKey(int crate, int cmx, int cpm, int chip, int loc) const
Key for TOBs.
Definition CpByteStreamV2Tool.cxx:1254
LVL1BS::ModifySlices::data
static void data(const std::vector< int > &oldVec, std::vector< int > &newVec, int newSlices)
Return modified data vector<int>
Definition ModifySlices.cxx:20
LVL1BS::ModifySlices::peak
static int peak(int oldPeak, int oldSlices, int newSlices)
Return new triggered slice offset.
Definition ModifySlices.cxx:12
LVL1::TriggerTowerKey::ttKey
virtual unsigned int ttKey(const TriggerTower &tower)
returns the key of the passed tower
Definition TriggerTowerKey.cxx:138
DeMoScan.index
str index
Definition DeMoScan.py:362
LArNewCalib_PedestalAutoCorr.cp
cp
Definition LArNewCalib_PedestalAutoCorr.py:188
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition ParticleGun_FastCalo_ChargeFlip_Config.py:78
TRT::Hit::layer
@ layer
Definition HitInfo.h:79
dqt_zlumi_pandas.err
err
Definition dqt_zlumi_pandas.py:183
get_generator_info.error
error
Definition get_generator_info.py:40
sendEI_SPB.ch
ch
Definition sendEI_SPB.py:35
xAOD::uint16_t
setWord1 uint16_t
Definition eFexEMRoI_v1.cxx:93
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127

◆ convert() [2/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert ( const std::string & sgKey,
const IROBDataProviderSvc::VROBFRAG & robFrags,
DataVector< LVL1::CMXCPHits > * hitCollection ) const

Definition at line 175 of file CpByteStreamV2Tool.cxx.

179{
180 CmxCpHitsData data (hitCollection);
181 return convertBs(sgKey, robFrags, data);
182}
data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11
LVL1BS::CpByteStreamV2Tool::convertBs
StatusCode convertBs(const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, CpByteStreamToolData &data) const
Convert bytestream to given container type.
Definition CpByteStreamV2Tool.cxx:524

◆ convert() [3/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert ( const std::string & sgKey,
const IROBDataProviderSvc::VROBFRAG & robFrags,
DataVector< LVL1::CMXCPTob > * tobCollection ) const

Definition at line 153 of file CpByteStreamV2Tool.cxx.

157{
158 CmxCpTobData data (tobCollection);
159 return convertBs(sgKey, robFrags, data);
160}

◆ convert() [4/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert ( const std::string & sgKey,
const IROBDataProviderSvc::VROBFRAG & robFrags,
DataVector< LVL1::CPMTower > * ttCollection ) const

Definition at line 131 of file CpByteStreamV2Tool.cxx.

135{
136 CpmTowerData data (ttCollection);
137 return convertBs(sgKey, robFrags, data);
138}

◆ convert() [5/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert ( const std::string & sgKey,
DataVector< LVL1::CMXCPHits > * hitCollection ) const

Convert ROB fragments to CMX-CP hits.

Definition at line 163 of file CpByteStreamV2Tool.cxx.

166{
167 const std::vector<uint32_t>& vID(sourceIDs());
168 // // get ROB fragments
169 IROBDataProviderSvc::VROBFRAG robFrags;
170 m_robDataProvider->getROBData(Gaudi::Hive::currentContext(), vID, robFrags, "CpByteStreamV2Tool");
171 ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
172 return convert(sgKey, robFrags, hitCollection);
173}
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
IROBDataProviderSvc::VROBFRAG
std::vector< const ROBF * > VROBFRAG
Definition IROBDataProviderSvc.h:27
LVL1BS::CpByteStreamV2Tool::sourceIDs
const std::vector< uint32_t > & sourceIDs() const
Return reference to vector with all possible Source Identifiers.
Definition CpByteStreamV2Tool.cxx:516
LVL1BS::CpByteStreamV2Tool::convert
StatusCode convert(const std::string &sgKey, DataVector< LVL1::CPMTower > *ttCollection) const
Convert ROB fragments to CPM towers.
Definition CpByteStreamV2Tool.cxx:119

◆ convert() [6/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert ( const std::string & sgKey,
DataVector< LVL1::CMXCPTob > * tobCollection ) const

Convert ROB fragments to CMX-CP TOBs.

Definition at line 141 of file CpByteStreamV2Tool.cxx.

144{
145 const std::vector<uint32_t>& vID(sourceIDs());
146 // // get ROB fragments
147 IROBDataProviderSvc::VROBFRAG robFrags;
148 m_robDataProvider->getROBData(Gaudi::Hive::currentContext(), vID, robFrags, "CpByteStreamV2Tool");
149 ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
150 return convert(sgKey, robFrags, tobCollection);
151}

◆ convert() [7/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert ( const std::string & sgKey,
DataVector< LVL1::CPMTower > * ttCollection ) const

Convert ROB fragments to CPM towers.

Definition at line 119 of file CpByteStreamV2Tool.cxx.

122{
123 const std::vector<uint32_t>& vID(sourceIDs());
124 // // get ROB fragments
125 IROBDataProviderSvc::VROBFRAG robFrags;
126 m_robDataProvider->getROBData(Gaudi::Hive::currentContext(), vID, robFrags, "CpByteStreamV2Tool");
127 ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
128 return convert(sgKey, robFrags, ttCollection);
129}

◆ convertBs()

StatusCode LVL1BS::CpByteStreamV2Tool::convertBs ( const std::string & sgKey,
const IROBDataProviderSvc::VROBFRAG & robFrags,
CpByteStreamToolData & data ) const
private

Convert bytestream to given container type.

Definition at line 524 of file CpByteStreamV2Tool.cxx.

528{
529 LocalData ld;
530
531 ld.coreOverlap = sgKey.ends_with( "Overlap") || sgKey.ends_with ("OverlapAux.");
532
533 const bool debug = msgLvl(MSG::DEBUG);
534 if (debug) msg(MSG::DEBUG);
535
536 CmxCpSubBlock cmxCpSubBlock;
537 CpmSubBlockV2 cpmSubBlock;
538
539 // Loop over ROB fragments
540
541 int robCount = 0;
542 std::set<uint32_t> dupCheck;
543 ROBIterator rob = robFrags.begin();
544 ROBIterator robEnd = robFrags.end();
545 for (; rob != robEnd; ++rob)
546 {
547 ++robCount;
548 ATH_MSG_DEBUG("Treating ROB fragment " << robCount << " source_id = " << std::hex << (*rob)->rob_source_id() << std::dec);
549
550 // Skip fragments with ROB status errors
551
552 const uint32_t robid = (*rob)->source_id();
553 if ((*rob)->nstatus() > 0)
554 {
555 ROBPointer robData;
556 (*rob)->status(robData);
557 if (*robData != 0)
558 {
559 m_errorTool->robError(robid, *robData);
560 if (debug) msg() << "ROB status error - skipping fragment" << endmsg;
561 continue;
562 }
563 }
564
565 // Skip duplicate fragments
566
567 if (!dupCheck.insert(robid).second)
568 {
569 m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_DUPLICATE_ROB);
570 if (debug) msg() << "Skipping duplicate ROB fragment" << endmsg;
571 continue;
572 }
573
574 // Unpack ROD data (slinks)
575
576 RODPointer payloadBeg;
577 RODPointer payload;
578 RODPointer payloadEnd;
579 (*rob)->rod_data(payloadBeg);
580 payloadEnd = payloadBeg + (*rob)->rod_ndata();
581 payload = payloadBeg;
582 if (payload == payloadEnd)
583 {
584 if (debug) msg() << "ROB fragment empty" << endmsg;
585 continue;
586 }
587
588 // Check identifier
589 const uint32_t sourceID = (*rob)->rod_source_id();
590 if (m_srcIdMap.getRobID(sourceID) != robid ||
591 m_srcIdMap.subDet(sourceID) != m_subDetector ||
592 m_srcIdMap.daqOrRoi(sourceID) != 0 ||
593 (m_srcIdMap.slink(sourceID) != 0 && m_srcIdMap.slink(sourceID) != 2) ||
594 m_srcIdMap.crate(sourceID) < m_crateOffsetHw ||
595 m_srcIdMap.crate(sourceID) >= m_crateOffsetHw + m_crates)
596 {
597 m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_ROD_ID);
598 if (debug)
599 {
600 msg() << "Wrong source identifier in data: ROD "
601 << MSG::hex << sourceID << " ROB " << robid
602 << MSG::dec << endmsg;
603 }
604 continue;
605 }
606
607 // Check minor version
608 const int minorVersion = (*rob)->rod_version() & 0xffff;
609
610 if (minorVersion <= m_srcIdMap.minorVersionPreLS1())
611 {
612 if (debug) msg() << "Skipping pre-LS1 data" << endmsg;
613 continue;
614 }
615 const int rodCrate = m_srcIdMap.crate(sourceID);
616 if (debug)
617 {
618 msg() << "Treating crate " << rodCrate
619 << " slink " << m_srcIdMap.slink(sourceID) << endmsg;
620 }
621
622 // First word should be User Header
623 if ( !L1CaloUserHeader::isValid(*payload) )
624 {
625 m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_USER_HEADER);
626 if (debug) msg() << "Invalid or missing user header" << endmsg;
627 continue;
628 }
629 L1CaloUserHeader userHeader(*payload);
630 userHeader.setVersion(minorVersion);
631 const int headerWords = userHeader.words();
632 if (headerWords != 1)
633 {
634 m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_USER_HEADER);
635 if (debug) msg() << "Unexpected number of user header words: "
636 << headerWords << endmsg;
637 continue;
638 }
639 for (int i = 0; i < headerWords; ++i) ++payload;
640 // triggered slice offset
641 const int trigCpm = userHeader.cpm();
642 if (debug)
643 {
644 msg() << "Minor format version number: " << MSG::hex
645 << minorVersion << MSG::dec << endmsg
646 << "Triggered slice offset: " << trigCpm << endmsg;
647 }
648
649 // Loop over sub-blocks
650
651 ld.rodErr = L1CaloSubBlock::ERROR_NONE;
652 while (payload != payloadEnd)
653 {
654 if (L1CaloSubBlock::wordType(*payload) != L1CaloSubBlock::HEADER)
655 {
656 if (debug) msg() << "Unexpected data sequence" << endmsg;
657 ld.rodErr = L1CaloSubBlock::ERROR_MISSING_HEADER;
658 break;
659 }
660
661 // TODO: (sasha) Comment this check since firmware does not ready
662 // Select right tool by ROD version
663 // if (L1CaloSubBlock::version(*payload) == 1) {
664 // if (debug) msg() << "Skipping pre-LS1 data" << endmsg;
665 // break;
666 // }
667
668 if (CmxSubBlock::cmxBlock(*payload))
669 {
670 // CMX
671 if (CmxSubBlock::cmxType(*payload) == CmxSubBlock::CMX_CP)
672 {
673 cmxCpSubBlock.clear();
674 payload = cmxCpSubBlock.read(payload, payloadEnd);
675 if (cmxCpSubBlock.crate() != rodCrate)
676 {
677 if (debug) msg() << "Inconsistent crate number in ROD source ID"
678 << endmsg;
679 ld.rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
680 break;
681 }
682
683 if (data.m_collection == CMX_CP_TOBS || data.m_collection == CMX_CP_HITS)
684 {
685 decodeCmxCp(&cmxCpSubBlock, trigCpm, data, ld);
686 if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
687 {
688 if (debug) msg() << "decodeCmxCp failed" << endmsg;
689 break;
690 }
691 }
692 }
693 else
694 {
695 if (debug) msg() << "Invalid CMX type in module field" << endmsg;
696 ld.rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
697 break;
698 }
699 }
700 else
701 {
702 // CPM
703 cpmSubBlock.clear();
704 payload = cpmSubBlock.read(payload, payloadEnd);
705 if (cpmSubBlock.crate() != rodCrate)
706 {
707 if (debug) msg() << "Inconsistent crate number in ROD source ID"
708 << endmsg;
709 ld.rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
710 break;
711 }
712 if (data.m_collection == CPM_TOWERS)
713 {
714 decodeCpm(&cpmSubBlock, trigCpm, static_cast<CpmTowerData&>(data), ld);
715 if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
716 {
717 if (debug) msg() << "decodeCpm failed" << endmsg;
718 break;
719 }
720 }
721 }
722 }
723 if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
724 {
725 m_errorTool->rodError(robid, ld.rodErr);
726 }
727 }
728 return StatusCode::SUCCESS;
729}
LVL1BS::CmxSubBlock::cmxBlock
static bool cmxBlock(uint32_t word)
Determine if header word corresponds to CMX.
Definition CmxSubBlock.cxx:84
LVL1BS::CmxSubBlock::cmxType
static CmxFirmwareCode cmxType(uint32_t word)
CMX differentiation (CMX_CP, CMX_JET, or CMX_ENERGY)
Definition CmxSubBlock.cxx:60
LVL1BS::CpByteStreamV2Tool::decodeCmxCp
void decodeCmxCp(CmxCpSubBlock *subBlock, int trigCpm, CpByteStreamToolData &data, LocalData &ld) const
Unpack CMX-CP sub-block.
Definition CpByteStreamV2Tool.cxx:733
LVL1BS::CpByteStreamV2Tool::ROBIterator
IROBDataProviderSvc::VROBFRAG::const_iterator ROBIterator
Definition CpByteStreamV2Tool.h:142
LVL1BS::CpByteStreamV2Tool::RODPointer
OFFLINE_FRAGMENTS_NAMESPACE::PointerType RODPointer
Definition CpByteStreamV2Tool.h:144
LVL1BS::CpByteStreamV2Tool::decodeCpm
void decodeCpm(CpmSubBlockV2 *subBlock, int trigCpm, CpmTowerData &data, LocalData &ld) const
Unpack CPM sub-block.
Definition CpByteStreamV2Tool.cxx:960
LVL1BS::CpByteStreamV2Tool::ROBPointer
OFFLINE_FRAGMENTS_NAMESPACE::PointerType ROBPointer
Definition CpByteStreamV2Tool.h:143
LVL1BS::L1CaloSubBlock::wordType
static SubBlockWordType wordType(uint32_t word)
Word identification.
Definition L1CaloSubBlock.cxx:479
LVL1BS::L1CaloUserHeader::isValid
static bool isValid(uint32_t word)
Test for valid header word.
Definition L1CaloUserHeader.cxx:36
PixelModuleFeMask_create_db.payload
str payload
Definition PixelModuleFeMask_create_db.py:69
geometry_dat_to_json.ld
ld
Definition geometry_dat_to_json.py:33

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ decodeCmxCp()

void LVL1BS::CpByteStreamV2Tool::decodeCmxCp ( CmxCpSubBlock * subBlock,
int trigCpm,
CpByteStreamToolData & data,
LocalData & ld ) const
private

Unpack CMX-CP sub-block.

Definition at line 733 of file CpByteStreamV2Tool.cxx.

736{
737 const bool debug = msgLvl(MSG::DEBUG);
738 if (debug) msg(MSG::DEBUG);
739
740 const int hwCrate = subBlock->crate();
741 const int cmx = subBlock->cmxPosition();
742 const int firmware = subBlock->cmxFirmware();
743 const int summing = subBlock->cmxSumming();
744 const int timeslices = subBlock->timeslices();
745 const int sliceNum = subBlock->slice();
746 if (debug)
747 {
748 msg() << "CMX-CP: Crate " << hwCrate
749 << " Position " << cmx
750 << " Firmware " << firmware
751 << " Summing " << summing
752 << " Total slices " << timeslices
753 << " Slice " << sliceNum
754 << endmsg;
755 }
756 if (timeslices <= trigCpm)
757 {
758 if (debug) msg() << "Triggered slice from header "
759 << "inconsistent with number of slices: "
760 << trigCpm << ", " << timeslices << endmsg;
761 ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
762 return;
763 }
764 if (timeslices <= sliceNum)
765 {
766 if (debug) msg() << "Total slices inconsistent with slice number: "
767 << timeslices << ", " << sliceNum << endmsg;
768 ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
769 return;
770 }
771 // Unpack sub-block
772 if (subBlock->dataWords() && !subBlock->unpack())
773 {
774 if (debug)
775 {
776 std::string errMsg(subBlock->unpackErrorMsg());
777 msg() << "CMX-CP sub-block unpacking failed: " << errMsg << endmsg;
778 }
779 ld.rodErr = subBlock->unpackErrorCode();
780 return;
781 }
782
783 // Retrieve required data
784
785 const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
786 LVL1::DataError dErr;
787 dErr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
788 const int subStatus = dErr.error();
789 const int crate = hwCrate - m_crateOffsetHw;
790 const int swCrate = crate + m_crateOffsetSw;
791 const int maxSid = CmxCpSubBlock::MAX_SOURCE_ID;
792 const int sliceBeg = ( neutralFormat ) ? 0 : sliceNum;
793 const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
794 for (int slice = sliceBeg; slice < sliceEnd; ++slice)
795 {
796
797 if (data.m_collection == CMX_CP_TOBS)
798 {
799 CmxCpTobData& tdata = static_cast<CmxCpTobData&> (data);
800
801 // TOBs
802
803 for (int cpm = 1; cpm <= m_modules; ++cpm)
804 {
805 const unsigned int presenceMap = subBlock->presenceMap(slice, cpm);
806 for (int tob = 0; tob < m_maxTobs; ++tob)
807 {
808 const int energy = subBlock->energy(slice, cpm, tob);
809 const int isolation = subBlock->isolation(slice, cpm, tob);
810 int error = subBlock->tobError(slice, cpm, tob);
811 if (energy == 0 && isolation == 0 && error == 0) break;
812 const int loc = subBlock->localCoord(slice, cpm, tob);
813 const int chip = subBlock->chip(slice, cpm, tob);
814 LVL1::DataError errBits(subStatus);
815 if (error)
816 {
817 errBits.set(LVL1::DataError::ParityPhase0, error);
818 errBits.set(LVL1::DataError::ParityPhase1, (error >> 1));
819 errBits.set(LVL1::DataError::ParityPhase2, (error >> 2));
820 errBits.set(LVL1::DataError::ParityPhase3, (error >> 3));
821 errBits.set(LVL1::DataError::Overflow, (error >> 4));
822 errBits.set(LVL1::DataError::ParityMerge, (error >> 5));
823 errBits.set(LVL1::DataError::Parity, (error & 0x2f) ? 1 : 0);
824 }
825 error = errBits.error();
826 const int key = tobKey(crate, cmx, cpm, chip, loc);
827 LVL1::CMXCPTob *tb = findCmxCpTob(tdata, key);
828 if ( ! tb ) // create new CMX TOB
829 {
830 ld.energyVec.assign(timeslices, 0);
831 ld.isolVec.assign(timeslices, 0);
832 ld.errorVec.assign(timeslices, 0);
833 ld.presenceMapVec.assign(timeslices, 0);
834 ld.energyVec[slice] = energy;
835 ld.isolVec[slice] = isolation;
836 ld.errorVec[slice] = error;
837 ld.presenceMapVec[slice] = presenceMap;
838 auto tbp =
839 std::make_unique<LVL1::CMXCPTob>(swCrate, cmx, cpm, chip, loc,
840 ld.energyVec, ld.isolVec, ld.errorVec,
841 ld.presenceMapVec, trigCpm);
842 tdata.m_tobMap.insert(std::make_pair(key, tbp.get()));
843 tdata.m_tobCollection->push_back(std::move(tbp));
844 }
845 else
846 {
847 ld.energyVec = tb->energyVec();
848 ld.isolVec = tb->isolationVec();
849 ld.errorVec = tb->errorVec();
850 ld.presenceMapVec = tb->presenceMapVec();
851 const int nsl = ld.energyVec.size();
852 if (timeslices != nsl)
853 {
854 if (debug) msg() << "Inconsistent number of slices in sub-blocks"
855 << endmsg;
856 ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
857 return;
858 }
859 if (ld.energyVec[slice] != 0 || ld.isolVec[slice] != 0 ||
860 ld.errorVec[slice] != 0)
861 {
862 if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
863 ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
864 return;
865 }
866 ld.energyVec[slice] = energy;
867 ld.isolVec[slice] = isolation;
868 ld.errorVec[slice] = error;
869 ld.presenceMapVec[slice] = presenceMap;
870 tb->addTob(ld.energyVec, ld.isolVec, ld.errorVec, ld.presenceMapVec);
871 }
872 }
873 }
874
875 }
876 else if (data.m_collection == CMX_CP_HITS)
877 {
878 CmxCpHitsData& hdata = static_cast<CmxCpHitsData&> (data);
879
880 // Hit/Topo counts
881
882 for (int source = 0; source < maxSid; ++source)
883 {
884 if (summing == CmxSubBlock::CRATE &&
885 (source == CmxCpSubBlock::REMOTE_0 ||
886 source == CmxCpSubBlock::REMOTE_1 ||
887 source == CmxCpSubBlock::REMOTE_2 ||
888 source == CmxCpSubBlock::TOTAL)) continue;
889 const unsigned int hits0 = subBlock->hits(slice, source, 0); //low
890 const unsigned int hits1 = subBlock->hits(slice, source, 1); //high
891 int err0 = subBlock->hitsError(slice, source, 0);
892 int err1 = subBlock->hitsError(slice, source, 1);
893 int overflow = subBlock->roiOverflow(slice, source);
894 LVL1::DataError err0Bits(subStatus);
895 err0Bits.set(LVL1::DataError::Parity, err0);
896 err0Bits.set(LVL1::DataError::Overflow, overflow);
897 err0 = err0Bits.error();
898 LVL1::DataError err1Bits(subStatus);
899 err1Bits.set(LVL1::DataError::Parity, err1);
900 err1Bits.set(LVL1::DataError::Overflow, overflow);
901 err1 = err1Bits.error();
902 if (hits0 || hits1 || err0 || err1)
903 {
904 const int key = hitsKey(crate, cmx, source);
905 LVL1::CMXCPHits *ch = findCmxCpHits(hdata, key);
906 if ( ! ch ) // create new CMX hits
907 {
908 ld.hitsVec0.assign(timeslices, 0);
909 ld.hitsVec1.assign(timeslices, 0);
910 ld.errVec0.assign(timeslices, 0);
911 ld.errVec1.assign(timeslices, 0);
912 ld.hitsVec0[slice] = hits0;
913 ld.hitsVec1[slice] = hits1;
914 ld.errVec0[slice] = err0;
915 ld.errVec1[slice] = err1;
916 auto chp =
917 std::make_unique<LVL1::CMXCPHits>(swCrate, cmx, source,
918 ld.hitsVec0, ld.hitsVec1,
919 ld.errVec0, ld.errVec1, trigCpm);
920 hdata.m_hitsMap.insert(std::make_pair(key, chp.get()));
921 hdata.m_hitCollection->push_back(std::move(chp));
922 }
923 else
924 {
925 ld.hitsVec0 = ch->hitsVec0();
926 ld.hitsVec1 = ch->hitsVec1();
927 ld.errVec0 = ch->errorVec0();
928 ld.errVec1 = ch->errorVec1();
929 const int nsl = ld.hitsVec0.size();
930 if (timeslices != nsl)
931 {
932 if (debug) msg() << "Inconsistent number of slices in sub-blocks"
933 << endmsg;
934 ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
935 return;
936 }
937 if (ld.hitsVec0[slice] != 0 || ld.hitsVec1[slice] != 0 ||
938 ld.errVec0[slice] != 0 || ld.errVec1[slice] != 0)
939 {
940 if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
941 ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
942 return;
943 }
944 ld.hitsVec0[slice] = hits0;
945 ld.hitsVec1[slice] = hits1;
946 ld.errVec0[slice] = err0;
947 ld.errVec1[slice] = err1;
948 ch->addHits(ld.hitsVec0, ld.hitsVec1, ld.errVec0, ld.errVec1);
949 }
950 }
951 }
952 }
953 }
954
955 return;
956}
LVL1::DataError::error
int error() const
Return the full error word.
Definition DataError.h:78
LVL1::DataError::set
void set(ErrorBit bit, int value=1)
Set an error bit or data.
Definition DataError.cxx:28

◆ decodeCpm()

void LVL1BS::CpByteStreamV2Tool::decodeCpm ( CpmSubBlockV2 * subBlock,
int trigCpm,
CpmTowerData & data,
LocalData & ld ) const
private

Unpack CPM sub-block.

Definition at line 960 of file CpByteStreamV2Tool.cxx.

963{
964 const bool debug = msgLvl(MSG::DEBUG);
965 const bool verbose = msgLvl(MSG::VERBOSE);
966 if (debug) msg(MSG::DEBUG);
967
968 const int hwCrate = subBlock->crate();
969 const int module = subBlock->module();
970 const int timeslices = subBlock->timeslices();
971 const int sliceNum = subBlock->slice();
972 if (debug)
973 {
974 msg() << "CPM: Crate " << hwCrate
975 << " Module " << module
976 << " Total slices " << timeslices
977 << " Slice " << sliceNum << endmsg;
978 }
979 if (module < 1 || module > m_modules)
980 {
981 if (debug) msg() << "Unexpected module number: " << module << endmsg;
982 ld.rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
983 return;
984 }
985 if (timeslices <= trigCpm)
986 {
987 if (debug) msg() << "Triggered slice from header "
988 << "inconsistent with number of slices: "
989 << trigCpm << ", " << timeslices << endmsg;
990 ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
991 return;
992 }
993 if (timeslices <= sliceNum)
994 {
995 if (debug) msg() << "Total slices inconsistent with slice number: "
996 << timeslices << ", " << sliceNum << endmsg;
997 ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
998 return;
999 }
1000 // Unpack sub-block
1001 if (subBlock->dataWords() && !subBlock->unpack())
1002 {
1003 if (debug)
1004 {
1005 std::string errMsg(subBlock->unpackErrorMsg());
1006 msg() << "CPM sub-block unpacking failed: " << errMsg << endmsg;
1007 }
1008 ld.rodErr = subBlock->unpackErrorCode();
1009 return;
1010 }
1011
1012 // Retrieve required data
1013 const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
1014 LVL1::DataError dErr;
1015 dErr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
1016 const int subStatus = dErr.error();
1017 const int crate = hwCrate - m_crateOffsetHw;
1018 const int sliceBeg = ( neutralFormat ) ? 0 : sliceNum;
1019 const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
1020 for (int slice = sliceBeg; slice < sliceEnd; ++slice)
1021 {
1022
1023 // Loop over tower channels and fill CPM towers
1024
1025 for (int chan = 0; chan < m_channels; ++chan)
1026 {
1027 if (!subStatus && !subBlock->anyTowerData(chan)) continue;
1028 const int em = subBlock->emData(slice, chan);
1029 const int had = subBlock->hadData(slice, chan);
1030 const int emErr = subBlock->emError(slice, chan);
1031 const int hadErr = subBlock->hadError(slice, chan);
1032 int emErr1 = subStatus;
1033 if (emErr)
1034 {
1035 LVL1::DataError emErrBits(emErr1);
1036 emErrBits.set(LVL1::DataError::Parity, emErr & 0x1);
1037 emErrBits.set(LVL1::DataError::LinkDown, (emErr >> 1) & 0x1);
1038 emErr1 = emErrBits.error();
1039 }
1040 int hadErr1 = subStatus;
1041 if (hadErr)
1042 {
1043 LVL1::DataError hadErrBits(hadErr1);
1044 hadErrBits.set(LVL1::DataError::Parity, hadErr & 0x1);
1045 hadErrBits.set(LVL1::DataError::LinkDown, (hadErr >> 1) & 0x1);
1046 hadErr1 = hadErrBits.error();
1047 }
1048 if (em || had || emErr1 || hadErr1)
1049 {
1050 double eta = 0.;
1051 double phi = 0.;
1052 int layer = 0;
1053 if (m_cpmMaps->mapping(crate, module, chan, eta, phi, layer))
1054 {
1055 if (layer == ld.coreOverlap)
1056 {
1057 const unsigned int key = ld.towerKey.ttKey(phi, eta);
1058 LVL1::CPMTower *tt = findCpmTower(data, key);
1059 if ( ! tt ) // create new CPM tower
1060 {
1061 ld.emVec.assign(timeslices, 0);
1062 ld.hadVec.assign(timeslices, 0);
1063 ld.emErrVec.assign(timeslices, 0);
1064 ld.hadErrVec.assign(timeslices, 0);
1065 ld.emVec[slice] = em;
1066 ld.hadVec[slice] = had;
1067 ld.emErrVec[slice] = emErr1;
1068 ld.hadErrVec[slice] = hadErr1;
1069 auto ttp =
1070 std::make_unique<LVL1::CPMTower>(phi, eta, ld.emVec, ld.emErrVec,
1071 ld.hadVec, ld.hadErrVec, trigCpm);
1072 data.m_ttMap.insert(std::make_pair(key, ttp.get()));
1073 data.m_ttCollection->push_back(std::move(ttp));
1074 }
1075 else
1076 {
1077 ld.emVec = tt->emEnergyVec();
1078 ld.hadVec = tt->hadEnergyVec();
1079 ld.emErrVec = tt->emErrorVec();
1080 ld.hadErrVec = tt->hadErrorVec();
1081 const int nsl = ld.emVec.size();
1082 if (timeslices != nsl)
1083 {
1084 if (debug)
1085 {
1086 msg() << "Inconsistent number of slices in sub-blocks"
1087 << endmsg;
1088 }
1089 ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
1090 return;
1091 }
1092 if (ld.emVec[slice] != 0 || ld.hadVec[slice] != 0 ||
1093 ld.emErrVec[slice] != 0 || ld.hadErrVec[slice] != 0)
1094 {
1095 if (debug) msg() << "Duplicate data for slice "
1096 << slice << endmsg;
1097 ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
1098 return;
1099 }
1100 ld.emVec[slice] = em;
1101 ld.hadVec[slice] = had;
1102 ld.emErrVec[slice] = emErr1;
1103 ld.hadErrVec[slice] = hadErr1;
1104 tt->fill(ld.emVec, ld.emErrVec, ld.hadVec, ld.hadErrVec, trigCpm);
1105 }
1106 }
1107 }
1108 else if (verbose && (em || had || emErr || hadErr))
1109 {
1110 msg(MSG::VERBOSE) << "Non-zero data but no channel mapping for channel "
1111 << chan << endmsg;
1112 msg(MSG::DEBUG);
1113 }
1114 }
1115 else if (verbose)
1116 {
1117 msg(MSG::VERBOSE) << "No CPM tower data for channel "
1118 << chan << " slice " << slice << endmsg;
1119 msg(MSG::DEBUG);
1120 }
1121 }
1122 }
1123 return;
1124}
verbose
bool verbose
Definition hcg.cxx:73

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ findCmxCpHits() [1/2]

LVL1::CMXCPHits * LVL1BS::CpByteStreamV2Tool::findCmxCpHits ( const CmxCpHitsData & data,
int key ) const
private

Definition at line 1175 of file CpByteStreamV2Tool.cxx.

1177{
1178 CmxCpHitsMap::const_iterator mapIter = data.m_hitsMap.find(key);
1179 if (mapIter != data.m_hitsMap.end()) return mapIter->second;
1180 return nullptr;
1181}

◆ findCmxCpHits() [2/2]

const LVL1::CMXCPHits * LVL1BS::CpByteStreamV2Tool::findCmxCpHits ( int key,
const ConstCmxCpHitsMap & hitsMap ) const
private

Find CMX-CP hits for given key.

Definition at line 1167 of file CpByteStreamV2Tool.cxx.

1169{
1170 ConstCmxCpHitsMap::const_iterator mapIter = hitsMap.find(key);
1171 if (mapIter != hitsMap.end()) return mapIter->second;
1172 return nullptr;
1173}

◆ findCmxCpTob() [1/2]

LVL1::CMXCPTob * LVL1BS::CpByteStreamV2Tool::findCmxCpTob ( const CmxCpTobData & data,
int key ) const
private

Definition at line 1156 of file CpByteStreamV2Tool.cxx.

1158{
1159 CmxCpTobMap::const_iterator mapIter = data.m_tobMap.find(key);
1160 if (mapIter != data.m_tobMap.end()) return mapIter->second;
1161 return nullptr;
1162}

◆ findCmxCpTob() [2/2]

const LVL1::CMXCPTob * LVL1BS::CpByteStreamV2Tool::findCmxCpTob ( int key,
const ConstCmxCpTobMap & tobMap ) const
private

Find CMX-CP TOB for given key.

Definition at line 1148 of file CpByteStreamV2Tool.cxx.

1150{
1151 ConstCmxCpTobMap::const_iterator mapIter = tobMap.find(key);
1152 if (mapIter != tobMap.end()) return mapIter->second;
1153 return nullptr;
1154}

◆ findCpmTower() [1/2]

LVL1::CPMTower * LVL1BS::CpByteStreamV2Tool::findCpmTower ( const CpmTowerData & data,
unsigned int key ) const
private

Definition at line 1137 of file CpByteStreamV2Tool.cxx.

1139{
1140 CpmTowerMap::const_iterator mapIter = data.m_ttMap.find(key);
1141 if (mapIter != data.m_ttMap.end()) return mapIter->second;
1142 return nullptr;
1143}

◆ findCpmTower() [2/2]

const LVL1::CPMTower * LVL1BS::CpByteStreamV2Tool::findCpmTower ( unsigned int key,
const ConstCpmTowerMap & ttMap ) const
private

Find a CPM tower for given key.

Definition at line 1129 of file CpByteStreamV2Tool.cxx.

1131{
1132 ConstCpmTowerMap::const_iterator mapIter = ttMap.find(key);
1133 if (mapIter != ttMap.end()) return mapIter->second;
1134 return nullptr;
1135}

◆ hitsKey()

int LVL1BS::CpByteStreamV2Tool::hitsKey ( int crate,
int cmx,
int source ) const
private

Key for Hits.

Definition at line 1262 of file CpByteStreamV2Tool.cxx.

1264{
1265 return (((crate << 1) | cmx) << 3) | source;
1266}

◆ initialize()

StatusCode LVL1BS::CpByteStreamV2Tool::initialize ( )
overridevirtual

Definition at line 103 of file CpByteStreamV2Tool.cxx.

104{
105 ATH_MSG_INFO( "Initializing " << name() );
106
107 CHECK(m_cpmMaps.retrieve());
108 CHECK(m_errorTool.retrieve());
109 CHECK(m_robDataProvider.retrieve());
110 if (m_enableEncoding.value()) {
111 m_byteStreamCnvSvc = serviceLocator()->service("ByteStreamCnvSvc");
112 ATH_CHECK(m_byteStreamCnvSvc.isValid());
113 }
114
115 return StatusCode::SUCCESS;
116}
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition Control/AthenaKernel/AthenaKernel/errorcheck.h:422

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

const InterfaceID & LVL1BS::CpByteStreamV2Tool::interfaceID ( )
static

AlgTool InterfaceID.

Definition at line 42 of file CpByteStreamV2Tool.cxx.

43{
44 return IID_ICpByteStreamV2Tool;
45}
LVL1BS::IID_ICpByteStreamV2Tool
static const InterfaceID IID_ICpByteStreamV2Tool("CpByteStreamV2Tool", 1, 1)

◆ makeSourceIDs()

std::vector< uint32_t > LVL1BS::CpByteStreamV2Tool::makeSourceIDs ( ) const
private

Create list of all source IDs.

Definition at line 491 of file CpByteStreamV2Tool.cxx.

492{
493 std::vector<uint32_t> sourceIDs;
494
495 if (!m_sourceIDsProp.empty()) {
496 sourceIDs = m_sourceIDsProp;
497 }
498 else {
499 const int maxCrates = m_crates + m_crateOffsetHw;
500 const int maxSlinks = m_srcIdMap.maxSlinks();
501 for (int hwCrate = m_crateOffsetHw; hwCrate < maxCrates; ++hwCrate)
502 {
503 for (int slink = 0; slink < maxSlinks; ++slink)
504 {
505 const int daqOrRoi = 0;
506 const uint32_t rodId = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
507 m_subDetector);
508 const uint32_t robId = m_srcIdMap.getRobID(rodId);
509 sourceIDs.push_back(robId);
510 }
511 }
512 }
513 return sourceIDs;
514}

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ setupCmxCpHitsMap()

void LVL1BS::CpByteStreamV2Tool::setupCmxCpHitsMap ( const CmxCpHitsCollection * hitCollection,
ConstCmxCpHitsMap & hitsMap ) const
private

Set up CMX-CP hits map.

Definition at line 1231 of file CpByteStreamV2Tool.cxx.

1234{
1235 hitsMap.clear();
1236 if (hitCollection)
1237 {
1238 CmxCpHitsCollection::const_iterator pos = hitCollection->begin();
1239 CmxCpHitsCollection::const_iterator pose = hitCollection->end();
1240 for (; pos != pose; ++pos)
1241 {
1242 const LVL1::CMXCPHits *const hits = *pos;
1243 const int crate = hits->crate() - m_crateOffsetSw;
1244 const int cmx = hits->cmx();
1245 const int source = hits->source();
1246 const int key = hitsKey(crate, cmx, source);
1247 hitsMap.insert(std::make_pair(key, hits));
1248 }
1249 }
1250}
DataVector< LVL1::CMXCPHits >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
TRTCalib_Extractor.hits
hits
Definition TRTCalib_Extractor.py:35

◆ setupCmxCpTobMap()

void LVL1BS::CpByteStreamV2Tool::setupCmxCpTobMap ( const CmxCpTobCollection * tobCollection,
ConstCmxCpTobMap & tobMap ) const
private

Set up CMX-CP TOB map.

Definition at line 1206 of file CpByteStreamV2Tool.cxx.

1209{
1210 tobMap.clear();
1211 if (tobCollection)
1212 {
1213 CmxCpTobCollection::const_iterator pos = tobCollection->begin();
1214 CmxCpTobCollection::const_iterator pose = tobCollection->end();
1215 for (; pos != pose; ++pos)
1216 {
1217 const LVL1::CMXCPTob *const tob = *pos;
1218 const int crate = tob->crate() - m_crateOffsetSw;
1219 const int cmx = tob->cmx();
1220 const int cpm = tob->cpm();
1221 const int chip = tob->chip();
1222 const int loc = tob->location();
1223 const int key = tobKey(crate, cmx, cpm, chip, loc);
1224 tobMap.insert(std::make_pair(key, tob));
1225 }
1226 }
1227}
LVL1::CMXCPTob::chip
int chip() const
returns chip number (3 or 4 bits?)
Definition Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:94
LVL1::CMXCPTob::cmx
int cmx() const
returns CMX number (0/1)==(Left/Right)==(Tau/Em)
Definition Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:84
LVL1::CMXCPTob::location
int location() const
returns location (3 or 2 bits?)
Definition Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:99

◆ setupCpmTowerMap()

void LVL1BS::CpByteStreamV2Tool::setupCpmTowerMap ( const CpmTowerCollection * ttCollection,
ConstCpmTowerMap & ttMap,
LVL1::TriggerTowerKey & towerKey ) const
private

Set up CPM tower map.

Definition at line 1185 of file CpByteStreamV2Tool.cxx.

1189{
1190 ttMap.clear();
1191 if (ttCollection)
1192 {
1193 CpmTowerCollection::const_iterator pos = ttCollection->begin();
1194 CpmTowerCollection::const_iterator pose = ttCollection->end();
1195 for (; pos != pose; ++pos)
1196 {
1197 const LVL1::CPMTower *const tt = *pos;
1198 const unsigned int key = towerKey.ttKey(tt->phi(), tt->eta());
1199 ttMap.insert(std::make_pair(key, tt));
1200 }
1201 }
1202}

◆ slinkSlices()

bool LVL1BS::CpByteStreamV2Tool::slinkSlices ( int crate,
int module,
int modulesPerSlink,
int & timeslices,
int & trigJem,
const ConstCpmTowerMap & ttMap,
const ConstCmxCpTobMap & tobMap,
const ConstCmxCpHitsMap & hitsMap,
LVL1::TriggerTowerKey & towerKey ) const
private

Get number of slices and triggered slice offset for next slink.

Definition at line 1270 of file CpByteStreamV2Tool.cxx.

1276{
1277 int slices = -1;
1278 int trigC = m_dfltSlices / 2;
1279 for (int mod = module; mod < module + modulesPerSlink; ++mod)
1280 {
1281 for (int chan = 0; chan < m_channels; ++chan)
1282 {
1283 double eta = 0.;
1284 double phi = 0.;
1285 int layer = 0;
1286 if ( !m_cpmMaps->mapping(crate, mod, chan, eta, phi, layer)) continue;
1287 const unsigned int key = towerKey.ttKey(phi, eta);
1288 const LVL1::CPMTower *const tt = findCpmTower(key, ttMap);
1289 if ( !tt ) continue;
1290 const int numdat = 4;
1291 std::vector<int> sums(numdat);
1292 std::vector<int> sizes(numdat);
1293 sums[0] = std::accumulate((tt->emEnergyVec()).begin(),
1294 (tt->emEnergyVec()).end(), 0);
1295 sums[1] = std::accumulate((tt->hadEnergyVec()).begin(),
1296 (tt->hadEnergyVec()).end(), 0);
1297 sums[2] = std::accumulate((tt->emErrorVec()).begin(),
1298 (tt->emErrorVec()).end(), 0);
1299 sums[3] = std::accumulate((tt->hadErrorVec()).begin(),
1300 (tt->hadErrorVec()).end(), 0);
1301 sizes[0] = (tt->emEnergyVec()).size();
1302 sizes[1] = (tt->hadEnergyVec()).size();
1303 sizes[2] = (tt->emErrorVec()).size();
1304 sizes[3] = (tt->hadErrorVec()).size();
1305 const int peak = tt->peak();
1306 for (int i = 0; i < numdat; ++i)
1307 {
1308 if (sums[i] == 0) continue;
1309 if (slices < 0)
1310 {
1311 slices = sizes[i];
1312 trigC = peak;
1313 }
1314 else if (slices != sizes[i] || trigC != peak) return false;
1315 }
1316 }
1317 }
1318 // CMXs last slink of crate
1319 if (module / modulesPerSlink == m_slinks - 1)
1320 {
1321 for (int cmx = 0; cmx < m_cmxs; ++cmx)
1322 {
1323 for (int cpm = 1; cpm <= m_modules; ++ cpm)
1324 {
1325 for (int chip = 0; chip < m_chips; ++chip)
1326 {
1327 for (int loc = 0; loc < m_locs; ++loc)
1328 {
1329 const int key = tobKey(crate, cmx, cpm, chip, loc);
1330 const LVL1::CMXCPTob *const tob = findCmxCpTob(key,
1331 tobMap);
1332 if (tob)
1333 {
1334 const int numdat = 3;
1335 std::vector<int> sums(numdat);
1336 std::vector<int> sizes(numdat);
1337 sums[0] = std::accumulate((tob->energyVec()).begin(),
1338 (tob->energyVec()).end(), 0);
1339 sums[1] = std::accumulate((tob->isolationVec()).begin(),
1340 (tob->isolationVec()).end(), 0);
1341 sums[2] = std::accumulate((tob->errorVec()).begin(),
1342 (tob->errorVec()).end(), 0);
1343 sizes[0] = (tob->energyVec()).size();
1344 sizes[1] = (tob->isolationVec()).size();
1345 sizes[2] = (tob->errorVec()).size();
1346 const int peak = tob->peak();
1347 for (int i = 0; i < numdat; ++i)
1348 {
1349 if (sums[i] == 0) continue;
1350 if (slices < 0)
1351 {
1352 slices = sizes[i];
1353 trigC = peak;
1354 }
1355 else if (slices != sizes[i] || trigC != peak) return false;
1356 }
1357 }
1358 }
1359 }
1360 }
1361 for (int source = 0; source < LVL1::CMXCPHits::MAXSOURCE; ++source)
1362 {
1363 const int key = hitsKey(crate, cmx, source);
1364
1365 const LVL1::CMXCPHits *const hits = findCmxCpHits(key,
1366 hitsMap);
1367 if (hits)
1368 {
1369 const int numdat = 4;
1370 std::vector<unsigned int> sums(numdat);
1371 std::vector<int> sizes(numdat);
1372 sums[0] = std::accumulate((hits->hitsVec0()).begin(),
1373 (hits->hitsVec0()).end(), 0);
1374 sums[1] = std::accumulate((hits->hitsVec1()).begin(),
1375 (hits->hitsVec1()).end(), 0);
1376 sums[2] = std::accumulate((hits->errorVec0()).begin(),
1377 (hits->errorVec0()).end(), 0);
1378 sums[3] = std::accumulate((hits->errorVec1()).begin(),
1379 (hits->errorVec1()).end(), 0);
1380 sizes[0] = (hits->hitsVec0()).size();
1381 sizes[1] = (hits->hitsVec1()).size();
1382 sizes[2] = (hits->errorVec0()).size();
1383 sizes[3] = (hits->errorVec1()).size();
1384 const int peak = hits->peak();
1385 for (int i = 0; i < numdat; ++i)
1386 {
1387 if (sums[i] == 0) continue;
1388 if (slices < 0)
1389 {
1390 slices = sizes[i];
1391 trigC = peak;
1392 }
1393 else if (slices != sizes[i] || trigC != peak) return false;
1394 }
1395 }
1396 }
1397 }
1398 }
1399 if (slices < 0) slices = m_dfltSlices;
1400 timeslices = slices;
1401 trigCpm = trigC;
1402 return true;
1403}
LVL1::CMXCPTob::isolationVec
const std::vector< int > & isolationVec() const
returns isolation
Definition Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:129
LVL1::CMXCPTob::errorVec
const std::vector< int > & errorVec() const
returns error
Definition Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:134
LVL1::CMXCPTob::energyVec
const std::vector< int > & energyVec() const
For multi-slice readout.
Definition Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:124
keylayer_zslicemap.slices
slices
Definition keylayer_zslicemap.py:112

◆ sourceIDs()

const std::vector< uint32_t > & LVL1BS::CpByteStreamV2Tool::sourceIDs ( ) const

Return reference to vector with all possible Source Identifiers.

Definition at line 516 of file CpByteStreamV2Tool.cxx.

517{
518 static const std::vector<uint32_t> sourceIDs = makeSourceIDs();
519 return sourceIDs;
520}
LVL1BS::CpByteStreamV2Tool::makeSourceIDs
std::vector< uint32_t > makeSourceIDs() const
Create list of all source IDs.
Definition CpByteStreamV2Tool.cxx:491

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ tobKey()

int LVL1BS::CpByteStreamV2Tool::tobKey ( int crate,
int cmx,
int cpm,
int chip,
int loc ) const
private

Key for TOBs.

Definition at line 1254 of file CpByteStreamV2Tool.cxx.

1256{
1257 return (((((((crate << 1) | cmx) << 4) | cpm) << 4) | chip) << 2) | loc;
1258}

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

Member Data Documentation

◆ m_byteStreamCnvSvc

SmartIF<IByteStreamCnvSvc> LVL1BS::CpByteStreamV2Tool::m_byteStreamCnvSvc
private

Definition at line 95 of file CpByteStreamV2Tool.h.

◆ m_channels

const int LVL1BS::CpByteStreamV2Tool::m_channels
private

Number of channels per module.

Definition at line 239 of file CpByteStreamV2Tool.h.

◆ m_chips

const int LVL1BS::CpByteStreamV2Tool::m_chips
private

Number of chips.

Definition at line 249 of file CpByteStreamV2Tool.h.

◆ m_cmxs

const int LVL1BS::CpByteStreamV2Tool::m_cmxs
private

Number of CMXs per crate.

Definition at line 245 of file CpByteStreamV2Tool.h.

◆ m_cpmMaps

ToolHandle<LVL1::IL1CaloMappingTool> LVL1BS::CpByteStreamV2Tool::m_cpmMaps
private

Channel mapping tool.

Definition at line 226 of file CpByteStreamV2Tool.h.

◆ m_crateMax

int LVL1BS::CpByteStreamV2Tool::m_crateMax
private

Property: Maximum crate number when writing out bytestream.

Definition at line 261 of file CpByteStreamV2Tool.h.

◆ m_crateMin

int LVL1BS::CpByteStreamV2Tool::m_crateMin
private

Property: Minimum crate number when writing out bytestream.

Definition at line 259 of file CpByteStreamV2Tool.h.

◆ m_crateOffsetHw

int LVL1BS::CpByteStreamV2Tool::m_crateOffsetHw
private

Property: Hardware crate number offset.

Definition at line 231 of file CpByteStreamV2Tool.h.

◆ m_crateOffsetSw

int LVL1BS::CpByteStreamV2Tool::m_crateOffsetSw
private

Property: Software crate number offset.

Definition at line 233 of file CpByteStreamV2Tool.h.

◆ m_crates

int LVL1BS::CpByteStreamV2Tool::m_crates
private

Property: Number of crates.

Definition at line 241 of file CpByteStreamV2Tool.h.

◆ m_dataFormat

int LVL1BS::CpByteStreamV2Tool::m_dataFormat
private

Property: Data compression format.

Definition at line 237 of file CpByteStreamV2Tool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_dfltSlices

int LVL1BS::CpByteStreamV2Tool::m_dfltSlices
private

Property: Default number of slices in simulation.

Definition at line 255 of file CpByteStreamV2Tool.h.

◆ m_enableEncoding

Gaudi::Property<bool> LVL1BS::CpByteStreamV2Tool::m_enableEncoding
private
Initial value:
{
this, "enableEncoding", true, "Enable conversion from RDO to ByteStream"}

Definition at line 93 of file CpByteStreamV2Tool.h.

93 {
94 this, "enableEncoding", true, "Enable conversion from RDO to ByteStream"};

◆ m_errorTool

ToolHandle<LVL1BS::L1CaloErrorByteStreamTool> LVL1BS::CpByteStreamV2Tool::m_errorTool
private

Error collection tool.

Definition at line 228 of file CpByteStreamV2Tool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_forceSlices

int LVL1BS::CpByteStreamV2Tool::m_forceSlices
private

Property: Force number of slices in bytestream.

Definition at line 257 of file CpByteStreamV2Tool.h.

◆ m_locs

const int LVL1BS::CpByteStreamV2Tool::m_locs
private

Number of Local coordinates.

Definition at line 251 of file CpByteStreamV2Tool.h.

◆ m_maxTobs

const int LVL1BS::CpByteStreamV2Tool::m_maxTobs
private

Maximum number of TOBS per module.

Definition at line 247 of file CpByteStreamV2Tool.h.

◆ m_modules

const int LVL1BS::CpByteStreamV2Tool::m_modules
private

Number of CPM modules per crate.

Definition at line 243 of file CpByteStreamV2Tool.h.

◆ m_robDataProvider

ServiceHandle<IROBDataProviderSvc> LVL1BS::CpByteStreamV2Tool::m_robDataProvider
private

Definition at line 229 of file CpByteStreamV2Tool.h.

◆ m_slinks

int LVL1BS::CpByteStreamV2Tool::m_slinks
private

Property: Number of slinks per crate when writing out bytestream.

Definition at line 253 of file CpByteStreamV2Tool.h.

◆ m_sourceIDsProp

std::vector<uint32_t> LVL1BS::CpByteStreamV2Tool::m_sourceIDsProp
private

Property: ROB source IDs.

Definition at line 267 of file CpByteStreamV2Tool.h.

◆ m_srcIdMap

const L1CaloSrcIdMap LVL1BS::CpByteStreamV2Tool::m_srcIdMap
private

Source ID converter.

Definition at line 265 of file CpByteStreamV2Tool.h.

◆ m_subDetector

const eformat::SubDetector LVL1BS::CpByteStreamV2Tool::m_subDetector
private

Sub-detector type.

Definition at line 263 of file CpByteStreamV2Tool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_version

int LVL1BS::CpByteStreamV2Tool::m_version
private

Property: Sub_block header version.

Definition at line 235 of file CpByteStreamV2Tool.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0