ATLAS Offline Software
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. More...
 
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. More...
 
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. More...
 
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. More...
 
const std::vector< uint32_t > & sourceIDs () const
 Return reference to vector with all possible Source Identifiers. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 AlgTool InterfaceID. More...
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

Private Types

enum  CollectionType { CPM_TOWERS, CMX_CP_TOBS, CMX_CP_HITS }
 
typedef DataVector< LVL1::CPMTowerCpmTowerCollection
 
typedef DataVector< LVL1::CMXCPTobCmxCpTobCollection
 
typedef DataVector< LVL1::CMXCPHitsCmxCpHitsCollection
 
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< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

std::vector< uint32_t > makeSourceIDs () const
 Create list of all source IDs. More...
 
StatusCode convertBs (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, CpByteStreamToolData &data) const
 Convert bytestream to given container type. More...
 
void decodeCmxCp (CmxCpSubBlock *subBlock, int trigCpm, CpByteStreamToolData &data, LocalData &ld) const
 Unpack CMX-CP sub-block. More...
 
void decodeCpm (CpmSubBlockV2 *subBlock, int trigCpm, CpmTowerData &data, LocalData &ld) const
 Unpack CPM sub-block. More...
 
const LVL1::CPMTowerfindCpmTower (unsigned int key, const ConstCpmTowerMap &ttMap) const
 Find a CPM tower for given key. More...
 
LVL1::CPMTowerfindCpmTower (const CpmTowerData &data, unsigned int key) const
 
const LVL1::CMXCPTobfindCmxCpTob (int key, const ConstCmxCpTobMap &tobMap) const
 Find CMX-CP TOB for given key. More...
 
LVL1::CMXCPTobfindCmxCpTob (const CmxCpTobData &data, int key) const
 
const LVL1::CMXCPHitsfindCmxCpHits (int key, const ConstCmxCpHitsMap &hitsMap) const
 Find CMX-CP hits for given key. More...
 
LVL1::CMXCPHitsfindCmxCpHits (const CmxCpHitsData &data, int key) const
 
void setupCpmTowerMap (const CpmTowerCollection *ttCollection, ConstCpmTowerMap &ttMap, LVL1::TriggerTowerKey &towerKey) const
 Set up CPM tower map. More...
 
void setupCmxCpTobMap (const CmxCpTobCollection *tobCollection, ConstCmxCpTobMap &tobMap) const
 Set up CMX-CP TOB map. More...
 
void setupCmxCpHitsMap (const CmxCpHitsCollection *hitCollection, ConstCmxCpHitsMap &hitsMap) const
 Set up CMX-CP hits map. More...
 
int tobKey (int crate, int cmx, int cpm, int chip, int loc) const
 Key for TOBs. More...
 
int hitsKey (int crate, int cmx, int source) const
 Key for Hits. More...
 
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. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

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

Definition at line 135 of file CpByteStreamV2Tool.h.

◆ CmxCpHitsMap

Definition at line 140 of file CpByteStreamV2Tool.h.

◆ CmxCpTobCollection

Definition at line 134 of file CpByteStreamV2Tool.h.

◆ CmxCpTobMap

Definition at line 138 of file CpByteStreamV2Tool.h.

◆ ConstCmxCpHitsMap

Definition at line 141 of file CpByteStreamV2Tool.h.

◆ ConstCmxCpTobMap

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

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

Definition at line 143 of file CpByteStreamV2Tool.h.

◆ RODPointer

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

Enumerator
CPM_TOWERS 
CMX_CP_TOBS 
CMX_CP_HITS 

Definition at line 131 of file CpByteStreamV2Tool.h.

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.

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 }

◆ ~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 
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 
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
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 }

◆ 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 }

◆ 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
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 }

