ATLAS Offline Software
CpByteStreamV2Tool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 #include <numeric>
7 #include <set>
8 #include <utility>
9 
10 #include "GaudiKernel/IInterface.h"
11 #include "GaudiKernel/MsgStream.h"
12 #include "GaudiKernel/StatusCode.h"
13 
14 #include "ByteStreamCnvSvcBase/FullEventAssembler.h"
15 
16 #include "TrigT1CaloEvent/CMXCPHits.h"
17 #include "TrigT1CaloEvent/CMXCPTob.h"
18 #include "TrigT1CaloEvent/CPMTower.h"
19 #include "TrigT1CaloEvent/CPBSCollectionV2.h"
20 #include "TrigT1CaloUtils/DataError.h"
21 #include "TrigT1CaloUtils/TriggerTowerKey.h"
22 #include "TrigT1CaloToolInterfaces/IL1CaloMappingTool.h"
23 
24 #include "CmxCpSubBlock.h"
25 #include "CmxSubBlock.h"
26 #include "CpmSubBlockV2.h"
27 #include "L1CaloErrorByteStreamTool.h"
28 #include "L1CaloSrcIdMap.h"
29 #include "L1CaloSubBlock.h"
30 #include "L1CaloUserHeader.h"
31 #include "ModifySlices.h"
32 
33 #include "CpByteStreamV2Tool.h"
34 
35 #include "CxxUtils/starts_with.h"
36 
37 namespace LVL1BS
38 {
39 
40 // Interface ID
41 
42 static const InterfaceID IID_ICpByteStreamV2Tool("CpByteStreamV2Tool", 1, 1);
43 
44 const InterfaceID &CpByteStreamV2Tool::interfaceID()
45 {
46  return IID_ICpByteStreamV2Tool;
47 }
48 
49 // Constructor
50 
51 CpByteStreamV2Tool::CpByteStreamV2Tool(const std::string &type,
52  const std::string &name,
53  const IInterface *parent)
54  : AthAlgTool(type, name, parent),
55  m_cpmMaps("LVL1::CpmMappingTool/CpmMappingTool"),
56  m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
57  m_robDataProvider("ROBDataProviderSvc", name),
58  m_channels(80), m_crates(4), m_modules(14), m_cmxs(2), m_maxTobs(5),
59  m_chips(16), m_locs(4),
60  m_subDetector(eformat::TDAQ_CALO_CLUSTER_PROC_DAQ)
61 {
62  declareInterface<CpByteStreamV2Tool>(this);
63 
64  declareProperty("CpmMappingTool", m_cpmMaps,
65  "Crate/Module/Channel to Eta/Phi/Layer mapping tool");
66  declareProperty("ErrorTool", m_errorTool,
67  "Tool to collect errors for monitoring");
68 
69  declareProperty("CrateOffsetHw", m_crateOffsetHw = 8,
70  "Offset of CP crate numbers in bytestream");
71  declareProperty("CrateOffsetSw", m_crateOffsetSw = 0,
72  "Offset of CP crate numbers in RDOs");
73 
74  // Properties for reading bytestream only
75  declareProperty("ROBSourceIDs", m_sourceIDsProp,
76  "ROB fragment source identifiers");
77 
78  // Properties for writing bytestream only
79  declareProperty("DataVersion", m_version = 2, // <<== CHECK
80  "Format version number in sub-block header");
81  declareProperty("DataFormat", m_dataFormat = 1,
82  "Format identifier (0-1) in sub-block header");
83  declareProperty("SlinksPerCrate", m_slinks = 2,
84  "The number of S-Links per crate");
85  declareProperty("SimulSlices", m_dfltSlices = 1,
86  "The number of slices in the simulation");
87  declareProperty("ForceSlices", m_forceSlices = 0,
88  "If >0, the number of slices in bytestream");
89  declareProperty("CrateMin", m_crateMin = 0,
90  "Minimum crate number, allows partial output");
91  declareProperty("CrateMax", m_crateMax = m_crates - 1,
92  "Maximum crate number, allows partial output");
93 
94 }
95 
96 // Destructor
97 
98 CpByteStreamV2Tool::~CpByteStreamV2Tool()
99 {
100 }
101 
102 // Initialize
103 
104 
105 StatusCode CpByteStreamV2Tool::initialize()
106 {
107  ATH_MSG_INFO( "Initializing " << name() );
108 
109  CHECK(m_cpmMaps.retrieve());
110  CHECK(m_errorTool.retrieve());
111  CHECK(m_robDataProvider.retrieve());
112  if (m_enableEncoding.value()) {
113  m_byteStreamCnvSvc = serviceLocator()->service("ByteStreamCnvSvc");
114  ATH_CHECK(m_byteStreamCnvSvc.isValid());
115  }
116 
117  return StatusCode::SUCCESS;
118 }
119 
120 // Conversion bytestream to CPM towers
121 StatusCode CpByteStreamV2Tool::convert(
122  const std::string& sgKey,
123  DataVector<LVL1::CPMTower> *const ttCollection) const
124 {
125  const std::vector<uint32_t>& vID(sourceIDs());
126  // // get ROB fragments
127  IROBDataProviderSvc::VROBFRAG robFrags;
128  m_robDataProvider->getROBData(vID, robFrags, "CpByteStreamV2Tool");
129  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
130  return convert(sgKey, robFrags, ttCollection);
131 }
132 
133 StatusCode CpByteStreamV2Tool::convert(
134  const std::string& sgKey,
135  const IROBDataProviderSvc::VROBFRAG &robFrags,
136  DataVector<LVL1::CPMTower> *const ttCollection) const
137 {
138  CpmTowerData data (ttCollection);
139  return convertBs(sgKey, robFrags, data);
140 }
141 
142 // Conversion bytestream to CMX-CP TOBs
143 StatusCode CpByteStreamV2Tool::convert(
144  const std::string& sgKey,
145  DataVector<LVL1::CMXCPTob> *const tobCollection) const
146 {
147  const std::vector<uint32_t>& vID(sourceIDs());
148  // // get ROB fragments
149  IROBDataProviderSvc::VROBFRAG robFrags;
150  m_robDataProvider->getROBData(vID, robFrags, "CpByteStreamV2Tool");
151  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
152  return convert(sgKey, robFrags, tobCollection);
153 }
154 
155 StatusCode CpByteStreamV2Tool::convert(
156  const std::string& sgKey,
157  const IROBDataProviderSvc::VROBFRAG &robFrags,
158  DataVector<LVL1::CMXCPTob> *const tobCollection) const
159 {
160  CmxCpTobData data (tobCollection);
161  return convertBs(sgKey, robFrags, data);
162 }
163 
164 // Conversion bytestream to CMX-CP hits
165 StatusCode CpByteStreamV2Tool::convert(
166  const std::string& sgKey,
167  DataVector<LVL1::CMXCPHits> *const hitCollection) const
168 {
169  const std::vector<uint32_t>& vID(sourceIDs());
170  // // get ROB fragments
171  IROBDataProviderSvc::VROBFRAG robFrags;
172  m_robDataProvider->getROBData(vID, robFrags, "CpByteStreamV2Tool");
173  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
174  return convert(sgKey, robFrags, hitCollection);
175 }
176 
177 StatusCode CpByteStreamV2Tool::convert(
178  const std::string& sgKey,
179  const IROBDataProviderSvc::VROBFRAG &robFrags,
180  DataVector<LVL1::CMXCPHits> *const hitCollection) const
181 {
182  CmxCpHitsData data (hitCollection);
183  return convertBs(sgKey, robFrags, data);
184 }
185 
186 // Conversion of CP container to bytestream
187 
188 StatusCode CpByteStreamV2Tool::convert(const LVL1::CPBSCollectionV2 *const cp) const
189 {
190  if (not m_enableEncoding.value()) {
191  ATH_MSG_ERROR("Encoding method called while " << m_enableEncoding.name() << "=False");
192  return StatusCode::FAILURE;
193  }
194 
195  const bool debug = msgLvl(MSG::DEBUG);
196  if (debug) msg(MSG::DEBUG);
197 
198  // Get the event assembler
199  FullEventAssembler<L1CaloSrcIdMap>* fea = nullptr;
200  ATH_CHECK( m_byteStreamCnvSvc->getFullEventAssembler (fea,
201  "CpByteStreamV2") );
202  const uint16_t minorVersion = m_srcIdMap.minorVersion();
203  fea->setRodMinorVersion(minorVersion);
204 
205  // Pointer to ROD data vector
206 
207  FullEventAssembler<L1CaloSrcIdMap>::RODDATA *theROD = 0;
208 
209  LVL1::TriggerTowerKey towerKey;
210 
211  // Set up the container maps
212 
213  // CPM tower map
214  ConstCpmTowerMap ttMap;
215  setupCpmTowerMap(cp->towers(), ttMap, towerKey);
216 
217  // CMX-CP TOB map
218  ConstCmxCpTobMap tobMap;
219  setupCmxCpTobMap(cp->tobs(), tobMap);
220 
221  // CMX-CP hits map
222  ConstCmxCpHitsMap hitsMap;
223  setupCmxCpHitsMap(cp->hits(), hitsMap);
224 
225  // Loop over data
226 
227  const bool neutralFormat = m_dataFormat == L1CaloSubBlock::NEUTRAL;
228  const int modulesPerSlink = m_modules / m_slinks;
229  int timeslices = 1;
230  int trigCpm = 0;
231  int timeslicesNew = 1;
232  int trigCpmNew = 0;
233  for (int crate = m_crateMin; crate <= m_crateMax; ++crate)
234  {
235  const int hwCrate = crate + m_crateOffsetHw;
236 
237  // CPM modules are numbered 1 to m_modules
238  for (int module = 1; module <= m_modules; ++module)
239  {
240  const int mod = module - 1;
241 
242  // Pack required number of modules per slink
243 
244  if (mod % modulesPerSlink == 0)
245  {
246  const int daqOrRoi = 0;
247  const int slink = (m_slinks == 2) ? 2 * (mod / modulesPerSlink)
248  : mod / modulesPerSlink;
249  if (debug)
250  {
251  msg() << "Treating crate " << hwCrate
252  << " slink " << slink << endmsg;
253  }
254  // Get number of CPM slices and triggered slice offset
255  // for this slink
256  if ( ! slinkSlices(crate, module, modulesPerSlink,
257  timeslices, trigCpm,
258  ttMap,
259  tobMap,
260  hitsMap,
261  towerKey))
262  {
263  msg(MSG::ERROR) << "Inconsistent number of slices or "
264  << "triggered slice offsets in data for crate "
265  << hwCrate << " slink " << slink << endmsg;
266  return StatusCode::FAILURE;
267  }
268  timeslicesNew = (m_forceSlices) ? m_forceSlices : timeslices;
269  trigCpmNew = ModifySlices::peak(trigCpm, timeslices, timeslicesNew);
270  if (debug)
271  {
272  msg() << "Data Version/Format: " << m_version
273  << " " << m_dataFormat << endmsg
274  << "Slices/offset: " << timeslices << " " << trigCpm;
275  if (timeslices != timeslicesNew)
276  {
277  msg() << " modified to " << timeslicesNew << " " << trigCpmNew;
278  }
279  msg() << endmsg;
280  }
281  L1CaloUserHeader userHeader;
282  userHeader.setCpm(trigCpmNew);
283  const uint32_t rodIdCpm = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
284  m_subDetector);
285  theROD = fea->getRodData(rodIdCpm);
286  theROD->push_back(userHeader.header());
287  }
288  if (debug) msg() << "Module " << module << endmsg;
289 
290  // Create a sub-block for each slice (except Neutral format)
291 
292  DataVector<CpmSubBlockV2> cpmBlocks;
293  for (int slice = 0; slice < timeslicesNew; ++slice)
294  {
295  CpmSubBlockV2 *const subBlock = new CpmSubBlockV2();
296  subBlock->setCpmHeader(m_version, m_dataFormat, slice,
297  hwCrate, module, timeslicesNew);
298  cpmBlocks.push_back(subBlock);
299  if (neutralFormat) break;
300  }
301 
302  // Find CPM towers corresponding to each eta/phi pair and fill
303  // sub-blocks
304 
305  for (int chan = 0; chan < m_channels; ++chan)
306  {
307  double eta = 0.;
308  double phi = 0.;
309  int layer = 0;
310  if (m_cpmMaps->mapping(crate, module, chan, eta, phi, layer))
311  {
312  const unsigned int key = towerKey.ttKey(phi, eta);
313  const LVL1::CPMTower *const tt = findCpmTower(key, ttMap);
314  if (tt )
315  {
316  std::vector<int> emData;
317  std::vector<int> hadData;
318  std::vector<int> emError;
319  std::vector<int> hadError;
320  ModifySlices::data(tt->emEnergyVec(), emData, timeslicesNew);
321  ModifySlices::data(tt->hadEnergyVec(), hadData, timeslicesNew);
322  ModifySlices::data(tt->emErrorVec(), emError, timeslicesNew);
323  ModifySlices::data(tt->hadErrorVec(), hadError, timeslicesNew);
324  for (int slice = 0; slice < timeslicesNew; ++slice)
325  {
326  const LVL1::DataError emErrBits(emError[slice]);
327  const LVL1::DataError hadErrBits(hadError[slice]);
328  const int emErr =
329  (emErrBits.get(LVL1::DataError::LinkDown) << 1) |
330  emErrBits.get(LVL1::DataError::Parity);
331  const int hadErr =
332  (hadErrBits.get(LVL1::DataError::LinkDown) << 1) |
333  hadErrBits.get(LVL1::DataError::Parity);
334  const int index = ( neutralFormat ) ? 0 : slice;
335  CpmSubBlockV2 *const subBlock = cpmBlocks[index];
336  subBlock->fillTowerData(slice, chan, emData[slice],
337  hadData[slice], emErr, hadErr);
338  if ((emErrBits.error() >> LVL1::DataError::GLinkParity))
339  {
340  int gLinkParity = emErrBits.get(LVL1::DataError::GLinkParity);
341  int gLinkProtocol = emErrBits.get(LVL1::DataError::GLinkProtocol);
342  int bCNMismatch = emErrBits.get(LVL1::DataError::BCNMismatch);
343  int fIFOOverflow = emErrBits.get(LVL1::DataError::FIFOOverflow);
344  int moduleError = emErrBits.get(LVL1::DataError::ModuleError);
345  int gLinkDown = emErrBits.get(LVL1::DataError::GLinkDown);
346  int gLinkTimeout = emErrBits.get(LVL1::DataError::GLinkTimeout);
347  uint32_t failingBCN = emErrBits.get(LVL1::DataError::FailingBCN);
348  subBlock->setStatus(failingBCN, gLinkTimeout, gLinkDown,
349  moduleError, fIFOOverflow, bCNMismatch,
350  gLinkProtocol, gLinkParity);
351  }
352  }
353  }
354  }
355  }
356 
357  // Pack and write the sub-blocks
358 
359  DataVector<CpmSubBlockV2>::iterator pos;
360  for (pos = cpmBlocks.begin(); pos != cpmBlocks.end(); ++pos)
361  {
362  CpmSubBlockV2 *const subBlock = *pos;
363  if ( !subBlock->pack())
364  {
365  msg(MSG::ERROR) << "CPM sub-block packing failed" << endmsg;
366  return StatusCode::FAILURE;
367  }
368  if (debug)
369  {
370  msg() << "CPM sub-block data words: "
371  << subBlock->dataWords() << endmsg;
372  }
373  subBlock->write(theROD);
374  }
375  }
376 
377  // Append CMXs to last S-Link of the crate
378 
379  for (int cmx = 0; cmx < m_cmxs; ++cmx)
380  {
381 
382  // Create a sub-block for each slice (except Neutral format)
383 
384  DataVector<CmxCpSubBlock> cmxBlocks;
385  const int summing = (crate == m_crates - 1) ? CmxSubBlock::SYSTEM
386  : CmxSubBlock::CRATE;
387  for (int slice = 0; slice < timeslicesNew; ++slice)
388  {
389  CmxCpSubBlock *const block = new CmxCpSubBlock();
390  block->setCmxHeader(m_version, m_dataFormat, slice, hwCrate,
391  summing, CmxSubBlock::CMX_CP, cmx, timeslicesNew);
392  cmxBlocks.push_back(block);
393  if (neutralFormat) break;
394  }
395 
396  // CMX-CP Tobs
397 
398  for (int cpm = 1; cpm <= m_modules; ++cpm)
399  {
400  for (int chip = 0; chip < m_chips; ++chip)
401  {
402  for (int loc = 0; loc < m_locs; ++loc)
403  {
404  const int key = tobKey(crate, cmx, cpm, chip, loc);
405  const LVL1::CMXCPTob *const ct = findCmxCpTob(key,
406  tobMap);
407  if ( ct )
408  {
409  std::vector<int> energy;
410  std::vector<int> isolation;
411  std::vector<int> error;
412  std::vector<unsigned int> presence;
413  ModifySlices::data(ct->energyVec(), energy, timeslicesNew);
414  ModifySlices::data(ct->isolationVec(), isolation, timeslicesNew);
415  ModifySlices::data(ct->errorVec(), error, timeslicesNew);
416  ModifySlices::data(ct->presenceMapVec(), presence, timeslicesNew);
417  for (int slice = 0; slice < timeslicesNew; ++slice)
418  {
419  const LVL1::DataError errBits(error[slice]);
420  int err = errBits.get(LVL1::DataError::ParityMerge);
421  err |= (errBits.get(LVL1::DataError::ParityPhase0)) << 1;
422  err |= (errBits.get(LVL1::DataError::ParityPhase1)) << 2;
423  err |= (errBits.get(LVL1::DataError::ParityPhase2)) << 3;
424  err |= (errBits.get(LVL1::DataError::ParityPhase3)) << 4;
425  err |= (errBits.get(LVL1::DataError::Overflow)) << 5;
426  const int index = ( neutralFormat ) ? 0 : slice;
427  CmxCpSubBlock *const subBlock = cmxBlocks[index];
428  subBlock->setTob(slice, cpm, chip, loc, energy[slice],
429  isolation[slice], err);
430  subBlock->setPresenceMap(slice, cpm, presence[slice]);
431  }
432  }
433  }
434  }
435  }
436 
437  // CMX-CP Hits
438 
439  for (int source = 0; source < LVL1::CMXCPHits::MAXSOURCE; ++source)
440  {
441  const int key = hitsKey(crate, cmx, source);
442  const LVL1::CMXCPHits *const ch = findCmxCpHits(key, hitsMap);
443  if ( ch )
444  {
445  std::vector<unsigned int> hits0;
446  std::vector<unsigned int> hits1;
447  std::vector<int> err0;
448  std::vector<int> err1;
449  ModifySlices::data(ch->hitsVec0(), hits0, timeslicesNew);
450  ModifySlices::data(ch->hitsVec1(), hits1, timeslicesNew);
451  ModifySlices::data(ch->errorVec0(), err0, timeslicesNew);
452  ModifySlices::data(ch->errorVec1(), err1, timeslicesNew);
453  for (int slice = 0; slice < timeslicesNew; ++slice)
454  {
455  const LVL1::DataError err0Bits(err0[slice]);
456  const LVL1::DataError err1Bits(err1[slice]);
457  const int index = ( neutralFormat ) ? 0 : slice;
458  CmxCpSubBlock *const subBlock = cmxBlocks[index];
459  subBlock->setHits(slice, source, 0, hits0[slice], // Assuming CMXCPHits::source == CmxCpSubBlock::source
460  err0Bits.get(LVL1::DataError::Parity));
461  subBlock->setHits(slice, source, 1, hits1[slice],
462  err1Bits.get(LVL1::DataError::Parity));
463  if (neutralFormat) // Neutral format wants RoI overflow bit
464  {
465  subBlock->setRoiOverflow(slice, source,
466  err0Bits.get(LVL1::DataError::Overflow));
467  }
468  }
469  }
470  }
471  for (CmxCpSubBlock* subBlock : cmxBlocks)
472  {
473  if ( !subBlock->pack())
474  {
475  msg(MSG::ERROR) << "CMX-Cp sub-block packing failed" << endmsg;
476  return StatusCode::FAILURE;
477  }
478  if (debug)
479  {
480  msg() << "CMX-Cp sub-block data words: "
481  << subBlock->dataWords() << endmsg;
482  }
483  subBlock->write(theROD);
484  }
485  }
486  }
487 
488  return StatusCode::SUCCESS;
489 }
490 
491 // Return reference to vector with all possible Source Identifiers
492 
493 std::vector<uint32_t> CpByteStreamV2Tool::makeSourceIDs() const
494 {
495  std::vector<uint32_t> sourceIDs;
496 
497  if (!m_sourceIDsProp.empty()) {
498  sourceIDs = m_sourceIDsProp;
499  }
500  else {
501  const int maxCrates = m_crates + m_crateOffsetHw;
502  const int maxSlinks = m_srcIdMap.maxSlinks();
503  for (int hwCrate = m_crateOffsetHw; hwCrate < maxCrates; ++hwCrate)
504  {
505  for (int slink = 0; slink < maxSlinks; ++slink)
506  {
507  const int daqOrRoi = 0;
508  const uint32_t rodId = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
509  m_subDetector);
510  const uint32_t robId = m_srcIdMap.getRobID(rodId);
511  sourceIDs.push_back(robId);
512  }
513  }
514  }
515  return sourceIDs;
516 }
517 
518 const std::vector<uint32_t> &CpByteStreamV2Tool::sourceIDs() const
519 {
520  static const std::vector<uint32_t> sourceIDs = makeSourceIDs();
521  return sourceIDs;
522 }
523 
524 // Convert bytestream to given container type
525 
526 StatusCode CpByteStreamV2Tool::convertBs(
527  const std::string& sgKey,
528  const IROBDataProviderSvc::VROBFRAG &robFrags,
529  CpByteStreamToolData& data) const
530 {
531  LocalData ld;
532 
533  ld.coreOverlap =
534  CxxUtils::ends_with (sgKey, "Overlap") || CxxUtils::ends_with (sgKey, "OverlapAux.");
535 
536  const bool debug = msgLvl(MSG::DEBUG);
537  if (debug) msg(MSG::DEBUG);
538 
539  CmxCpSubBlock cmxCpSubBlock;
540  CpmSubBlockV2 cpmSubBlock;
541 
542  // Loop over ROB fragments
543 
544  int robCount = 0;
545  std::set<uint32_t> dupCheck;
546  ROBIterator rob = robFrags.begin();
547  ROBIterator robEnd = robFrags.end();
548  for (; rob != robEnd; ++rob)
549  {
550  ++robCount;
551  ATH_MSG_DEBUG("Treating ROB fragment " << robCount << " source_id = " << std::hex << (*rob)->rob_source_id() << std::dec);
552 
553  // Skip fragments with ROB status errors
554 
555  const uint32_t robid = (*rob)->source_id();
556  if ((*rob)->nstatus() > 0)
557  {
558  ROBPointer robData;
559  (*rob)->status(robData);
560  if (*robData != 0)
561  {
562  m_errorTool->robError(robid, *robData);
563  if (debug) msg() << "ROB status error - skipping fragment" << endmsg;
564  continue;
565  }
566  }
567 
568  // Skip duplicate fragments
569 
570  if (!dupCheck.insert(robid).second)
571  {
572  m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_DUPLICATE_ROB);
573  if (debug) msg() << "Skipping duplicate ROB fragment" << endmsg;
574  continue;
575  }
576 
577  // Unpack ROD data (slinks)
578 
579  RODPointer payloadBeg;
580  RODPointer payload;
581  RODPointer payloadEnd;
582  (*rob)->rod_data(payloadBeg);
583  payloadEnd = payloadBeg + (*rob)->rod_ndata();
584  payload = payloadBeg;
585  if (payload == payloadEnd)
586  {
587  if (debug) msg() << "ROB fragment empty" << endmsg;
588  continue;
589  }
590 
591  // Check identifier
592  const uint32_t sourceID = (*rob)->rod_source_id();
593  if (m_srcIdMap.getRobID(sourceID) != robid ||
594  m_srcIdMap.subDet(sourceID) != m_subDetector ||
595  m_srcIdMap.daqOrRoi(sourceID) != 0 ||
596  (m_srcIdMap.slink(sourceID) != 0 && m_srcIdMap.slink(sourceID) != 2) ||
597  m_srcIdMap.crate(sourceID) < m_crateOffsetHw ||
598  m_srcIdMap.crate(sourceID) >= m_crateOffsetHw + m_crates)
599  {
600  m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_ROD_ID);
601  if (debug)
602  {
603  msg() << "Wrong source identifier in data: ROD "
604  << MSG::hex << sourceID << " ROB " << robid
605  << MSG::dec << endmsg;
606  }
607  continue;
608  }
609 
610  // Check minor version
611  const int minorVersion = (*rob)->rod_version() & 0xffff;
612 
613  if (minorVersion <= m_srcIdMap.minorVersionPreLS1())
614  {
615  if (debug) msg() << "Skipping pre-LS1 data" << endmsg;
616  continue;
617  }
618  const int rodCrate = m_srcIdMap.crate(sourceID);
619  if (debug)
620  {
621  msg() << "Treating crate " << rodCrate
622  << " slink " << m_srcIdMap.slink(sourceID) << endmsg;
623  }
624 
625  // First word should be User Header
626  if ( !L1CaloUserHeader::isValid(*payload) )
627  {
628  m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_USER_HEADER);
629  if (debug) msg() << "Invalid or missing user header" << endmsg;
630  continue;
631  }
632  L1CaloUserHeader userHeader(*payload);
633  userHeader.setVersion(minorVersion);
634  const int headerWords = userHeader.words();
635  if (headerWords != 1)
636  {
637  m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_USER_HEADER);
638  if (debug) msg() << "Unexpected number of user header words: "
639  << headerWords << endmsg;
640  continue;
641  }
642  for (int i = 0; i < headerWords; ++i) ++payload;
643  // triggered slice offset
644  const int trigCpm = userHeader.cpm();
645  if (debug)
646  {
647  msg() << "Minor format version number: " << MSG::hex
648  << minorVersion << MSG::dec << endmsg
649  << "Triggered slice offset: " << trigCpm << endmsg;
650  }
651 
652  // Loop over sub-blocks
653 
654  ld.rodErr = L1CaloSubBlock::ERROR_NONE;
655  while (payload != payloadEnd)
656  {
657  if (L1CaloSubBlock::wordType(*payload) != L1CaloSubBlock::HEADER)
658  {
659  if (debug) msg() << "Unexpected data sequence" << endmsg;
660  ld.rodErr = L1CaloSubBlock::ERROR_MISSING_HEADER;
661  break;
662  }
663 
664  // TODO: (sasha) Comment this check since firmware does not ready
665  // Select right tool by ROD version
666  // if (L1CaloSubBlock::version(*payload) == 1) {
667  // if (debug) msg() << "Skipping pre-LS1 data" << endmsg;
668  // break;
669  // }
670 
671  if (CmxSubBlock::cmxBlock(*payload))
672  {
673  // CMX
674  if (CmxSubBlock::cmxType(*payload) == CmxSubBlock::CMX_CP)
675  {
676  cmxCpSubBlock.clear();
677  payload = cmxCpSubBlock.read(payload, payloadEnd);
678  if (cmxCpSubBlock.crate() != rodCrate)
679  {
680  if (debug) msg() << "Inconsistent crate number in ROD source ID"
681  << endmsg;
682  ld.rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
683  break;
684  }
685 
686  if (data.m_collection == CMX_CP_TOBS || data.m_collection == CMX_CP_HITS)
687  {
688  decodeCmxCp(&cmxCpSubBlock, trigCpm, data, ld);
689  if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
690  {
691  if (debug) msg() << "decodeCmxCp failed" << endmsg;
692  break;
693  }
694  }
695  }
696  else
697  {
698  if (debug) msg() << "Invalid CMX type in module field" << endmsg;
699  ld.rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
700  break;
701  }
702  }
703  else
704  {
705  // CPM
706  cpmSubBlock.clear();
707  payload = cpmSubBlock.read(payload, payloadEnd);
708  if (cpmSubBlock.crate() != rodCrate)
709  {
710  if (debug) msg() << "Inconsistent crate number in ROD source ID"
711  << endmsg;
712  ld.rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
713  break;
714  }
715  if (data.m_collection == CPM_TOWERS)
716  {
717  decodeCpm(&cpmSubBlock, trigCpm, static_cast<CpmTowerData&>(data), ld);
718  if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
719  {
720  if (debug) msg() << "decodeCpm failed" << endmsg;
721  break;
722  }
723  }
724  }
725  }
726  if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
727  {
728  m_errorTool->rodError(robid, ld.rodErr);
729  }
730  }
731  return StatusCode::SUCCESS;
732 }
733 
734 // Unpack CMX-CP sub-block
735 
736 void CpByteStreamV2Tool::decodeCmxCp(CmxCpSubBlock *subBlock, int trigCpm,
737  CpByteStreamToolData& data,
738  LocalData& ld) const
739 {
740  const bool debug = msgLvl(MSG::DEBUG);
741  if (debug) msg(MSG::DEBUG);
742 
743  const int hwCrate = subBlock->crate();
744  const int cmx = subBlock->cmxPosition();
745  const int firmware = subBlock->cmxFirmware();
746  const int summing = subBlock->cmxSumming();
747  const int timeslices = subBlock->timeslices();
748  const int sliceNum = subBlock->slice();
749  if (debug)
750  {
751  msg() << "CMX-CP: Crate " << hwCrate
752  << " Position " << cmx
753  << " Firmware " << firmware
754  << " Summing " << summing
755  << " Total slices " << timeslices
756  << " Slice " << sliceNum
757  << endmsg;
758  }
759  if (timeslices <= trigCpm)
760  {
761  if (debug) msg() << "Triggered slice from header "
762  << "inconsistent with number of slices: "
763  << trigCpm << ", " << timeslices << endmsg;
764  ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
765  return;
766  }
767  if (timeslices <= sliceNum)
768  {
769  if (debug) msg() << "Total slices inconsistent with slice number: "
770  << timeslices << ", " << sliceNum << endmsg;
771  ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
772  return;
773  }
774  // Unpack sub-block
775  if (subBlock->dataWords() && !subBlock->unpack())
776  {
777  if (debug)
778  {
779  std::string errMsg(subBlock->unpackErrorMsg());
780  msg() << "CMX-CP sub-block unpacking failed: " << errMsg << endmsg;
781  }
782  ld.rodErr = subBlock->unpackErrorCode();
783  return;
784  }
785 
786  // Retrieve required data
787 
788  const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
789  LVL1::DataError dErr;
790  dErr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
791  const int subStatus = dErr.error();
792  const int crate = hwCrate - m_crateOffsetHw;
793  const int swCrate = crate + m_crateOffsetSw;
794  const int maxSid = CmxCpSubBlock::MAX_SOURCE_ID;
795  const int sliceBeg = ( neutralFormat ) ? 0 : sliceNum;
796  const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
797  for (int slice = sliceBeg; slice < sliceEnd; ++slice)
798  {
799 
800  if (data.m_collection == CMX_CP_TOBS)
801  {
802  CmxCpTobData& tdata = static_cast<CmxCpTobData&> (data);
803 
804  // TOBs
805 
806  for (int cpm = 1; cpm <= m_modules; ++cpm)
807  {
808  const unsigned int presenceMap = subBlock->presenceMap(slice, cpm);
809  for (int tob = 0; tob < m_maxTobs; ++tob)
810  {
811  const int energy = subBlock->energy(slice, cpm, tob);
812  const int isolation = subBlock->isolation(slice, cpm, tob);
813  int error = subBlock->tobError(slice, cpm, tob);
814  if (energy == 0 && isolation == 0 && error == 0) break;
815  const int loc = subBlock->localCoord(slice, cpm, tob);
816  const int chip = subBlock->chip(slice, cpm, tob);
817  LVL1::DataError errBits(subStatus);
818  if (error)
819  {
820  errBits.set(LVL1::DataError::ParityPhase0, error);
821  errBits.set(LVL1::DataError::ParityPhase1, (error >> 1));
822  errBits.set(LVL1::DataError::ParityPhase2, (error >> 2));
823  errBits.set(LVL1::DataError::ParityPhase3, (error >> 3));
824  errBits.set(LVL1::DataError::Overflow, (error >> 4));
825  errBits.set(LVL1::DataError::ParityMerge, (error >> 5));
826  errBits.set(LVL1::DataError::Parity, (error & 0x2f) ? 1 : 0);
827  }
828  error = errBits.error();
829  const int key = tobKey(crate, cmx, cpm, chip, loc);
830  LVL1::CMXCPTob *tb = findCmxCpTob(tdata, key);
831  if ( ! tb ) // create new CMX TOB
832  {
833  ld.energyVec.assign(timeslices, 0);
834  ld.isolVec.assign(timeslices, 0);
835  ld.errorVec.assign(timeslices, 0);
836  ld.presenceMapVec.assign(timeslices, 0);
837  ld.energyVec[slice] = energy;
838  ld.isolVec[slice] = isolation;
839  ld.errorVec[slice] = error;
840  ld.presenceMapVec[slice] = presenceMap;
841  auto tbp =
842  std::make_unique<LVL1::CMXCPTob>(swCrate, cmx, cpm, chip, loc,
843  ld.energyVec, ld.isolVec, ld.errorVec,
844  ld.presenceMapVec, trigCpm);
845  tdata.m_tobMap.insert(std::make_pair(key, tbp.get()));
846  tdata.m_tobCollection->push_back(std::move(tbp));
847  }
848  else
849  {
850  ld.energyVec = tb->energyVec();
851  ld.isolVec = tb->isolationVec();
852  ld.errorVec = tb->errorVec();
853  ld.presenceMapVec = tb->presenceMapVec();
854  const int nsl = ld.energyVec.size();
855  if (timeslices != nsl)
856  {
857  if (debug) msg() << "Inconsistent number of slices in sub-blocks"
858  << endmsg;
859  ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
860  return;
861  }
862  if (ld.energyVec[slice] != 0 || ld.isolVec[slice] != 0 ||
863  ld.errorVec[slice] != 0)
864  {
865  if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
866  ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
867  return;
868  }
869  ld.energyVec[slice] = energy;
870  ld.isolVec[slice] = isolation;
871  ld.errorVec[slice] = error;
872  ld.presenceMapVec[slice] = presenceMap;
873  tb->addTob(ld.energyVec, ld.isolVec, ld.errorVec, ld.presenceMapVec);
874  }
875  }
876  }
877 
878  }
879  else if (data.m_collection == CMX_CP_HITS)
880  {
881  CmxCpHitsData& hdata = static_cast<CmxCpHitsData&> (data);
882 
883  // Hit/Topo counts
884 
885  for (int source = 0; source < maxSid; ++source)
886  {
887  if (summing == CmxSubBlock::CRATE &&
888  (source == CmxCpSubBlock::REMOTE_0 ||
889  source == CmxCpSubBlock::REMOTE_1 ||
890  source == CmxCpSubBlock::REMOTE_2 ||
891  source == CmxCpSubBlock::TOTAL)) continue;
892  const unsigned int hits0 = subBlock->hits(slice, source, 0); //low
893  const unsigned int hits1 = subBlock->hits(slice, source, 1); //high
894  int err0 = subBlock->hitsError(slice, source, 0);
895  int err1 = subBlock->hitsError(slice, source, 1);
896  int overflow = subBlock->roiOverflow(slice, source);
897  LVL1::DataError err0Bits(subStatus);
898  err0Bits.set(LVL1::DataError::Parity, err0);
899  err0Bits.set(LVL1::DataError::Overflow, overflow);
900  err0 = err0Bits.error();
901  LVL1::DataError err1Bits(subStatus);
902  err1Bits.set(LVL1::DataError::Parity, err1);
903  err1Bits.set(LVL1::DataError::Overflow, overflow);
904  err1 = err1Bits.error();
905  if (hits0 || hits1 || err0 || err1)
906  {
907  const int key = hitsKey(crate, cmx, source);
908  LVL1::CMXCPHits *ch = findCmxCpHits(hdata, key);
909  if ( ! ch ) // create new CMX hits
910  {
911  ld.hitsVec0.assign(timeslices, 0);
912  ld.hitsVec1.assign(timeslices, 0);
913  ld.errVec0.assign(timeslices, 0);
914  ld.errVec1.assign(timeslices, 0);
915  ld.hitsVec0[slice] = hits0;
916  ld.hitsVec1[slice] = hits1;
917  ld.errVec0[slice] = err0;
918  ld.errVec1[slice] = err1;
919  auto chp =
920  std::make_unique<LVL1::CMXCPHits>(swCrate, cmx, source,
921  ld.hitsVec0, ld.hitsVec1,
922  ld.errVec0, ld.errVec1, trigCpm);
923  hdata.m_hitsMap.insert(std::make_pair(key, chp.get()));
924  hdata.m_hitCollection->push_back(std::move(chp));
925  }
926  else
927  {
928  ld.hitsVec0 = ch->hitsVec0();
929  ld.hitsVec1 = ch->hitsVec1();
930  ld.errVec0 = ch->errorVec0();
931  ld.errVec1 = ch->errorVec1();
932  const int nsl = ld.hitsVec0.size();
933  if (timeslices != nsl)
934  {
935  if (debug) msg() << "Inconsistent number of slices in sub-blocks"
936  << endmsg;
937  ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
938  return;
939  }
940  if (ld.hitsVec0[slice] != 0 || ld.hitsVec1[slice] != 0 ||
941  ld.errVec0[slice] != 0 || ld.errVec1[slice] != 0)
942  {
943  if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
944  ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
945  return;
946  }
947  ld.hitsVec0[slice] = hits0;
948  ld.hitsVec1[slice] = hits1;
949  ld.errVec0[slice] = err0;
950  ld.errVec1[slice] = err1;
951  ch->addHits(ld.hitsVec0, ld.hitsVec1, ld.errVec0, ld.errVec1);
952  }
953  }
954  }
955  }
956  }
957 
958  return;
959 }
960 
961 // Unpack CPM sub-block
962 
963 void CpByteStreamV2Tool::decodeCpm(CpmSubBlockV2 *subBlock, int trigCpm,
964  CpmTowerData& data,
965  LocalData& ld) const
966 {
967  const bool debug = msgLvl(MSG::DEBUG);
968  const bool verbose = msgLvl(MSG::VERBOSE);
969  if (debug) msg(MSG::DEBUG);
970 
971  const int hwCrate = subBlock->crate();
972  const int module = subBlock->module();
973  const int timeslices = subBlock->timeslices();
974  const int sliceNum = subBlock->slice();
975  if (debug)
976  {
977  msg() << "CPM: Crate " << hwCrate
978  << " Module " << module
979  << " Total slices " << timeslices
980  << " Slice " << sliceNum << endmsg;
981  }
982  if (module < 1 || module > m_modules)
983  {
984  if (debug) msg() << "Unexpected module number: " << module << endmsg;
985  ld.rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
986  return;
987  }
988  if (timeslices <= trigCpm)
989  {
990  if (debug) msg() << "Triggered slice from header "
991  << "inconsistent with number of slices: "
992  << trigCpm << ", " << timeslices << endmsg;
993  ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
994  return;
995  }
996  if (timeslices <= sliceNum)
997  {
998  if (debug) msg() << "Total slices inconsistent with slice number: "
999  << timeslices << ", " << sliceNum << endmsg;
1000  ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
1001  return;
1002  }
1003  // Unpack sub-block
1004  if (subBlock->dataWords() && !subBlock->unpack())
1005  {
1006  if (debug)
1007  {
1008  std::string errMsg(subBlock->unpackErrorMsg());
1009  msg() << "CPM sub-block unpacking failed: " << errMsg << endmsg;
1010  }
1011  ld.rodErr = subBlock->unpackErrorCode();
1012  return;
1013  }
1014 
1015  // Retrieve required data
1016  const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
1017  LVL1::DataError dErr;
1018  dErr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
1019  const int subStatus = dErr.error();
1020  const int crate = hwCrate - m_crateOffsetHw;
1021  const int sliceBeg = ( neutralFormat ) ? 0 : sliceNum;
1022  const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
1023  for (int slice = sliceBeg; slice < sliceEnd; ++slice)
1024  {
1025 
1026  // Loop over tower channels and fill CPM towers
1027 
1028  for (int chan = 0; chan < m_channels; ++chan)
1029  {
1030  if (!subStatus && !subBlock->anyTowerData(chan)) continue;
1031  const int em = subBlock->emData(slice, chan);
1032  const int had = subBlock->hadData(slice, chan);
1033  const int emErr = subBlock->emError(slice, chan);
1034  const int hadErr = subBlock->hadError(slice, chan);
1035  int emErr1 = subStatus;
1036  if (emErr)
1037  {
1038  LVL1::DataError emErrBits(emErr1);
1039  emErrBits.set(LVL1::DataError::Parity, emErr & 0x1);
1040  emErrBits.set(LVL1::DataError::LinkDown, (emErr >> 1) & 0x1);
1041  emErr1 = emErrBits.error();
1042  }
1043  int hadErr1 = subStatus;
1044  if (hadErr)
1045  {
1046  LVL1::DataError hadErrBits(hadErr1);
1047  hadErrBits.set(LVL1::DataError::Parity, hadErr & 0x1);
1048  hadErrBits.set(LVL1::DataError::LinkDown, (hadErr >> 1) & 0x1);
1049  hadErr1 = hadErrBits.error();
1050  }
1051  if (em || had || emErr1 || hadErr1)
1052  {
1053  double eta = 0.;
1054  double phi = 0.;
1055  int layer = 0;
1056  if (m_cpmMaps->mapping(crate, module, chan, eta, phi, layer))
1057  {
1058  if (layer == ld.coreOverlap)
1059  {
1060  const unsigned int key = ld.towerKey.ttKey(phi, eta);
1061  LVL1::CPMTower *tt = findCpmTower(data, key);
1062  if ( ! tt ) // create new CPM tower
1063  {
1064  ld.emVec.assign(timeslices, 0);
1065  ld.hadVec.assign(timeslices, 0);
1066  ld.emErrVec.assign(timeslices, 0);
1067  ld.hadErrVec.assign(timeslices, 0);
1068  ld.emVec[slice] = em;
1069  ld.hadVec[slice] = had;
1070  ld.emErrVec[slice] = emErr1;
1071  ld.hadErrVec[slice] = hadErr1;
1072  auto ttp =
1073  std::make_unique<LVL1::CPMTower>(phi, eta, ld.emVec, ld.emErrVec,
1074  ld.hadVec, ld.hadErrVec, trigCpm);
1075  data.m_ttMap.insert(std::make_pair(key, ttp.get()));
1076  data.m_ttCollection->push_back(std::move(ttp));
1077  }
1078  else
1079  {
1080  ld.emVec = tt->emEnergyVec();
1081  ld.hadVec = tt->hadEnergyVec();
1082  ld.emErrVec = tt->emErrorVec();
1083  ld.hadErrVec = tt->hadErrorVec();
1084  const int nsl = ld.emVec.size();
1085  if (timeslices != nsl)
1086  {
1087  if (debug)
1088  {
1089  msg() << "Inconsistent number of slices in sub-blocks"
1090  << endmsg;
1091  }
1092  ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
1093  return;
1094  }
1095  if (ld.emVec[slice] != 0 || ld.hadVec[slice] != 0 ||
1096  ld.emErrVec[slice] != 0 || ld.hadErrVec[slice] != 0)
1097  {
1098  if (debug) msg() << "Duplicate data for slice "
1099  << slice << endmsg;
1100  ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
1101  return;
1102  }
1103  ld.emVec[slice] = em;
1104  ld.hadVec[slice] = had;
1105  ld.emErrVec[slice] = emErr1;
1106  ld.hadErrVec[slice] = hadErr1;
1107  tt->fill(ld.emVec, ld.emErrVec, ld.hadVec, ld.hadErrVec, trigCpm);
1108  }
1109  }
1110  }
1111  else if (verbose && (em || had || emErr || hadErr))
1112  {
1113  msg(MSG::VERBOSE) << "Non-zero data but no channel mapping for channel "
1114  << chan << endmsg;
1115  msg(MSG::DEBUG);
1116  }
1117  }
1118  else if (verbose)
1119  {
1120  msg(MSG::VERBOSE) << "No CPM tower data for channel "
1121  << chan << " slice " << slice << endmsg;
1122  msg(MSG::DEBUG);
1123  }
1124  }
1125  }
1126  return;
1127 }
1128 
1129 // Find a CPM tower for given key
1130 
1131 const
1132 LVL1::CPMTower *CpByteStreamV2Tool::findCpmTower(const unsigned int key,
1133  const ConstCpmTowerMap& ttMap) const
1134 {
1135  ConstCpmTowerMap::const_iterator mapIter = ttMap.find(key);
1136  if (mapIter != ttMap.end()) return mapIter->second;
1137  return nullptr;
1138 }
1139 
1140 LVL1::CPMTower *CpByteStreamV2Tool::findCpmTower(const CpmTowerData& data,
1141  const unsigned int key) const
1142 {
1143  CpmTowerMap::const_iterator mapIter = data.m_ttMap.find(key);
1144  if (mapIter != data.m_ttMap.end()) return mapIter->second;
1145  return nullptr;
1146 }
1147 
1148 // Find CMX-CP TOB for given key
1149 
1150 const
1151 LVL1::CMXCPTob *CpByteStreamV2Tool::findCmxCpTob(const int key,
1152  const ConstCmxCpTobMap& tobMap) const
1153 {
1154  ConstCmxCpTobMap::const_iterator mapIter = tobMap.find(key);
1155  if (mapIter != tobMap.end()) return mapIter->second;
1156  return nullptr;
1157 }
1158 
1159 LVL1::CMXCPTob *CpByteStreamV2Tool::findCmxCpTob(const CmxCpTobData& data,
1160  const int key) const
1161 {
1162  CmxCpTobMap::const_iterator mapIter = data.m_tobMap.find(key);
1163  if (mapIter != data.m_tobMap.end()) return mapIter->second;
1164  return nullptr;
1165 }
1166 
1167 // Find CMX-CP hits for given key
1168 
1169 const
1170 LVL1::CMXCPHits *CpByteStreamV2Tool::findCmxCpHits(const int key,
1171  const ConstCmxCpHitsMap& hitsMap) const
1172 {
1173  ConstCmxCpHitsMap::const_iterator mapIter = hitsMap.find(key);
1174  if (mapIter != hitsMap.end()) return mapIter->second;
1175  return nullptr;
1176 }
1177 
1178 LVL1::CMXCPHits *CpByteStreamV2Tool::findCmxCpHits(const CmxCpHitsData& data,
1179  const int key) const
1180 {
1181  CmxCpHitsMap::const_iterator mapIter = data.m_hitsMap.find(key);
1182  if (mapIter != data.m_hitsMap.end()) return mapIter->second;
1183  return nullptr;
1184 }
1185 
1186 // Set up CPM tower map
1187 
1188 void CpByteStreamV2Tool::setupCpmTowerMap(const CpmTowerCollection *
1189  const ttCollection,
1190  ConstCpmTowerMap& ttMap,
1191  LVL1::TriggerTowerKey& towerKey) const
1192 {
1193  ttMap.clear();
1194  if (ttCollection)
1195  {
1196  CpmTowerCollection::const_iterator pos = ttCollection->begin();
1197  CpmTowerCollection::const_iterator pose = ttCollection->end();
1198  for (; pos != pose; ++pos)
1199  {
1200  const LVL1::CPMTower *const tt = *pos;
1201  const unsigned int key = towerKey.ttKey(tt->phi(), tt->eta());
1202  ttMap.insert(std::make_pair(key, tt));
1203  }
1204  }
1205 }
1206 
1207 // Set up CMX-CP TOB map
1208 
1209 void CpByteStreamV2Tool::setupCmxCpTobMap(const CmxCpTobCollection *
1210  const tobCollection,
1211  ConstCmxCpTobMap& tobMap) const
1212 {
1213  tobMap.clear();
1214  if (tobCollection)
1215  {
1216  CmxCpTobCollection::const_iterator pos = tobCollection->begin();
1217  CmxCpTobCollection::const_iterator pose = tobCollection->end();
1218  for (; pos != pose; ++pos)
1219  {
1220  const LVL1::CMXCPTob *const tob = *pos;
1221  const int crate = tob->crate() - m_crateOffsetSw;
1222  const int cmx = tob->cmx();
1223  const int cpm = tob->cpm();
1224  const int chip = tob->chip();
1225  const int loc = tob->location();
1226  const int key = tobKey(crate, cmx, cpm, chip, loc);
1227  tobMap.insert(std::make_pair(key, tob));
1228  }
1229  }
1230 }
1231 
1232 // Set up CMX-CP hits map
1233 
1234 void CpByteStreamV2Tool::setupCmxCpHitsMap(const CmxCpHitsCollection *
1235  const hitCollection,
1236  ConstCmxCpHitsMap& hitsMap) const
1237 {
1238  hitsMap.clear();
1239  if (hitCollection)
1240  {
1241  CmxCpHitsCollection::const_iterator pos = hitCollection->begin();
1242  CmxCpHitsCollection::const_iterator pose = hitCollection->end();
1243  for (; pos != pose; ++pos)
1244  {
1245  const LVL1::CMXCPHits *const hits = *pos;
1246  const int crate = hits->crate() - m_crateOffsetSw;
1247  const int cmx = hits->cmx();
1248  const int source = hits->source();
1249  const int key = hitsKey(crate, cmx, source);
1250  hitsMap.insert(std::make_pair(key, hits));
1251  }
1252  }
1253 }
1254 
1255 // Key for TOBs
1256 
1257 int CpByteStreamV2Tool::tobKey(const int crate, const int cmx, const int cpm,
1258  const int chip, const int loc) const
1259 {
1260  return (((((((crate << 1) | cmx) << 4) | cpm) << 4) | chip) << 2) | loc;
1261 }
1262 
1263 // Key for Hits
1264 
1265 int CpByteStreamV2Tool::hitsKey(const int crate, const int cmx,
1266  const int source) const
1267 {
1268  return (((crate << 1) | cmx) << 3) | source;
1269 }
1270 
1271 // Get number of slices and triggered slice offset for next slink
1272 
1273 bool CpByteStreamV2Tool::slinkSlices(const int crate, const int module,
1274  const int modulesPerSlink, int &timeslices, int &trigCpm,
1275  const ConstCpmTowerMap& ttMap,
1276  const ConstCmxCpTobMap& tobMap,
1277  const ConstCmxCpHitsMap& hitsMap,
1278  LVL1::TriggerTowerKey& towerKey) const
1279 {
1280  int slices = -1;
1281  int trigC = m_dfltSlices / 2;
1282  for (int mod = module; mod < module + modulesPerSlink; ++mod)
1283  {
1284  for (int chan = 0; chan < m_channels; ++chan)
1285  {
1286  double eta = 0.;
1287  double phi = 0.;
1288  int layer = 0;
1289  if ( !m_cpmMaps->mapping(crate, mod, chan, eta, phi, layer)) continue;
1290  const unsigned int key = towerKey.ttKey(phi, eta);
1291  const LVL1::CPMTower *const tt = findCpmTower(key, ttMap);
1292  if ( !tt ) continue;
1293  const int numdat = 4;
1294  std::vector<int> sums(numdat);
1295  std::vector<int> sizes(numdat);
1296  sums[0] = std::accumulate((tt->emEnergyVec()).begin(),
1297  (tt->emEnergyVec()).end(), 0);
1298  sums[1] = std::accumulate((tt->hadEnergyVec()).begin(),
1299  (tt->hadEnergyVec()).end(), 0);
1300  sums[2] = std::accumulate((tt->emErrorVec()).begin(),
1301  (tt->emErrorVec()).end(), 0);
1302  sums[3] = std::accumulate((tt->hadErrorVec()).begin(),
1303  (tt->hadErrorVec()).end(), 0);
1304  sizes[0] = (tt->emEnergyVec()).size();
1305  sizes[1] = (tt->hadEnergyVec()).size();
1306  sizes[2] = (tt->emErrorVec()).size();
1307  sizes[3] = (tt->hadErrorVec()).size();
1308  const int peak = tt->peak();
1309  for (int i = 0; i < numdat; ++i)
1310  {
1311  if (sums[i] == 0) continue;
1312  if (slices < 0)
1313  {
1314  slices = sizes[i];
1315  trigC = peak;
1316  }
1317  else if (slices != sizes[i] || trigC != peak) return false;
1318  }
1319  }
1320  }
1321  // CMXs last slink of crate
1322  if (module / modulesPerSlink == m_slinks - 1)
1323  {
1324  for (int cmx = 0; cmx < m_cmxs; ++cmx)
1325  {
1326  for (int cpm = 1; cpm <= m_modules; ++ cpm)
1327  {
1328  for (int chip = 0; chip < m_chips; ++chip)
1329  {
1330  for (int loc = 0; loc < m_locs; ++loc)
1331  {
1332  const int key = tobKey(crate, cmx, cpm, chip, loc);
1333  const LVL1::CMXCPTob *const tob = findCmxCpTob(key,
1334  tobMap);
1335  if (tob)
1336  {
1337  const int numdat = 3;
1338  std::vector<int> sums(numdat);
1339  std::vector<int> sizes(numdat);
1340  sums[0] = std::accumulate((tob->energyVec()).begin(),
1341  (tob->energyVec()).end(), 0);
1342  sums[1] = std::accumulate((tob->isolationVec()).begin(),
1343  (tob->isolationVec()).end(), 0);
1344  sums[2] = std::accumulate((tob->errorVec()).begin(),
1345  (tob->errorVec()).end(), 0);
1346  sizes[0] = (tob->energyVec()).size();
1347  sizes[1] = (tob->isolationVec()).size();
1348  sizes[2] = (tob->errorVec()).size();
1349  const int peak = tob->peak();
1350  for (int i = 0; i < numdat; ++i)
1351  {
1352  if (sums[i] == 0) continue;
1353  if (slices < 0)
1354  {
1355  slices = sizes[i];
1356  trigC = peak;
1357  }
1358  else if (slices != sizes[i] || trigC != peak) return false;
1359  }
1360  }
1361  }
1362  }
1363  }
1364  for (int source = 0; source < LVL1::CMXCPHits::MAXSOURCE; ++source)
1365  {
1366  const int key = hitsKey(crate, cmx, source);
1367 
1368  const LVL1::CMXCPHits *const hits = findCmxCpHits(key,
1369  hitsMap);
1370  if (hits)
1371  {
1372  const int numdat = 4;
1373  std::vector<unsigned int> sums(numdat);
1374  std::vector<int> sizes(numdat);
1375  sums[0] = std::accumulate((hits->hitsVec0()).begin(),
1376  (hits->hitsVec0()).end(), 0);
1377  sums[1] = std::accumulate((hits->hitsVec1()).begin(),
1378  (hits->hitsVec1()).end(), 0);
1379  sums[2] = std::accumulate((hits->errorVec0()).begin(),
1380  (hits->errorVec0()).end(), 0);
1381  sums[3] = std::accumulate((hits->errorVec1()).begin(),
1382  (hits->errorVec1()).end(), 0);
1383  sizes[0] = (hits->hitsVec0()).size();
1384  sizes[1] = (hits->hitsVec1()).size();
1385  sizes[2] = (hits->errorVec0()).size();
1386  sizes[3] = (hits->errorVec1()).size();
1387  const int peak = hits->peak();
1388  for (int i = 0; i < numdat; ++i)
1389  {
1390  if (sums[i] == 0) continue;
1391  if (slices < 0)
1392  {
1393  slices = sizes[i];
1394  trigC = peak;
1395  }
1396  else if (slices != sizes[i] || trigC != peak) return false;
1397  }
1398  }
1399  }
1400  }
1401  }
1402  if (slices < 0) slices = m_dfltSlices;
1403  timeslices = slices;
1404  trigCpm = trigC;
1405  return true;
1406 }
1407 
1408 } // end namespace
eformat
Definition: L1CaloBsDecoderUtil.h:11
LVL1BS::CpmSubBlockV2::pack
bool pack()
Pack data.
Definition: CpmSubBlockV2.cxx:155
LVL1BS::CpByteStreamV2Tool::CmxCpHitsData::m_hitCollection
CmxCpHitsCollection *const m_hitCollection
Definition: CpByteStreamV2Tool.h:170
LVL1BS::CmxCpSubBlock::localCoord
int localCoord(int slice, int cpm, int tob) const
Return Local coordinate for given cpm and tob.
Definition: CmxCpSubBlock.cxx:107
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
LVL1BS::L1CaloSrcIdMap::minorVersionPreLS1
uint16_t minorVersionPreLS1() const
Return last ROD header minor version for pre-LS1 data.
Definition: L1CaloSrcIdMap.h:59
LVL1BS::CmxCpSubBlock::clear
void clear()
Clear all data.
Definition: CmxCpSubBlock.cxx:73
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
LVL1BS::L1CaloSrcIdMap::slink
int slink(uint32_t code) const
Return slink from unpacked moduleID.
Definition: L1CaloSrcIdMap.cxx:68
LVL1BS::CpByteStreamV2Tool::CmxCpTobData::m_tobMap
CmxCpTobMap m_tobMap
Definition: CpByteStreamV2Tool.h:164
LVL1::DataError::LinkDown
@ LinkDown
Definition: DataError.h:31
LVL1BS::L1CaloUserHeader
L1Calo User Header class.
Definition: L1CaloUserHeader.h:20
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
LVL1BS::L1CaloSubBlock::ERROR_MISSING_HEADER
@ ERROR_MISSING_HEADER
Definition: L1CaloSubBlock.h:33
LVL1::DataError
Error data.
Definition: DataError.h:27
LVL1::CMXCPTob::cmx
int cmx() const
returns CMX number (0/1)==(Left/Right)==(Tau/Em)
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:86
LVL1BS::CpByteStreamV2Tool::m_enableEncoding
Gaudi::Property< bool > m_enableEncoding
Definition: CpByteStreamV2Tool.h:93
LVL1BS::L1CaloSubBlock::unpackErrorCode
int unpackErrorCode() const
Return the unpacking error code.
Definition: L1CaloSubBlock.h:343
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LVL1BS::CpByteStreamV2Tool::decodeCpm
void decodeCpm(CpmSubBlockV2 *subBlock, int trigCpm, CpmTowerData &data, LocalData &ld) const
Unpack CPM sub-block.
Definition: CpByteStreamV2Tool.cxx:963
CmxCpSubBlock.h
FullEventAssembler
Template class for assembling a full atlas raw event from subfragments.
Definition: FullEventAssembler.h:40
LVL1BS::CmxCpSubBlock::REMOTE_2
@ REMOTE_2
Definition: CmxCpSubBlock.h:28
LVL1BS::CpByteStreamV2Tool::findCpmTower
const LVL1::CPMTower * findCpmTower(unsigned int key, const ConstCpmTowerMap &ttMap) const
Find a CPM tower for given key.
Definition: CpByteStreamV2Tool.cxx:1132
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
CxxUtils::ends_with
bool ends_with(const char *s, const char *suffix)
Test whether one null-terminated byte string ends with another.
LVL1BS::CpByteStreamV2Tool::m_crateOffsetHw
int m_crateOffsetHw
Property: Hardware crate number offset.
Definition: CpByteStreamV2Tool.h:231
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
LVL1::DataError::ParityPhase0
@ ParityPhase0
Definition: DataError.h:37
LVL1BS::ModifySlices::peak
static int peak(int oldPeak, int oldSlices, int newSlices)
Return new triggered slice offset.
Definition: ModifySlices.cxx:12
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LVL1BS::CmxCpSubBlock::isolation
int isolation(int slice, int cpm, int tob) const
Return isolation for given cpm and tob.
Definition: CmxCpSubBlock.cxx:119
LVL1::DataError::ModuleError
@ ModuleError
Definition: DataError.h:41
LVL1BS::CpByteStreamV2Tool::m_byteStreamCnvSvc
SmartIF< ByteStreamCnvSvc > m_byteStreamCnvSvc
Definition: CpByteStreamV2Tool.h:95
LVL1BS::L1CaloSubBlock::ERROR_DUPLICATE_ROB
@ ERROR_DUPLICATE_ROB
Definition: L1CaloSubBlock.h:31
LVL1BS::CpmSubBlockV2::hadData
int hadData(int slice, int channel) const
Return Had data for given channel.
Definition: CpmSubBlockV2.cxx:121
LVL1BS::CpByteStreamV2Tool::interfaceID
static const InterfaceID & interfaceID()
AlgTool InterfaceID.
Definition: CpByteStreamV2Tool.cxx:44
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
LVL1BS::CpByteStreamV2Tool::CPM_TOWERS
@ CPM_TOWERS
Definition: CpByteStreamV2Tool.h:131
L1CaloUserHeader.h
LVL1BS::L1CaloUserHeader::header
uint32_t header() const
Return packed header.
Definition: L1CaloUserHeader.h:89
TriggerTowerKey.h
LVL1BS::L1CaloUserHeader::cpm
int cpm() const
Definition: L1CaloUserHeader.h:116
LVL1::CMXCPTob::errorVec
const std::vector< int > & errorVec() const
returns error
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:136
LVL1BS::CpByteStreamV2Tool::CmxCpTobData::m_tobCollection
CmxCpTobCollection *const m_tobCollection
Definition: CpByteStreamV2Tool.h:163
LVL1BS::CpByteStreamV2Tool::findCmxCpTob
const LVL1::CMXCPTob * findCmxCpTob(int key, const ConstCmxCpTobMap &tobMap) const
Find CMX-CP TOB for given key.
Definition: CpByteStreamV2Tool.cxx:1151
LVL1BS::CpByteStreamV2Tool::m_errorTool
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool > m_errorTool
Error collection tool.
Definition: CpByteStreamV2Tool.h:228
LVL1BS::CmxCpSubBlock::presenceMap
unsigned int presenceMap(int slice, int cpm) const
Return presence map for given CPM.
Definition: CmxCpSubBlock.cxx:84
LVL1::CMXCPHits
Summary of CP (EM/tau) hits produced by the merger modules.
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPHits.h:24
LVL1BS::L1CaloSubBlock::write
void write(FullEventAssembler< L1CaloSrcIdMap >::RODDATA *theROD) const
Output complete packed sub-block to ROD vector.
Definition: L1CaloSubBlock.cxx:165
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
LVL1BS::L1CaloSrcIdMap::getRobID
uint32_t getRobID(uint32_t rod_id) const
Make a ROB Source ID from a ROD source ID.
Definition: L1CaloSrcIdMap.cxx:27
ModifySlices.h
LVL1::DataError::ParityPhase1
@ ParityPhase1
Definition: DataError.h:37
LVL1BS::CpByteStreamV2Tool::CMX_CP_HITS
@ CMX_CP_HITS
Definition: CpByteStreamV2Tool.h:131
LVL1BS::L1CaloSubBlock::read
OFFLINE_FRAGMENTS_NAMESPACE::PointerType read(const OFFLINE_FRAGMENTS_NAMESPACE::PointerType beg, const OFFLINE_FRAGMENTS_NAMESPACE::PointerType end)
Input complete packed sub-block from ROD array.
Definition: L1CaloSubBlock.cxx:118
LVL1BS::CpByteStreamV2Tool::ROBIterator
IROBDataProviderSvc::VROBFRAG::const_iterator ROBIterator
Definition: CpByteStreamV2Tool.h:142
LVL1BS::CpByteStreamV2Tool::CmxCpTobData
Definition: CpByteStreamV2Tool.h:160
LVL1BS::CmxCpSubBlock::setPresenceMap
void setPresenceMap(int slice, int cpm, unsigned int map)
Store presence map.
Definition: CmxCpSubBlock.cxx:191
LVL1BS::L1CaloSubBlock::NEUTRAL
@ NEUTRAL
Definition: L1CaloSubBlock.h:28
LVL1BS::CpByteStreamV2Tool::m_subDetector
const eformat::SubDetector m_subDetector
Sub-detector type.
Definition: CpByteStreamV2Tool.h:263
LVL1::DataError::GLinkParity
@ GLinkParity
Definition: DataError.h:40
LVL1::DataError::GLinkDown
@ GLinkDown
Definition: DataError.h:41
LVL1BS::CmxCpSubBlock::TOTAL
@ TOTAL
Definition: CmxCpSubBlock.h:28
LVL1BS::CpByteStreamV2Tool::makeSourceIDs
std::vector< uint32_t > makeSourceIDs() const
Create list of all source IDs.
Definition: CpByteStreamV2Tool.cxx:493
LVL1BS::CmxCpSubBlock::tobError
int tobError(int slice, int cpm, int tob) const
Return error bits for given cpm and tob.
Definition: CmxCpSubBlock.cxx:143
LVL1BS::CpmSubBlockV2
Sub-Block class for CPM data post LS1.
Definition: CpmSubBlockV2.h:23
LVL1BS::L1CaloSubBlock::slice
int slice() const
Definition: L1CaloSubBlock.h:258
LVL1BS::CmxCpSubBlock::hits
unsigned int hits(int slice, int source, int flag) const
Return hit/topo counts for given source ID and HL flag.
Definition: CmxCpSubBlock.cxx:155
LVL1BS::CpByteStreamV2Tool::m_robDataProvider
ServiceHandle< IROBDataProviderSvc > m_robDataProvider
Definition: CpByteStreamV2Tool.h:229
LVL1BS::CpByteStreamV2Tool::m_crateMin
int m_crateMin
Property: Minimum crate number when writing out bytestream.
Definition: CpByteStreamV2Tool.h:259
LVL1BS::CmxSubBlock::cmxBlock
static bool cmxBlock(uint32_t word)
Determine if header word corresponds to CMX.
Definition: CmxSubBlock.cxx:84
LVL1BS::L1CaloSubBlock::HEADER
@ HEADER
Definition: L1CaloSubBlock.h:27
LVL1BS::CmxSubBlock::cmxFirmware
int cmxFirmware() const
Definition: CmxSubBlock.h:68
CPBSCollectionV2.h
LVL1BS::CmxCpSubBlock::setHits
void setHits(int slice, int source, int flag, unsigned int hits, int error)
Store hit counts for given source ID and HL flag.
Definition: CmxCpSubBlock.cxx:239
LVL1BS::L1CaloSubBlock::crate
int crate() const
Definition: L1CaloSubBlock.h:263
LVL1::CMXCPTob::isolationVec
const std::vector< int > & isolationVec() const
returns isolation
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:131
LVL1BS::CmxSubBlock::timeslices
int timeslices() const
Definition: CmxSubBlock.cxx:48
LVL1::CPBSCollectionV2
Cluster Processor container for writing bytestream.
Definition: CPBSCollectionV2.h:24
LVL1::DataError::SubStatusWord
@ SubStatusWord
Definition: DataError.h:44
LVL1BS::CpByteStreamV2Tool::m_crates
int m_crates
Property: Number of crates.
Definition: CpByteStreamV2Tool.h:241
LVL1BS::CpByteStreamV2Tool::m_cmxs
const int m_cmxs
Number of CMXs per crate.
Definition: CpByteStreamV2Tool.h:245
LVL1BS::CpByteStreamV2Tool::m_srcIdMap
const L1CaloSrcIdMap m_srcIdMap
Source ID converter.
Definition: CpByteStreamV2Tool.h:265
LVL1BS::CmxCpSubBlock::setTob
void setTob(int slice, int cpm, int chip, int loc, int energy, int isol, int error)
Store TOB (RoI) data for given CPM, chip, local coord.
Definition: CmxCpSubBlock.cxx:203
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
python.PyAthena.module
module
Definition: PyAthena.py:134
Execution.tb
tb
Definition: Execution.py:15
LVL1::CPMTower
The CPMTower class contains the TriggerTower information received by the Cluster Processor Modules.
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CPMTower.h:36
LVL1BS::CpByteStreamV2Tool::m_forceSlices
int m_forceSlices
Property: Force number of slices in bytestream.
Definition: CpByteStreamV2Tool.h:257
LVL1BS::L1CaloSubBlock::ERROR_ROD_ID
@ ERROR_ROD_ID
Definition: L1CaloSubBlock.h:31
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:1273
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
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
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
LVL1BS::L1CaloSubBlock::ERROR_CRATE_NUMBER
@ ERROR_CRATE_NUMBER
Definition: L1CaloSubBlock.h:34
LVL1::DataError::Overflow
@ Overflow
Definition: DataError.h:31
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:88
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:526
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:193
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
LVL1BS::CpByteStreamV2Tool::CmxCpHitsData::m_hitsMap
CmxCpHitsMap m_hitsMap
Definition: CpByteStreamV2Tool.h:171
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
lumiFormat.i
int i
Definition: lumiFormat.py:92
LVL1BS::CpmSubBlockV2::timeslices
int timeslices() const
Return number of timeslices.
Definition: CpmSubBlockV2.cxx:142
LVL1::CMXCPTob::energyVec
const std::vector< int > & energyVec() const
For multi-slice readout.
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:126
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
LVL1::DataError::GLinkProtocol
@ GLinkProtocol
Definition: DataError.h:40
L1CaloSubBlock.h
LVL1BS::L1CaloSubBlock::ERROR_DUPLICATE_DATA
@ ERROR_DUPLICATE_DATA
Definition: L1CaloSubBlock.h:35
LVL1BS::CmxCpSubBlock::hitsError
int hitsError(int slice, int source, int flag) const
Return hit error for given source ID and HL flag.
Definition: CmxCpSubBlock.cxx:168
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LVL1::DataError::set
void set(ErrorBit bit, int value=1)
Set an error bit or data.
Definition: DataError.cxx:28
LArG4ShowerLibProcessing.hits
hits
Definition: LArG4ShowerLibProcessing.py:136
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LVL1BS::L1CaloSrcIdMap::crate
int crate(uint32_t code) const
Return crate from unpacked moduleID.
Definition: L1CaloSrcIdMap.cxx:52
LVL1BS::CpByteStreamV2Tool::LocalData
Definition: CpByteStreamV2Tool.h:98
LVL1BS::CpByteStreamV2Tool::initialize
virtual StatusCode initialize() override
Definition: CpByteStreamV2Tool.cxx:105
LVL1BS::CpByteStreamV2Tool::m_maxTobs
const int m_maxTobs
Maximum number of TOBS per module.
Definition: CpByteStreamV2Tool.h:247
LVL1BS::CpByteStreamV2Tool::convert
StatusCode convert(const std::string &sgKey, DataVector< LVL1::CPMTower > *ttCollection) const
Convert ROB fragments to CPM towers.
Definition: CpByteStreamV2Tool.cxx:121
LVL1BS::CpByteStreamV2Tool::m_chips
const int m_chips
Number of chips.
Definition: CpByteStreamV2Tool.h:249
LVL1BS::CpByteStreamV2Tool::setupCmxCpTobMap
void setupCmxCpTobMap(const CmxCpTobCollection *tobCollection, ConstCmxCpTobMap &tobMap) const
Set up CMX-CP TOB map.
Definition: CpByteStreamV2Tool.cxx:1209
LVL1BS::CpByteStreamV2Tool::~CpByteStreamV2Tool
virtual ~CpByteStreamV2Tool()
Definition: CpByteStreamV2Tool.cxx:98
CmxSubBlock.h
LVL1BS::L1CaloSubBlock::format
int format() const
Definition: L1CaloSubBlock.h:248
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1BS::CmxSubBlock::SYSTEM
@ SYSTEM
Definition: CmxSubBlock.h:27
LVL1BS::CpByteStreamV2Tool::setupCmxCpHitsMap
void setupCmxCpHitsMap(const CmxCpHitsCollection *hitCollection, ConstCmxCpHitsMap &hitsMap) const
Set up CMX-CP hits map.
Definition: CpByteStreamV2Tool.cxx:1234
LVL1BS::CpmSubBlockV2::unpack
bool unpack()
Unpack data.
Definition: CpmSubBlockV2.cxx:179
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
LVL1BS::L1CaloUserHeader::setVersion
void setVersion(int minorVersion)
Set version flag.
Definition: L1CaloUserHeader.h:176
LVL1BS::CmxCpSubBlock
Sub-Block class for CMX-CP data post LS1.
Definition: CmxCpSubBlock.h:23
LVL1BS::CpmSubBlockV2::fillTowerData
void fillTowerData(int slice, int channel, int em, int had, int emErr, int hadErr)
Store trigger tower data.
Definition: CpmSubBlockV2.cxx:70
IROBDataProviderSvc::VROBFRAG
std::vector< const ROBF * > VROBFRAG
Definition: IROBDataProviderSvc.h:29
LVL1BS::CmxCpSubBlock::REMOTE_0
@ REMOTE_0
Definition: CmxCpSubBlock.h:28
LVL1BS::CpByteStreamV2Tool::findCmxCpHits
const LVL1::CMXCPHits * findCmxCpHits(int key, const ConstCmxCpHitsMap &hitsMap) const
Find CMX-CP hits for given key.
Definition: CpByteStreamV2Tool.cxx:1170
LVL1BS::L1CaloSubBlock::ERROR_NONE
@ ERROR_NONE
Definition: L1CaloSubBlock.h:31
LVL1BS::CpmSubBlockV2::setCpmHeader
void setCpmHeader(int version, int format, int slice, int crate, int module, int timeslices)
Store CPM header.
Definition: CpmSubBlockV2.cxx:61
LVL1BS::CpByteStreamV2Tool::decodeCmxCp
void decodeCmxCp(CmxCpSubBlock *subBlock, int trigCpm, CpByteStreamToolData &data, LocalData &ld) const
Unpack CMX-CP sub-block.
Definition: CpByteStreamV2Tool.cxx:736
LVL1::DataError::Parity
@ Parity
Definition: DataError.h:31
LVL1BS::CpByteStreamV2Tool::ConstCmxCpTobMap
std::map< int, const LVL1::CMXCPTob * > ConstCmxCpTobMap
Definition: CpByteStreamV2Tool.h:139
DataVector< LVL1::CPMTower >
LVL1BS::CpmSubBlockV2::hadError
int hadError(int slice, int channel) const
Return Had error for given channel.
Definition: CpmSubBlockV2.cxx:135
LVL1BS::CmxCpSubBlock::setRoiOverflow
void setRoiOverflow(int slice, int source, int overflow)
Store RoI overflow for given source ID.
Definition: CmxCpSubBlock.cxx:257
LVL1BS::L1CaloSubBlock::wordType
static SubBlockWordType wordType(uint32_t word)
Word identification.
Definition: L1CaloSubBlock.cxx:479
LVL1BS::CmxCpSubBlock::roiOverflow
int roiOverflow(int slice, int source) const
Return RoI overflow for given source ID.
Definition: CmxCpSubBlock.cxx:181
FullEventAssembler.h
LVL1BS::CmxCpSubBlock::chip
int chip(int slice, int cpm, int tob) const
Return chip for given cpm and tob.
Definition: CmxCpSubBlock.cxx:95
starts_with.h
C++20-like starts_with/ends_with for strings.
calibdata.ct
ct
Definition: calibdata.py:418
DataError.h
LVL1BS::CpByteStreamV2Tool::m_channels
const int m_channels
Number of channels per module.
Definition: CpByteStreamV2Tool.h:239
LVL1::DataError::error
int error() const
Return the full error word.
Definition: DataError.h:78
LVL1BS::L1CaloSubBlock::unpackErrorMsg
std::string unpackErrorMsg() const
Return the unpacking error message for printing.
Definition: L1CaloSubBlock.cxx:228
LVL1::DataError::GLinkTimeout
@ GLinkTimeout
Definition: DataError.h:42
LVL1::CMXCPTob::chip
int chip() const
returns chip number (3 or 4 bits?)
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:96
LVL1::CMXCPTob::crate
int crate() const
Data accessors.
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:81
CpmSubBlockV2.h
LVL1::DataError::FailingBCN
@ FailingBCN
Definition: DataError.h:42
LVL1BS::CpByteStreamV2Tool::CpByteStreamToolData
Definition: CpByteStreamV2Tool.h:147
LVL1::DataError::ParityMerge
@ ParityMerge
Definition: DataError.h:37
LVL1BS::CpmSubBlockV2::emData
int emData(int slice, int channel) const
Return Em data for given channel.
Definition: CpmSubBlockV2.cxx:114
LVL1BS::L1CaloSrcIdMap::minorVersion
uint16_t minorVersion() const
Return ROD header minor version to use when writing BS.
Definition: L1CaloSrcIdMap.h:56
LVL1BS::CpByteStreamV2Tool::ConstCpmTowerMap
std::map< unsigned int, const LVL1::CPMTower * > ConstCpmTowerMap
Definition: CpByteStreamV2Tool.h:137
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
CPMTower.h
LVL1BS::CpByteStreamV2Tool::ConstCmxCpHitsMap
std::map< int, const LVL1::CMXCPHits * > ConstCmxCpHitsMap
Definition: CpByteStreamV2Tool.h:141
L1CaloErrorByteStreamTool.h
LVL1BS::L1CaloSubBlock::dataWords
int dataWords() const
Return number of data words.
Definition: L1CaloSubBlock.h:233
LVL1BS::L1CaloSubBlock::subStatus
uint32_t subStatus() const
Return Sub-status word.
Definition: L1CaloSubBlock.h:323
CMXCPTob.h
IL1CaloMappingTool.h
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
LVL1BS::CpmSubBlockV2::clear
void clear()
Clear all data.
Definition: CpmSubBlockV2.cxx:52
LVL1BS::L1CaloUserHeader::setCpm
void setCpm(int offset)
Definition: L1CaloUserHeader.h:154
LVL1BS::L1CaloUserHeader::words
int words() const
Return number of header words (should be one)
Definition: L1CaloUserHeader.h:94
LArNewCalib_PedestalAutoCorr.cp
cp
Definition: LArNewCalib_PedestalAutoCorr.py:175
LVL1BS::CpByteStreamV2Tool::RODPointer
OFFLINE_FRAGMENTS_NAMESPACE::PointerType RODPointer
Definition: CpByteStreamV2Tool.h:144
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
LVL1BS::CpByteStreamV2Tool::m_locs
const int m_locs
Number of Local coordinates.
Definition: CpByteStreamV2Tool.h:251
LVL1BS::CpByteStreamV2Tool::m_crateOffsetSw
int m_crateOffsetSw
Property: Software crate number offset.
Definition: CpByteStreamV2Tool.h:233
LVL1BS::CmxSubBlock::CMX_CP
@ CMX_CP
Definition: CmxSubBlock.h:25
LVL1BS::CpByteStreamV2Tool::CpByteStreamV2Tool
CpByteStreamV2Tool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: CpByteStreamV2Tool.cxx:51
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
LVL1BS::CmxCpSubBlock::REMOTE_1
@ REMOTE_1
Definition: CmxCpSubBlock.h:28
LVL1BS::CmxSubBlock::cmxType
static CmxFirmwareCode cmxType(uint32_t word)
CMX differentiation (CMX_CP, CMX_JET, or CMX_ENERGY)
Definition: CmxSubBlock.cxx:60
LVL1BS::L1CaloSubBlock::module
int module() const
Definition: L1CaloSubBlock.h:268
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
LVL1::CMXCPTob::peak
int peak() const
returns peak slice number
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:162
LVL1BS::L1CaloSrcIdMap::subDet
eformat::SubDetector subDet(uint32_t code) const
Return sub-detector for given ID.
Definition: L1CaloSrcIdMap.cxx:84
LVL1BS::CmxSubBlock::setCmxHeader
void setCmxHeader(int version, int format, int slice, int crate, int summing, int firmware, int position, int timeslices)
Store CMX header.
Definition: CmxSubBlock.cxx:33
LVL1BS::CpByteStreamV2Tool::m_slinks
int m_slinks
Property: Number of slinks per crate when writing out bytestream.
Definition: CpByteStreamV2Tool.h:253
DeMoScan.index
string index
Definition: DeMoScan.py:362
LVL1BS::CpByteStreamV2Tool::m_modules
const int m_modules
Number of CPM modules per crate.
Definition: CpByteStreamV2Tool.h:243
FullEventAssembler::setRodMinorVersion
void setRodMinorVersion(uint16_t m)
change the ROD minor version
LVL1BS::CpByteStreamV2Tool::m_dataFormat
int m_dataFormat
Property: Data compression format.
Definition: CpByteStreamV2Tool.h:237
LVL1::DataError::BCNMismatch
@ BCNMismatch
Definition: DataError.h:40
LVL1::DataError::FIFOOverflow
@ FIFOOverflow
Definition: DataError.h:41
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LVL1BS::L1CaloSubBlock::ERROR_SLICES
@ ERROR_SLICES
Definition: L1CaloSubBlock.h:35
python.TriggerHandler.verbose
verbose
Definition: TriggerHandler.py:297
LVL1::CMXCPTob::cpm
int cpm() const
returns CPM number
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:91
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LVL1BS
Definition: ZdcByteStreamReadV1V2Tool.h:47
LVL1BS::CpmSubBlockV2::anyTowerData
bool anyTowerData(int channel) const
Return true if there is tower data for given channel.
Definition: CpmSubBlockV2.h:120
LVL1BS::CmxSubBlock::cmxSumming
int cmxSumming() const
Definition: CmxSubBlock.h:63
CMXCPHits.h
LVL1BS::CpByteStreamV2Tool::m_crateMax
int m_crateMax
Property: Maximum crate number when writing out bytestream.
Definition: CpByteStreamV2Tool.h:261
LVL1BS::L1CaloSubBlock::ERROR_MODULE_NUMBER
@ ERROR_MODULE_NUMBER
Definition: L1CaloSubBlock.h:34
LVL1BS::CmxCpSubBlock::energy
int energy(int slice, int cpm, int tob) const
Return energy for given cpm and tob.
Definition: CmxCpSubBlock.cxx:131
LVL1BS::L1CaloSrcIdMap::getRodID
uint32_t getRodID(int crate, int slink, int daqOrRoi, eformat::SubDetector subdet) const
Make a ROD Source ID.
Definition: L1CaloSrcIdMap.cxx:16
LVL1BS::CpByteStreamV2Tool::m_cpmMaps
ToolHandle< LVL1::IL1CaloMappingTool > m_cpmMaps
Channel mapping tool.
Definition: CpByteStreamV2Tool.h:226
LVL1BS::CpByteStreamV2Tool::CMX_CP_TOBS
@ CMX_CP_TOBS
Definition: CpByteStreamV2Tool.h:131
LVL1BS::CpByteStreamV2Tool::m_dfltSlices
int m_dfltSlices
Property: Default number of slices in simulation.
Definition: CpByteStreamV2Tool.h:255
LVL1::CMXCPTob::location
int location() const
returns location (3 or 2 bits?)
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:101
L1CaloSrcIdMap.h
LVL1::DataError::ParityPhase3
@ ParityPhase3
Definition: DataError.h:38
LVL1BS::CmxSubBlock::cmxPosition
int cmxPosition() const
Definition: CmxSubBlock.h:73
LVL1BS::CpByteStreamV2Tool::CmxCpHitsData
Definition: CpByteStreamV2Tool.h:167
FullEventAssembler::RODDATA
std::vector< uint32_t > RODDATA
ROD data as a vector of unsigned int.
Definition: FullEventAssembler.h:54
LVL1BS::CpByteStreamV2Tool::CpmTowerData
Definition: CpByteStreamV2Tool.h:153
LVL1BS::CpByteStreamV2Tool::tobKey
int tobKey(int crate, int cmx, int cpm, int chip, int loc) const
Key for TOBs.
Definition: CpByteStreamV2Tool.cxx:1257
LVL1BS::CmxSubBlock::CRATE
@ CRATE
Definition: CmxSubBlock.h:27
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
AthAlgTool
Definition: AthAlgTool.h:26
LVL1::DataError::get
int get(ErrorBit bit) const
Return an error bit or data.
Definition: DataError.cxx:48
LVL1::TriggerTowerKey::ttKey
virtual unsigned int ttKey(const TriggerTower &tower)
returns the key of the passed tower
Definition: TriggerTowerKey.cxx:143
LVL1BS::L1CaloSrcIdMap::maxSlinks
int maxSlinks() const
Return the maximum possible number of slinks.
Definition: L1CaloSrcIdMap.cxx:77
LVL1::CMXCPTob
TOB data received by the merger modules.
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:24
get_generator_info.error
error
Definition: get_generator_info.py:40
LVL1BS::CpByteStreamV2Tool::hitsKey
int hitsKey(int crate, int cmx, int source) const
Key for Hits.
Definition: CpByteStreamV2Tool.cxx:1265
error
Definition: IImpactPoint3dEstimator.h:70
LVL1BS::L1CaloUserHeader::isValid
static bool isValid(uint32_t word)
Test for valid header word.
Definition: L1CaloUserHeader.cxx:36
LVL1BS::CpByteStreamV2Tool::sourceIDs
const std::vector< uint32_t > & sourceIDs() const
Return reference to vector with all possible Source Identifiers.
Definition: CpByteStreamV2Tool.cxx:518
TileDCSDataPlotter.tt
tt
Definition: TileDCSDataPlotter.py:874
LVL1BS::L1CaloSubBlock::setStatus
void setStatus(uint32_t failingBCN, bool glinkTimeout, bool glinkDown, bool upstreamError, bool daqOverflow, bool bcnMismatch, bool glinkProtocol, bool glinkParity)
Store error status trailer.
Definition: L1CaloSubBlock.cxx:179
LVL1BS::L1CaloSrcIdMap::daqOrRoi
int daqOrRoi(uint32_t code) const
Return daqOrRoi from unpacked moduleID.
Definition: L1CaloSrcIdMap.cxx:60
geometry_dat_to_json.ld
ld
Definition: geometry_dat_to_json.py:14
LVL1BS::CpByteStreamV2Tool::setupCpmTowerMap
void setupCpmTowerMap(const CpmTowerCollection *ttCollection, ConstCpmTowerMap &ttMap, LVL1::TriggerTowerKey &towerKey) const
Set up CPM tower map.
Definition: CpByteStreamV2Tool.cxx:1188
LVL1::DataError::ParityPhase2
@ ParityPhase2
Definition: DataError.h:38
LVL1::TriggerTowerKey
The TriggerTowerKey object provides the key for each trigger tower depending on its eta-phi coords.
Definition: TriggerTowerKey.h:56
LVL1BS::CpByteStreamV2Tool::m_sourceIDsProp
std::vector< uint32_t > m_sourceIDsProp
Property: ROB source IDs.
Definition: CpByteStreamV2Tool.h:267
LVL1BS::L1CaloSubBlock::ERROR_USER_HEADER
@ ERROR_USER_HEADER
Definition: L1CaloSubBlock.h:32
FullEventAssembler::getRodData
RODDATA * getRodData(uint32_t id)
get a block of ROD data
LVL1BS::CmxCpSubBlock::MAX_SOURCE_ID
@ MAX_SOURCE_ID
Definition: CmxCpSubBlock.h:30
LVL1BS::CpByteStreamV2Tool::ROBPointer
OFFLINE_FRAGMENTS_NAMESPACE::PointerType ROBPointer
Definition: CpByteStreamV2Tool.h:143
LVL1BS::CpByteStreamV2Tool::m_version
int m_version
Property: Sub_block header version.
Definition: CpByteStreamV2Tool.h:235
LVL1BS::CmxCpSubBlock::unpack
bool unpack()
Unpack data.
Definition: CmxCpSubBlock.cxx:292
keylayer_zslicemap.slices
slices
Definition: keylayer_zslicemap.py:112
CpByteStreamV2Tool.h
LVL1BS::CpmSubBlockV2::emError
int emError(int slice, int channel) const
Return Em error for given channel.
Definition: CpmSubBlockV2.cxx:128
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
LVL1::CMXCPHits::MAXSOURCE
@ MAXSOURCE
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPHits.h:29
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Sun Jun 30 2024 21:13:06 for ATLAS Offline Software by   doxygen 1.8.18