◆ 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
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
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  {
570  if (debug) msg() << "Skipping duplicate ROB fragment" << endmsg;
571  continue;
572  }
573 
574  // Unpack ROD data (slinks)
575 
576  RODPointer payloadBeg;
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
624  {
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  {
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 
652  while (payload != payloadEnd)
653  {
655  {
656  if (debug) msg() << "Unexpected data sequence" << endmsg;
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 
669  {
670  // CMX
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;
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;
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;
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 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ 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;
762  return;
763  }
764  if (timeslices <= sliceNum)
765  {
766  if (debug) msg() << "Total slices inconsistent with slice number: "
767  << timeslices << ", " << sliceNum << endmsg;
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;
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;
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 &&
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;
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;
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 }

◆ 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;
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;
991  return;
992  }
993  if (timeslices <= sliceNum)
994  {
995  if (debug) msg() << "Total slices inconsistent with slice number: "
996  << timeslices << ", " << sliceNum << endmsg;
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);
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  }
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;
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 }

◆ 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() [1/2]

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; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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 }

◆ 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 }

◆ 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()) {
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() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ 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  }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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  }

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.

◆ 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:
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:64
test_pyathena.eta
eta
Definition: test_pyathena.py:10
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:73
LVL1::DataError::LinkDown
@ LinkDown
Definition: DataError.h:31
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
LVL1BS::L1CaloSubBlock::ERROR_MISSING_HEADER
@ ERROR_MISSING_HEADER
Definition: L1CaloSubBlock.h:33
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
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
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:960
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:1129
DataVector< LVL1::CMXCPHits >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition: DataVector.h:837
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
LVL1BS::CpByteStreamV2Tool::m_crateOffsetHw
int m_crateOffsetHw
Property: Hardware crate number offset.
Definition: CpByteStreamV2Tool.h:231
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
LVL1::DataError::ModuleError
@ ModuleError
Definition: DataError.h:41
LVL1BS::L1CaloSubBlock::ERROR_DUPLICATE_ROB
@ ERROR_DUPLICATE_ROB
Definition: L1CaloSubBlock.h:31
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
LVL1::CMXCPTob::errorVec
const std::vector< int > & errorVec() const
returns error
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:136
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_errorTool
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool > m_errorTool
Error collection tool.
Definition: CpByteStreamV2Tool.h:228
LVL1::CMXCPHits
Summary of CP (EM/tau) hits produced by the merger modules.
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPHits.h:24
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
DataVector::get
const T * get(size_type n) const
Access an element, as an rvalue.
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:32
LVL1::DataError::ParityPhase1
@ ParityPhase1
Definition: DataError.h:37
LVL1BS::CpByteStreamV2Tool::CMX_CP_HITS
@ CMX_CP_HITS
Definition: CpByteStreamV2Tool.h:131
LVL1BS::CpByteStreamV2Tool::ROBIterator
IROBDataProviderSvc::VROBFRAG::const_iterator ROBIterator
Definition: CpByteStreamV2Tool.h:142
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
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
LVL1BS::CpByteStreamV2Tool::makeSourceIDs
std::vector< uint32_t > makeSourceIDs() const
Create list of all source IDs.
Definition: CpByteStreamV2Tool.cxx:491
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
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LVL1::CMXCPTob::isolationVec
const std::vector< int > & isolationVec() const
returns isolation
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPTob.h:131
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
LVL1BS::CpByteStreamV2Tool::m_srcIdMap
const L1CaloSrcIdMap m_srcIdMap
Source ID converter.
Definition: CpByteStreamV2Tool.h:265
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
python.PyAthena.module
module
Definition: PyAthena.py:131
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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
AthCommonDataStore
Definition: AthCommonDataStore.h:52
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
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:93
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
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
LVL1BS::L1CaloSubBlock::ERROR_DUPLICATE_DATA
@ ERROR_DUPLICATE_DATA
Definition: L1CaloSubBlock.h:35
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
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
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:57
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:119
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:1206
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:1231
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
IROBDataProviderSvc::VROBFRAG
std::vector< const ROBF * > VROBFRAG
Definition: IROBDataProviderSvc.h:27
LVL1BS::CmxCpSubBlock::REMOTE_0
@ REMOTE_0
Definition: CmxCpSubBlock.h:28
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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::L1CaloSubBlock::ERROR_NONE
@ ERROR_NONE
Definition: L1CaloSubBlock.h:31
LVL1BS::CpByteStreamV2Tool::decodeCmxCp
void decodeCmxCp(CmxCpSubBlock *subBlock, int trigCpm, CpByteStreamToolData &data, LocalData &ld) const
Unpack CMX-CP sub-block.
Definition: CpByteStreamV2Tool.cxx:733
LVL1::DataError::Parity
@ Parity
Definition: DataError.h:31
LVL1BS::CpByteStreamV2Tool::ConstCmxCpTobMap
std::map< int, const LVL1::CMXCPTob * > ConstCmxCpTobMap
Definition: CpByteStreamV2Tool.h:139
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
LVL1BS::L1CaloSubBlock::wordType
static SubBlockWordType wordType(uint32_t word)
Word identification.
Definition: L1CaloSubBlock.cxx:479
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
calibdata.ct
ct
Definition: calibdata.py:418
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
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
LVL1::DataError::GLinkTimeout
@ GLinkTimeout
Definition: DataError.h:42
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
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
LVL1::DataError::FailingBCN
@ FailingBCN
Definition: DataError.h:42
LVL1::DataError::ParityMerge
@ ParityMerge
Definition: DataError.h:37
LVL1BS::L1CaloSrcIdMap::minorVersion
uint16_t minorVersion() const
Return ROD header minor version to use when writing BS.
Definition: L1CaloSrcIdMap.h:61
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
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:228
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
LVL1BS::CpByteStreamV2Tool::ConstCmxCpHitsMap
std::map< int, const LVL1::CMXCPHits * > ConstCmxCpHitsMap
Definition: CpByteStreamV2Tool.h:141
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
LArNewCalib_PedestalAutoCorr.cp
cp
Definition: LArNewCalib_PedestalAutoCorr.py:188
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
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
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:89
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:364
LVL1BS::CpByteStreamV2Tool::m_modules
const int m_modules
Number of CPM modules per crate.
Definition: CpByteStreamV2Tool.h:243
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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::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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
LVL1BS::L1CaloSrcIdMap::getRodID
uint32_t getRodID(int crate, int slink, int daqOrRoi, eformat::SubDetector subdet) const
Make a ROD Source ID.
Definition: L1CaloSrcIdMap.cxx:18
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
LVL1::DataError::ParityPhase3
@ ParityPhase3
Definition: DataError.h:38
copySelective.source
string source
Definition: copySelective.py:32
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
FullEventAssembler::RODDATA
std::vector< uint32_t > RODDATA
ROD data as a vector of unsigned int.
Definition: FullEventAssembler.h:54
LVL1BS::CpByteStreamV2Tool::tobKey
int tobKey(int crate, int cmx, int cpm, int chip, int loc) const
Key for TOBs.
Definition: CpByteStreamV2Tool.cxx:1254
LVL1BS::CmxSubBlock::CRATE
@ CRATE
Definition: CmxSubBlock.h:27
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
LVL1BS::CpByteStreamV2Tool::m_byteStreamCnvSvc
SmartIF< IByteStreamCnvSvc > m_byteStreamCnvSvc
Definition: CpByteStreamV2Tool.h:95
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:82
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:1262
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:516
TileDCSDataPlotter.tt
tt
Definition: TileDCSDataPlotter.py:874
LVL1BS::L1CaloSrcIdMap::daqOrRoi
int daqOrRoi(uint32_t code) const
Return daqOrRoi from unpacked moduleID.
Definition: L1CaloSrcIdMap.cxx:65
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
geometry_dat_to_json.ld
ld
Definition: geometry_dat_to_json.py:32
LVL1BS::CpByteStreamV2Tool::setupCpmTowerMap
void setupCpmTowerMap(const CpmTowerCollection *ttCollection, ConstCpmTowerMap &ttMap, LVL1::TriggerTowerKey &towerKey) const
Set up CPM tower map.
Definition: CpByteStreamV2Tool.cxx:1185
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
keylayer_zslicemap.slices
slices
Definition: keylayer_zslicemap.py:112
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
LVL1::CMXCPHits::MAXSOURCE
@ MAXSOURCE
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXCPHits.h:29
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37