ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
LVL1BS::PpmByteStreamReadV1V2Tool Class Reference

Tool to perform ROB fragments to trigger towers and trigger towers to raw data conversions. More...

#include <PpmByteStreamReadV1V2Tool.h>

Inheritance diagram for LVL1BS::PpmByteStreamReadV1V2Tool:
Collaboration diagram for LVL1BS::PpmByteStreamReadV1V2Tool:

Classes

class  BitReader
 
struct  State
 

Public Member Functions

 PpmByteStreamReadV1V2Tool (const std::string &name)
 
virtual ~PpmByteStreamReadV1V2Tool ()
 
virtual StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
virtual StatusCode finalize () override
 
StatusCode convert (xAOD::TriggerTowerContainer *const ttCollection) const
 Convert ROB fragments to trigger towers. More...
 
StatusCode convert (const std::string &sgKey, xAOD::TriggerTowerContainer *const ttCollection) const
 
virtual void print () const
 Print the state of the tool. 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, V, H > &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
 

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  RequestType { RequestType::PPM, RequestType::CPM, RequestType::CMX }
 
typedef IROBDataProviderSvc::VROBFRAG::const_iterator ROBIterator
 
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType ROBPointer
 
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType RODPointer
 
typedef std::map< uint8_t, std::vector< uint16_t > > LutsMap
 
typedef std::map< uint8_t, std::vector< uint16_t > > FadcsMap
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode convert (State &state, const IROBDataProviderSvc::VROBFRAG &robFrags) const
 
void initSourceIDs ()
 
const std::vector< uint32_t > & ppmSourceIDs (State &state, const std::string &sgKey) const
 Return reference to vector with all possible Source Identifiers. More...
 
StatusCode processRobFragment_ (State &state, const ROBIterator &robFrag, const RequestType &requestedType) const
 
StatusCode processPpmWord_ (State &state, uint32_t word, int indata) const
 
StatusCode processPpmBlock_ (State &state) const
 
StatusCode processPpmBlockR4V1_ (State &state) const
 
StatusCode processPpmBlockR3V1_ (State &state) const
 
StatusCode processPpmStandardR4V1_ (State &state) const
 
StatusCode processPpmStandardR3V1_ (State &state) const
 
StatusCode processPpmStandardR3V1_ (State &state, uint32_t word, int indata) const
 
StatusCode processPpmCompressedR3V1_ (State &state) const
 
std::vector< uint16_t > getPpmAdcSamplesR3_ (State &state, BitReader &br, uint8_t format, uint8_t minIndex) const
 
StatusCode processPpmCompressedR4V1_ (State &state) const
 
void interpretPpmHeaderR4V1_ (BitReader &br, uint8_t numAdc, int8_t &encoding, int8_t &minIndex) const
 
std::vector< uint16_t > getPpmAdcSamplesR4_ (State &state, BitReader &br, uint8_t encoding, uint8_t minIndex) const
 
StatusCode processPpmNeutral_ (State &state) const
 
StatusCode addTriggerTowerV2_ (State &state, uint8_t crate, uint8_t module, uint8_t channel, std::vector< uint8_t > &&lcpVal, std::vector< uint8_t > &&lcpBcidVec, std::vector< uint8_t > &&ljeVal, std::vector< uint8_t > &&ljeSat80Vec, std::vector< uint16_t > &&adcVal, std::vector< uint8_t > &&adcExt, std::vector< int16_t > &&pedCor, std::vector< uint8_t > &&pedEn) const
 
StatusCode addTriggerTowerV1_ (State &state, uint8_t crate, uint8_t module, uint8_t channel, const std::vector< uint16_t > &luts, const std::vector< uint16_t > &fadc) const
 
StatusCode addTriggerTowerV1_ (State &state, uint8_t crate, uint8_t module, uint8_t channel, std::vector< uint8_t > &&luts, std::vector< uint8_t > &&lcpBcidVec, std::vector< uint16_t > &&fadc, std::vector< uint8_t > &&bcidExt) const
 
void processSubBlockStatus_ (State &state, uint8_t crate, uint8_t module, uint32_t word) const
 
void processPpmErrorBits_ (State &state, uint8_t crate, uint8_t module, BitReader &br) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ToolHandle< LVL1BS::L1CaloErrorByteStreamTool > m_errorTool
 
ToolHandle< LVL1::IL1CaloMappingTool > m_ppmMaps
 Channel mapping tool. More...
 
ServiceHandle< IROBDataProviderSvc > m_robDataProvider
 Service for reading bytestream. More...
 
std::vector< uint32_t > m_ppmSourceIDs
 
std::vector< uint32_t > m_ppmSourceIDsMuon
 
std::vector< uint32_t > m_ppmSourceIDsSpare
 
L1CaloSrcIdMap * m_srcIdMap
 
std::atomic< size_t > m_maxSizeSeen
 
bool m_useSWROD = false
 
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
 

Static Private Attributes

static const uint8_t s_crates = 8
 
static const uint8_t s_modules = 16
 
static const uint8_t s_submodules = 16
 
static const uint8_t s_channels = 64
 
static const uint16_t s_maxtowers = s_crates * s_modules * s_channels
 

Detailed Description

Tool to perform ROB fragments to trigger towers and trigger towers to raw data conversions.

Author
alexa.nosp@m.nder.nosp@m..mazu.nosp@m.rov@.nosp@m.cern..nosp@m.ch

Definition at line 58 of file PpmByteStreamReadV1V2Tool.h.

Member Typedef Documentation

◆ FadcsMap

typedef std::map<uint8_t, std::vector<uint16_t> > LVL1BS::PpmByteStreamReadV1V2Tool::FadcsMap
private

Definition at line 101 of file PpmByteStreamReadV1V2Tool.h.

◆ LutsMap

typedef std::map<uint8_t, std::vector<uint16_t> > LVL1BS::PpmByteStreamReadV1V2Tool::LutsMap
private

Definition at line 100 of file PpmByteStreamReadV1V2Tool.h.

◆ ROBIterator

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

Definition at line 77 of file PpmByteStreamReadV1V2Tool.h.

◆ ROBPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::PpmByteStreamReadV1V2Tool::ROBPointer
private

Definition at line 78 of file PpmByteStreamReadV1V2Tool.h.

◆ RODPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::PpmByteStreamReadV1V2Tool::RODPointer
private

Definition at line 79 of file PpmByteStreamReadV1V2Tool.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ RequestType

enum LVL1BS::PpmByteStreamReadV1V2Tool::RequestType
strongprivate
Enumerator
PPM 
CPM 
CMX 

Definition at line 76 of file PpmByteStreamReadV1V2Tool.h.

76 { PPM, CPM, CMX };

Constructor & Destructor Documentation

◆ PpmByteStreamReadV1V2Tool()

LVL1BS::PpmByteStreamReadV1V2Tool::PpmByteStreamReadV1V2Tool ( const std::string &  name)

Definition at line 63 of file PpmByteStreamReadV1V2Tool.cxx.

64  :
65  AsgTool(name),
66  m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
67  m_ppmMaps("LVL1::PpmMappingTool/PpmMappingTool"),
68  m_robDataProvider("ROBDataProviderSvc", name),
69  m_srcIdMap(nullptr),
70  m_maxSizeSeen(0)
71 {
72  declareInterface<PpmByteStreamReadV1V2Tool>(this);
73  declareProperty("UseSWROD",m_useSWROD = false, "Use SWROD readout instead of legacy (which was removed in 2024)");
74  declareProperty("PpmMappingTool", m_ppmMaps,
75  "Crate/Module/Channel to Eta/Phi/Layer mapping tool");
76  declareProperty("ROBDataProviderSvc", m_robDataProvider,
77  "Get ROB source IDs service");
78 }

◆ ~PpmByteStreamReadV1V2Tool()

virtual LVL1BS::PpmByteStreamReadV1V2Tool::~PpmByteStreamReadV1V2Tool ( )
inlinevirtual

Definition at line 64 of file PpmByteStreamReadV1V2Tool.h.

64 {};

Member Function Documentation

◆ addTriggerTowerV1_() [1/2]

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::addTriggerTowerV1_ ( State &  state,
uint8_t  crate,
uint8_t  module,
uint8_t  channel,
const std::vector< uint16_t > &  luts,
const std::vector< uint16_t > &  fadc 
) const
private

Definition at line 1070 of file PpmByteStreamReadV1V2Tool.cxx.

1078 {
1079  std::vector<uint8_t> lcpVal;
1080  std::vector<uint8_t> lcpBcidVec;
1081 
1082  std::vector<uint16_t> adcVal;
1083  std::vector<uint8_t> adcExt;
1084 
1085  for(auto lut: luts) {
1086  lcpVal.push_back(BitField::get<uint8_t>(lut, 0, 8));
1087  lcpBcidVec.push_back(BitField::get<uint8_t>(lut, 8, 3));
1088  }
1089 
1090  for(auto f: fadc) {
1091  adcExt.push_back(BitField::get<uint8_t>(f, 0, 1));
1092  adcVal.push_back(BitField::get<uint16_t>(f, 1, 10));
1093  }
1094 
1095  CHECK(addTriggerTowerV1_(state,
1096  crate, module, channel,
1097  std::move(lcpVal), std::move(lcpBcidVec),
1098  std::move(adcVal), std::move(adcExt)));
1099 
1100  return StatusCode::SUCCESS;
1101 }

◆ addTriggerTowerV1_() [2/2]

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::addTriggerTowerV1_ ( State &  state,
uint8_t  crate,
uint8_t  module,
uint8_t  channel,
std::vector< uint8_t > &&  luts,
std::vector< uint8_t > &&  lcpBcidVec,
std::vector< uint16_t > &&  fadc,
std::vector< uint8_t > &&  bcidExt 
) const
private

Definition at line 1042 of file PpmByteStreamReadV1V2Tool.cxx.

1052 {
1053  std::vector<uint8_t> ljeSat80Vec;
1054 
1055  std::vector<int16_t> pedCor;
1056  std::vector<uint8_t> pedEn;
1057  std::vector<uint8_t> luts_copy =luts;
1058 
1059  CHECK(addTriggerTowerV2_(state,
1060  crate, module, channel,
1061  std::move(luts), std::move(lcpBcidVec),
1062  std::move(luts_copy) , std::move(ljeSat80Vec),
1063  std::move(fadc), std::move(bcidExt),
1064  std::move(pedCor), std::move(pedEn))
1065  );
1066 
1067  return StatusCode::SUCCESS;
1068 }

◆ addTriggerTowerV2_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::addTriggerTowerV2_ ( State &  state,
uint8_t  crate,
uint8_t  module,
uint8_t  channel,
std::vector< uint8_t > &&  lcpVal,
std::vector< uint8_t > &&  lcpBcidVec,
std::vector< uint8_t > &&  ljeVal,
std::vector< uint8_t > &&  ljeSat80Vec,
std::vector< uint16_t > &&  adcVal,
std::vector< uint8_t > &&  adcExt,
std::vector< int16_t > &&  pedCor,
std::vector< uint8_t > &&  pedEn 
) const
private

Definition at line 996 of file PpmByteStreamReadV1V2Tool.cxx.

1009 {
1010  uint32_t coolId = ::coolId(crate, module, channel);
1011 
1012  int layer = 0;
1013  double eta = 0.;
1014  double phi = 0.;
1015 
1016  bool isData = m_ppmMaps->mapping(crate, module, channel, eta, phi, layer);
1017 
1018  if (!isData && !state.m_ppmIsRetSpare && !state.m_ppmIsRetMuon){
1019  return StatusCode::SUCCESS;
1020  }
1021 
1022  if (!isData) {
1023  const int pin = channel % 16;
1024  const int asic = channel / 16;
1025  eta = 16 * crate + module;
1026  phi = 4 * pin + asic;
1027  }
1028 
1029  xAOD::TriggerTower* tt = new xAOD::TriggerTower();
1030  state.m_triggerTowers->push_back(tt);
1031 
1032  tt->initialize(coolId, eta, phi,
1033  std::move(lcpVal), std::move(ljeVal),
1034  std::move(pedCor), std::move(pedEn),
1035  std::move(lcpBcidVec), std::move(adcVal),
1036  std::move(adcExt), std::move(ljeSat80Vec),
1037  0, state.m_caloUserHeader.lut(),
1038  state.m_caloUserHeader.ppFadc());
1039  return StatusCode::SUCCESS;
1040 }

◆ convert() [1/3]

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::convert ( const std::string &  sgKey,
xAOD::TriggerTowerContainer *const  ttCollection 
) const

Definition at line 140 of file PpmByteStreamReadV1V2Tool.cxx.

142 {
143  State state;
144  state.m_triggerTowers = ttCollection;
145  const std::vector<uint32_t>& vID(ppmSourceIDs(state, sgKey));
146  // // get ROB fragments
147  IROBDataProviderSvc::VROBFRAG robFrags;
148  m_robDataProvider->getROBData(Gaudi::Hive::currentContext(), vID, robFrags, "PpmByteStreamxAODReadTool");
149  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
150 
151  CHECK(convert(state, robFrags));
152  return StatusCode::SUCCESS;
153 }

◆ convert() [2/3]

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::convert ( State &  state,
const IROBDataProviderSvc::VROBFRAG &  robFrags 
) const
private

Definition at line 107 of file PpmByteStreamReadV1V2Tool.cxx.

110 {
111  if (m_maxSizeSeen > state.m_triggerTowers->capacity()){
112  state.m_triggerTowers->reserve (m_maxSizeSeen);
113  }
114 
115  state.m_subDetectorID = eformat::TDAQ_CALO_PREPROC;
116 
117  ROBIterator rob = robFrags.begin();
118  ROBIterator robEnd = robFrags.end();
119 
120  int robCounter = 1;
121  for (; rob != robEnd; ++rob, ++robCounter) {
122 
123  StatusCode sc = processRobFragment_(state, rob, RequestType::PPM);
124  if (!sc.isSuccess()) {
125 
126  }
127  }
128 
129  CxxUtils::atomic_fetch_max (&m_maxSizeSeen, state.m_triggerTowers->size());
130  return StatusCode::SUCCESS;
131 }

◆ convert() [3/3]

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::convert ( xAOD::TriggerTowerContainer *const  ttCollection) const

Convert ROB fragments to trigger towers.

Definition at line 134 of file PpmByteStreamReadV1V2Tool.cxx.

136 {
137  return convert(LVL1::TrigT1CaloDefs::xAODTriggerTowerLocation, ttCollection);
138 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ 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

◆ finalize()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::finalize ( )
overridevirtual

Definition at line 100 of file PpmByteStreamReadV1V2Tool.cxx.

100  {
101  delete m_srcIdMap;
102 
103  return StatusCode::SUCCESS;
104 }

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr) const
inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

119  {
120 
121 #ifdef XAOD_STANDALONE
122  // In case we use @c xAOD::TEvent, we have a direct function call
123  // for this.
124  return evtStore()->event()->getKey( ptr );
125 #else
126  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127  return ( proxy == nullptr ? 0 : proxy->sgkey() );
128 #endif // XAOD_STANDALONE
129  }

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

106  {
107 
108 #ifdef XAOD_STANDALONE
109  // In case we use @c xAOD::TEvent, we have a direct function call
110  // for this.
111  return evtStore()->event()->getName( ptr );
112 #else
113  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114  static const std::string dummy = "";
115  return ( proxy == nullptr ? dummy : proxy->name() );
116 #endif // XAOD_STANDALONE
117  }

◆ getPpmAdcSamplesR3_()

std::vector< uint16_t > LVL1BS::PpmByteStreamReadV1V2Tool::getPpmAdcSamplesR3_ ( State &  state,
BitReader &  br,
uint8_t  format,
uint8_t  minIndex 
) const
private

Definition at line 500 of file PpmByteStreamReadV1V2Tool.cxx.

503 {
504  std::vector<uint16_t> adc = {0, 0, 0, 0, 0};
505  uint8_t minAdc = 0;
506 
507  for(uint8_t i = 0; i <5; ++i) {
508  uint8_t longField = 0;
509  uint8_t numBits = 0;
510  if (format > 2) {
511  longField = br.getField(1);
512  numBits = longField == 0? 4: (format * 2);
513  } else {
514  numBits = i == 0? 4: (format + 2);
515  }
516 
517  if (i == 0) {
518  minAdc = br.getField(numBits);
519  if (longField == 0) {
520  minAdc += state.m_caloUserHeader.ppLowerBound();
521  }
522  } else {
523  adc[i] = minAdc + br.getField(numBits);
524  }
525  }
526 
527  if (minIndex == 0) {
528  adc[0] = minAdc;
529  } else {
530  adc[0] = adc[minIndex];
531  adc[minIndex] = minAdc;
532  }
533  return adc;
534 }

◆ getPpmAdcSamplesR4_()

std::vector< uint16_t > LVL1BS::PpmByteStreamReadV1V2Tool::getPpmAdcSamplesR4_ ( State &  state,
BitReader &  br,
uint8_t  encoding,
uint8_t  minIndex 
) const
private

Definition at line 790 of file PpmByteStreamReadV1V2Tool.cxx.

794 {
795  uint8_t numAdc = state.m_subBlockHeader.nSlice2();
796 
797  if (encoding == 6) {
798  uint16_t val = br.getField(6);
799  return std::vector<uint16_t>(numAdc, val);
800  } else if ( encoding < 3) {
801  std::vector<uint16_t> adc(numAdc, 0);
802  uint16_t minAdc = br.getField(5) + state.m_caloUserHeader.ppLowerBound();
803  adc[minIndex] = minAdc;
804  for(uint8_t i = 1; i < numAdc; ++i) {
805  adc[i == minIndex? 0: i] = br.getField(encoding + 2) + minAdc;
806  }
807  return adc;
808  } else {
809  std::vector<uint16_t> adc(numAdc, 0);
810  uint16_t minAdc = br.getField(1)
811  ? br.getField(encoding * 2)
812  : (br.getField(5) +
813  state.m_caloUserHeader.ppLowerBound());
814 
815  adc[minIndex] = minAdc;
816  for (uint8_t i = 1; i < numAdc; ++i) {
817  adc[minIndex == i? 0: i] = br.getField(
818  br.getField(1)? encoding * 2: 4
819  ) + minAdc;
820  }
821  return adc;
822  }
823 }

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ initialize()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::initialize ( )
overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 84 of file PpmByteStreamReadV1V2Tool.cxx.

84  {
85  ATH_MSG_DEBUG("Initializing " << name());
86 
87  m_srcIdMap = new L1CaloSrcIdMap();
88  m_srcIdMap->useSWROD(m_useSWROD);
89  CHECK(m_errorTool.retrieve());
90  CHECK(m_ppmMaps.retrieve());
91  CHECK(m_robDataProvider.retrieve());
92 
93  initSourceIDs();
94 
95  return StatusCode::SUCCESS;
96 }

◆ initSourceIDs()

void LVL1BS::PpmByteStreamReadV1V2Tool::initSourceIDs ( )
private

Definition at line 1106 of file PpmByteStreamReadV1V2Tool.cxx.

1107 {
1108  const int crates = 8;
1109 
1110  m_ppmSourceIDs.clear();
1111  m_ppmSourceIDsSpare.clear();
1112  m_ppmSourceIDsMuon.clear();
1113 
1114  for (int crate = 0; crate < crates; ++crate) {
1115  for (int slink = 0; slink < m_srcIdMap->maxSlinks(); ++slink) {
1116  const uint32_t rodId = m_srcIdMap->getRodID(crate, slink, 0,
1117  eformat::TDAQ_CALO_PREPROC);
1118  const uint32_t robId = m_srcIdMap->getRobID(rodId);
1119  m_ppmSourceIDs.push_back(robId);
1120  if (crate > 1 && crate < 6) {
1121  m_ppmSourceIDsSpare.push_back(robId);
1122  if (crate < 4 && slink == 0) {
1123  m_ppmSourceIDsMuon.push_back(robId);
1124  }
1125  }
1126  }
1127  }
1128 }

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

◆ interpretPpmHeaderR4V1_()

void LVL1BS::PpmByteStreamReadV1V2Tool::interpretPpmHeaderR4V1_ ( BitReader &  br,
uint8_t  numAdc,
int8_t &  encoding,
int8_t &  minIndex 
) const
private

Definition at line 739 of file PpmByteStreamReadV1V2Tool.cxx.

742 {
743  uint8_t minHeader = 0;
744 
745  if (numAdc == 5) {
746  minHeader = br.getField(4);
747 
748  minIndex = minHeader % 5;
749  if (minHeader < 15){ // Encodings 0-5
750  if (minHeader < 10) {
751  encoding = minHeader / 5;
752  } else {
753  encoding = 2 + br.getField(2);
754  }
755  } else {
756  encoding = 6;
757  }
758  } else {
759  uint8_t numBits = 0;
760  if (numAdc ==3 ) {
761  numBits = 2;
762  } else if (numAdc == 7) {
763  numBits = 3;
764  } else if (numAdc < 16) {
765  numBits = 4;
766  }
767 
768  if (numBits > 0) {
769  uint8_t fieldSize = 1 << numBits;
770  minHeader = br.getField(numBits);
771  uint8_t encValue = fieldSize - 1;
772  if (minHeader == encValue) { // Encoding 6
773  encoding = 6;
774  minIndex = 0;
775  } else {
776  minHeader += br.getField(2) << numBits;
777  minIndex = minHeader % fieldSize;
778  encValue = 3 * fieldSize;
779 
780  if (minHeader < encValue) { // Encodings 0-2
781  encoding = minHeader / fieldSize;
782  } else {
783  encoding = 3 + br.getField(2);
784  }
785  }
786  }
787  }
788 }

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

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const
inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns
The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

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

◆ ppmSourceIDs()

const std::vector< uint32_t > & LVL1BS::PpmByteStreamReadV1V2Tool::ppmSourceIDs ( State &  state,
const std::string &  sgKey 
) const
private

Return reference to vector with all possible Source Identifiers.

Definition at line 1132 of file PpmByteStreamReadV1V2Tool.cxx.

1135 {
1136  state.m_ppmIsRetMuon = false;
1137  state.m_ppmIsRetSpare = false;
1138 
1139  if (sgKey.find("Muon") != std::string::npos) {
1140  state.m_ppmIsRetMuon = true;
1141  } else if (sgKey.find("Spare") != std::string::npos) {
1142  state.m_ppmIsRetSpare = true;
1143  }
1144 
1145  if (state.m_ppmIsRetSpare) {
1146  return m_ppmSourceIDsSpare;
1147  }
1148 
1149  if (state.m_ppmIsRetMuon) {
1150  return m_ppmSourceIDsMuon;
1151  }
1152 
1153  return m_ppmSourceIDs;
1154 }

◆ print()

void asg::AsgTool::print ( ) const
virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ processPpmBlock_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmBlock_ ( State &  state) const
private

Definition at line 293 of file PpmByteStreamReadV1V2Tool.cxx.

294 {
295  if (state.m_ppBlock.size() > 0) {
296  if (state.m_subBlockHeader.format() == 0) {
297  StatusCode sc = processPpmNeutral_(state);
298  CHECK(sc);
299  return sc;
300  }
301 
302  if (state.m_verCode == 0x31) {
303  StatusCode sc = processPpmCompressedR3V1_(state);
304  CHECK(sc);
305  return sc;
306  }
307 
308  if (state.m_verCode == 0x41 || state.m_verCode == 0x42) {
309  StatusCode sc = processPpmBlockR4V1_(state);
310  CHECK(sc);
311  return sc;
312  }
313  }
314 
315  if (state.m_ppLuts.size() > 0) {
316  if (state.m_verCode == 0x21 || state.m_verCode == 0x31) {
317  StatusCode sc = processPpmBlockR3V1_(state);
318  CHECK(sc);
319  return sc;
320  }
321  ATH_MSG_ERROR("Unknown PPM subheader format '"
322  << int(state.m_subBlockHeader.format())
323  << "' for rob version '"
324  << MSG::hex << int(state.m_verCode)
325  << MSG::dec << "'" );
326  return StatusCode::FAILURE;
327  }
328  return StatusCode::SUCCESS;
329 }

◆ processPpmBlockR3V1_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmBlockR3V1_ ( State &  state) const
private

Definition at line 825 of file PpmByteStreamReadV1V2Tool.cxx.

826 {
827  if (state.m_subBlockHeader.format() == 1) {
828  CHECK(processPpmStandardR3V1_(state));
829  return StatusCode::SUCCESS;
830  } else if (state.m_subBlockHeader.format() >= 2) {
831  // TODO: convert compressed
832  return StatusCode::FAILURE;
833  }
834  return StatusCode::FAILURE;
835 }

◆ processPpmBlockR4V1_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmBlockR4V1_ ( State &  state) const
private

Definition at line 577 of file PpmByteStreamReadV1V2Tool.cxx.

578 {
579  if (state.m_subBlockHeader.format() == 1) {
580  CHECK(processPpmStandardR4V1_(state));
581  return StatusCode::SUCCESS;
582  } else if (state.m_subBlockHeader.format() >= 2) {
583  CHECK(processPpmCompressedR4V1_(state));
584  return StatusCode::SUCCESS;
585  }
586  return StatusCode::FAILURE;
587 }

◆ processPpmCompressedR3V1_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmCompressedR3V1_ ( State &  state) const
private

Definition at line 416 of file PpmByteStreamReadV1V2Tool.cxx.

417 {
418  BitReader br (state.m_ppBlock);
419  uint8_t chan = 0;
420  try{
421  while (chan < 64) {
422  uint8_t present = 1;
423  if (state.m_subBlockHeader.format() == 3) {
424  present = br.getField(1);
425  }
426 
427  if (present == 1) {
428  uint8_t lutVal = 0;
429  uint8_t fmt = 6;
430  uint8_t lutSat=0;
431  uint8_t lutExt=0;
432  uint8_t lutPeak=0;
433 
434  std::vector<uint16_t> adcVal = {0 , 0, 0, 0, 0};
435  std::vector<uint8_t> adcExt = {0 , 0, 0, 0, 0};
436 
437  uint8_t minHeader = br.getField(4);
438  uint8_t minIndex = minHeader % 5;
439  if (minHeader < 15) { // Formats 0-5
440  if (minHeader < 10) { // Formats 0-1
441  fmt = minHeader / 5;
442  } else { // Formats 2-5
443  fmt = 2 + br.getField( 2);
444  uint8_t haveLut = br.getField(1);
445  if (fmt == 2) {
446  if (haveLut == 1) {
447  lutVal = br.getField(3);
448  lutPeak = 1; // Even if LutVal==0 it seems
449  }
450  } else {
451  uint8_t haveExt = br.getField(1);
452  if (haveLut == 1) {
453  lutVal = br.getField(8);
454  lutExt = br.getField(1);
455  lutSat = br.getField(1);
456  lutPeak = br.getField(1);
457  }
458 
459  if (haveExt == 1){
460  for(uint8_t i = 0; i < 5; ++i) {
461  adcExt[i] = br.getField(1);
462  }
463  } else {
464  adcExt[2] = lutExt;
465  }
466  }
467  }
468  adcVal = getPpmAdcSamplesR3_(state, br, fmt, minIndex);
469  } else {
470  uint8_t haveAdc = br.getField(1);
471  if (haveAdc == 1) {
472  uint16_t val = br.getField(10);
473  for(uint8_t i = 0; i < 5; ++i) {
474  adcVal[i] = val;
475  }
476  }
477  }
478  // Add Trigger Tower
479  //std::vector<uint8_t> luts = {lutVal};
480  CHECK(addTriggerTowerV1_(
481  state,
482  state.m_subBlockHeader.crate(),
483  state.m_subBlockHeader.module(),
484  chan,
485  std::vector<uint8_t> {lutVal},
486  std::vector<uint8_t> {uint8_t(lutExt | (lutSat << 1) | (lutPeak << 2))},
487  std::move(adcVal),
488  std::move(adcExt)
489  ));
490  }
491  chan++;
492  }
493  }catch (const std::out_of_range& ex) {
494  ATH_MSG_WARNING("Excess Data in Sub-block");
495  m_errorTool->rodError(state.m_rodSourceId, L1CaloSubBlock::UNPACK_EXCESS_DATA);
496  }
497  return StatusCode::SUCCESS;
498 }

◆ processPpmCompressedR4V1_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmCompressedR4V1_ ( State &  state) const
private

Definition at line 589 of file PpmByteStreamReadV1V2Tool.cxx.

590 {
591  BitReader br (state.m_ppBlock);
592  uint8_t numAdc = state.m_subBlockHeader.nSlice2();
593  uint8_t numLut = state.m_subBlockHeader.nSlice1();
594  int16_t pedCorBase = -20;
595 
596 
597  try{
598  for(uint8_t chan = 0; chan < s_channels; ++chan) {
599  uint8_t present = 1;
600 
601  std::vector<uint8_t> haveLut(numLut, 0);
602  std::vector<uint8_t> lcpVal(numLut, 0);
603 
604  std::vector<uint8_t> lcpExt(numLut, 0);
605  std::vector<uint8_t> lcpSat(numLut, 0);
606  std::vector<uint8_t> lcpPeak(numLut, 0);
607  std::vector<uint8_t> lcpBcidVec(numLut, 0);
608 
609  std::vector<uint8_t> ljeVal(numLut, 0);
610 
611  std::vector<uint8_t> ljeLow(numLut, 0);
612  std::vector<uint8_t> ljeHigh(numLut, 0);
613  std::vector<uint8_t> ljeRes(numLut, 0);
614  std::vector<uint8_t> ljeSat80Vec(numLut, 0);
615 
616  std::vector<uint16_t> adcVal(numAdc, 0);
617  std::vector<uint8_t> adcExt(numAdc, 0);
618  std::vector<int16_t> pedCor(numLut, 0);
619  std::vector<uint8_t> pedEn(numLut, 0);
620 
621  int8_t encoding = -1;
622  int8_t minIndex = -1;
623 
624  if (state.m_subBlockHeader.format() == 3) {
625  present = br.getField(1);
626  }
627  if (present == 1) {
628  interpretPpmHeaderR4V1_(br, numAdc, encoding, minIndex);
629  CHECK((encoding != -1) && (minIndex != -1));
630  // First get the LUT related quantities
631  if (encoding < 3) {
632  // Get the peak finder bits
633  for(uint i=0; i < numLut; ++i) {
634  lcpPeak[i] = br.getField(1);
635  }
636  // Get Sat80 low bits
637  if (encoding > 0) {
638  for (uint8_t i = 0; i < numLut; ++i) {
639  ljeLow[i] = br.getField(1);
640  }
641  }
642  // Get LutCP and LutJEP values (these are
643  // only present if the peak finder is set).
644  if (encoding == 2) {
645  for (uint8_t i = 0; i < numLut; ++i) {
646  if (lcpPeak[i] == 1) {
647  lcpVal[i] = br.getField(4);
648  }
649  }
650  for(uint8_t i = 0; i < numLut; ++i) {
651  if (lcpPeak[i] == 1){
652  ljeVal[i] = br.getField(3);
653  }
654  }
655  }
656  } else if (encoding < 6) {
657  // Get LUT presence flag for each LUT slice.
658  for(uint8_t i = 0; i < numLut; ++i){
659  haveLut[i] = br.getField(1);
660  }
661 
662  // Get external BCID bits (if block is present).
663  uint8_t haveExt = br.getField(1);
664 
665  if (haveExt == 1) {
666  for (uint8_t i = 0; i < numAdc; ++i) {
667  adcExt[i] = br.getField(1);
668  }
669  }
670 
671  for(uint8_t i = 0; i < numLut; ++i){
672  if (haveLut[i] == 1) {
673  lcpVal[i] = br.getField(8);
674  lcpExt[i] = br.getField(1);
675  lcpSat[i] = br.getField(1);
676  lcpPeak[i] = br.getField(1);
677  }
678  }
679  // Get JEP LUT values and corresponding bits.
680  for(uint8_t i = 0; i < numLut; ++i){
681  if (haveLut[i] == 1) {
682  ljeVal[i] = br.getField(8);
683  ljeLow[i] = br.getField(1);
684  ljeHigh[i] = br.getField(1);
685  ljeRes[i] = br.getField(1);
686  }
687  }
688 
689  }
690 
691  }
692  // Next get the ADC related quantities (all encodings).
693  adcVal = getPpmAdcSamplesR4_(state, br, encoding, minIndex);
694  // Finally get the pedestal correction.
695  if ((encoding < 3) || (encoding == 6)) {
696  for (uint8_t i = 0; i < numLut; ++i)
697  {
698  pedCor[i] = br.getField(6) + pedCorBase;
699  if (state.m_subBlockHeader.compVer() > 0) {
700  pedEn[i] = 1;
701  }
702  }
703  } else {
704  // At the moment there is an enabled bit for every LUT slice
705  // (even though its really a global flag).
706  // The correction values is a twos complement signed value.
707  for (uint8_t i = 0; i < numLut; ++i)
708  {
709  uint16_t val = br.getField(10);
710  pedCor[i] = ::pedCorrection(val);
711  pedEn[i] = br.getField(1);
712  }
713  }
714 
715  for(uint8_t i=0; i < numLut; ++i){
716  lcpBcidVec[i] = uint8_t((lcpPeak[i] << 2) | (lcpSat[i] << 1) | lcpExt[i]);
717  ljeSat80Vec[i] = uint8_t((ljeRes[i] << 2) | (ljeHigh[i] << 1) | ljeLow[i]);
718  }
719  CHECK(addTriggerTowerV2_(state,
720  state.m_subBlockHeader.crate(), state.m_subBlockHeader.module(),
721  chan,
722  std::move(lcpVal), std::move(lcpBcidVec),
723  std::move(ljeVal), std::move(ljeSat80Vec),
724  std::move(adcVal), std::move(adcExt),
725  std::move(pedCor), std::move(pedEn)));
726  } // End for loop: done with that channel, move on to the next one.
727  // Finally decode the error and status blocks (if any).
728  processPpmErrorBits_(state,
729  state.m_subBlockHeader.crate(), state.m_subBlockHeader.module(), br);
730  } catch (const std::out_of_range& ex) {
731  ATH_MSG_WARNING("Excess Data in Sub-block");
732  m_errorTool->rodError(state.m_rodSourceId, L1CaloSubBlock::UNPACK_EXCESS_DATA);
733  }
734  //Check status word
735  return StatusCode::SUCCESS;
736 
737 }

◆ processPpmErrorBits_()

void LVL1BS::PpmByteStreamReadV1V2Tool::processPpmErrorBits_ ( State &  state,
uint8_t  crate,
uint8_t  module,
BitReader &  br 
) const
private

Definition at line 931 of file PpmByteStreamReadV1V2Tool.cxx.

933 {
934  // These bits come at the end of a PPM block. This code assumes the main part of the block
935  // has already been decoded and the pointer is set to the start of the error bits.
936  uint8_t haveStatus = br.getField(1);
937  uint8_t haveErrors = br.getField(1);
938 
939  // If either or both of these bits is set, then follows a single 16 bit map to indicate the MCM
940  if (haveStatus || haveErrors) {
941  uint16_t mcmMap = br.getField(s_submodules);
942  std::vector<uint16_t> mcmErrors(s_submodules);
943  uint16_t errorWord = 0;
944 
945  // For each so indicated MCM, there is either the 5 bit status block, or the 6 bit error block, or both
946  for(int i=0; i < s_submodules; ++i){
947  errorWord = 0;
948  if ((mcmMap & (1 << i)) != 0) {
949  uint16_t blockStatus = 0;
950  uint16_t blockErrors = 0;
951 
952  if (haveStatus) {
953  blockStatus = br.getField(5);
954  errorWord |= blockStatus;
955  }
956  if (haveErrors) {
957  blockErrors = br.getField(6);
958  errorWord |= (blockErrors<<5);
959  }
960  }
961  mcmErrors.at(i)=errorWord;
962  }
963 
964  int curr = state.m_triggerTowers->size() - 1;
965  for(int i=0; i < s_channels; ++i){
966  if (curr < 0){
967  break;
968  }
969  auto tt = (*state.m_triggerTowers)[curr--];
970  if (tt->coolId() >> 16 & crateModuleMask(crate, module)){
971  uint16_t mcmID = (tt->coolId() >> 8) & 0xff;
972  uint16_t chnID = tt->coolId() & 0xff;
973  uint16_t error = mcmErrors.at(mcmID);
974 
975  // Now translate the error into Athena language
976  LVL1::DataError errorBits( tt->errorWord() );
977  if ( error & (1<<chnID) ) { errorBits.set(LVL1::DataError::ChannelDisabled); }
978  if ( error & (1<<4) ) { errorBits.set(LVL1::DataError::MCMAbsent); }
979  if ( error & (1<<5) ) { errorBits.set(LVL1::DataError::Timeout); }
980  if ( error & (1<<6) ) { errorBits.set(LVL1::DataError::ASICFull); }
981  if ( error & (1<<7) ) { errorBits.set(LVL1::DataError::EventMismatch); }
982  if ( error & (1<<8) ) { errorBits.set(LVL1::DataError::BunchMismatch); }
983  if ( error & (1<<9) ) { errorBits.set(LVL1::DataError::FIFOCorrupt); }
984  if ( error & (1<<10) ) { errorBits.set(LVL1::DataError::PinParity); }
985 
986  // Set the modified error word for this channel
987  tt->setErrorWord( errorBits.error() );
988  }else{
989  break;
990  }
991  }
992  }
993 }

◆ processPpmNeutral_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmNeutral_ ( State &  state) const
private

Definition at line 331 of file PpmByteStreamReadV1V2Tool.cxx.

332 {
333  uint8_t numLut = state.m_subBlockHeader.nSlice1();
334  uint8_t numFadc = state.m_subBlockHeader.nSlice2();
335  uint8_t totSlice = 3 * numLut + numFadc;
336 
337  uint8_t channel = 0;
338  for ( int asic = 0 ; asic < 4 ; ++asic ) {
339  for ( int mcm = 0 ; mcm < 16 ; ++mcm ) {
340  // ----------------------------------------------------------------------
341  std::vector<uint32_t> rotated(totSlice);
342 
343  for ( uint8_t slice = 0 ; slice < totSlice ; ++slice ) {
344  for ( uint8_t bit = 0 ; bit < 11 ; ++bit ) {
345  if ( state.m_ppBlock[slice * 11 + asic * (11 * totSlice) + bit + 1] & (1 << mcm))
346  rotated[slice] |= (1 << bit);
347  }
348  }
349 
350  bool nonZeroData = false;
351  for (uint8_t slice = 0; slice < numLut; ++slice) {
352  if (rotated[slice]
353  || rotated[slice + numLut]
354  || rotated[slice + 2 * numLut + numFadc]) { // CP, JET
355  nonZeroData = true;
356  break;
357  }
358  }
359 
360  std::vector<uint8_t> lcpVal;
361  std::vector<uint8_t> lcpBcidVec;
362  std::vector<uint8_t> ljeVal;
363  std::vector<uint8_t> ljeSat80Vec;
364  std::vector<int16_t> pedCor;
365  std::vector<uint8_t> pedEn;
366 
367  std::vector<uint16_t> adcVal;
368  std::vector<uint8_t> adcExt;
369 
370  if (nonZeroData) {
371  for (uint8_t slice = 0; slice < numLut; ++slice) {
372  lcpVal.push_back(rotated[slice] & 0xff);
373  ljeVal.push_back(rotated[slice + numLut] & 0xff);
374  pedCor.push_back(::pedCorrection(rotated[slice + 2 * numLut + numFadc] & 0x3ff));
375 
376  lcpBcidVec.push_back((rotated[slice] >> 8) & 0x7);
377  ljeSat80Vec.push_back((rotated[slice + numLut] >> 8) & 0x7);
378  pedEn.push_back((rotated[slice + 2 * numLut + numFadc] >> 10) & 0x1);
379  }
380  }
381 
382  for (uint8_t slice = 0; slice < numFadc; ++slice) {
383  if (rotated[slice + numLut]) { // CP, JET
384  nonZeroData = true;
385  break;
386  }
387  }
388 
389  if (nonZeroData) {
390  for (uint8_t slice = 0; slice < numFadc; ++ slice) {
391  adcVal.push_back(rotated[slice + 2 * numLut] & 0x3ff);
392  adcExt.push_back((rotated[slice + 2 * numLut] >> 10 & 0x1) & 0x3ff);
393  }
394  }
395 
396  CHECK(addTriggerTowerV2_(
397  state,
398  state.m_subBlockHeader.crate(),
399  state.m_subBlockHeader.module(),
400  channel,
401  std::move(lcpVal),
402  std::move(lcpBcidVec),
403  std::move(ljeVal),
404  std::move(ljeSat80Vec),
405  std::move(adcVal),
406  std::move(adcExt),
407  std::move(pedCor),
408  std::move(pedEn)));
409  // ---------------------------------------------------------------------
410  channel++;
411  }
412  }
413  return StatusCode::SUCCESS;
414 }

◆ processPpmStandardR3V1_() [1/2]

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmStandardR3V1_ ( State &  state) const
private

Definition at line 897 of file PpmByteStreamReadV1V2Tool.cxx.

898 {
899  for(auto lut : state.m_ppLuts) {
900  CHECK(addTriggerTowerV1_(
901  state,
902  state.m_subBlockHeader.crate(),
903  state.m_subBlockHeader.module(),
904  lut.first,
905  lut.second,
906  state.m_ppFadcs[lut.first]));
907  }
908  return StatusCode::SUCCESS;
909 }

◆ processPpmStandardR3V1_() [2/2]

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmStandardR3V1_ ( State &  state,
uint32_t  word,
int  indata 
) const
private

Definition at line 538 of file PpmByteStreamReadV1V2Tool.cxx.

541 {
542 
543  StatusCode sc = StatusCode::SUCCESS;
544  if (state.m_subBlockHeader.seqNum() == 63) { // Error block
545  ATH_MSG_DEBUG("Error PPM subblock");
546  //TODO: errorTool
547  } else {
548  const uint8_t numAdc = state.m_subBlockHeader.nSlice2();
549  const uint8_t numLut = state.m_subBlockHeader.nSlice1();
550  const uint8_t nTotal = numAdc + numLut;
551  const uint8_t wordsPerBlock = 8; // 16 towers (4 MCMs) / 2 per word
552  const uint8_t iBlk = inData / wordsPerBlock;
553  uint8_t iChan = state.m_subBlockHeader.seqNum() + 2 * (inData % wordsPerBlock);
554 
555  if (iBlk < numLut) { // First all LUT values
556  for(uint8_t i = 0; i < 2; ++i) {
557  uint16_t subword = (word >> 16 * i) & 0x7ff;
558  state.m_ppLuts[iChan].push_back(subword);
559  iChan++;
560  }
561  } else if (iBlk < nTotal) { // Next all FADC values
562  for(uint8_t i = 0; i < 2; ++i) {
563  uint16_t subword = (word >> (16 * i)) & 0x7ff;
564  state.m_ppFadcs[iChan].push_back(subword);
565  iChan++;
566  }
567 
568  } else{
569  ATH_MSG_WARNING("Error decoding Ppm word (run1)");
570  sc = StatusCode::FAILURE;
571  }
572 
573  }
574  return sc;
575 }

◆ processPpmStandardR4V1_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmStandardR4V1_ ( State &  state) const
private

Definition at line 837 of file PpmByteStreamReadV1V2Tool.cxx.

838 {
839  BitReader br (state.m_ppBlock);
840  uint8_t numAdc = state.m_subBlockHeader.nSlice2();
841  uint8_t numLut = state.m_subBlockHeader.nSlice1();
842  uint8_t crate = state.m_subBlockHeader.crate();
843  uint8_t module = state.m_subBlockHeader.module();
844 
845  for (uint8_t chan = 0; chan < 64; ++chan) {
846 
847  //for (uint8_t k = 0; k < 4; ++k) {
848  std::vector<uint8_t> lcpVal;
849  std::vector<uint8_t> lcpBcidVec;
850 
851  std::vector<uint8_t> ljeVal;
852  std::vector<uint8_t> ljeSat80Vec;
853 
854 
855 
856  std::vector<uint16_t> adcVal;
857  std::vector<uint8_t> adcExt;
858  std::vector<int16_t> pedCor;
859  std::vector<uint8_t> pedEn;
860  try {
861  for (int i = 0; i < numLut; ++i) {
862  lcpVal.push_back(br.getField(8));
863  lcpBcidVec.push_back(br.getField(3));
864  }
865 
866  for (int i = 0; i < numLut; ++i) {
867  ljeVal.push_back(br.getField(8));
868  ljeSat80Vec.push_back(br.getField(3));
869  }
870 
871  for (int i = 0; i < numAdc; ++i) {
872  adcVal.push_back(br.getField(10));
873  adcExt.push_back(br.getField(1));
874  }
875 
876  for (int i = 0; i < numLut; ++i) {
877  uint16_t pc = br.getField(10);
878  pedCor.push_back(pedCorrection(pc));
879  pedEn.push_back(br.getField(1));
880  }
881  } catch (const std::out_of_range& ex) {
882  ATH_MSG_WARNING("Excess Data in Sub-block");
883  m_errorTool->rodError(state.m_rodSourceId, L1CaloSubBlock::UNPACK_EXCESS_DATA);
884  }
885  CHECK(
886  addTriggerTowerV2_(state,
887  crate, module, chan,
888  std::move(lcpVal), std::move(lcpBcidVec),
889  std::move(ljeVal), std::move(ljeSat80Vec),
890  std::move(adcVal), std::move(adcExt),
891  std::move(pedCor), std::move(pedEn)));
892  }
893 
894  return StatusCode::SUCCESS;
895 }

◆ processPpmWord_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processPpmWord_ ( State &  state,
uint32_t  word,
int  indata 
) const
private

Definition at line 273 of file PpmByteStreamReadV1V2Tool.cxx.

276 {
277  if ( (state.m_subBlockHeader.format() == 0)
278  || (state.m_subBlockHeader.format() >= 2)
279  || (state.m_verCode >= 0x41)) {
280  state.m_ppBlock.push_back(word);
281  } else if ((state.m_verCode == 0x21) || (state.m_verCode == 0x31)) {
282  return processPpmStandardR3V1_(state, word, indata);
283  } else {
284  ATH_MSG_ERROR("Unsupported PPM version:format ("
285  << state.m_verCode << ":" << state.m_subBlockHeader.format()
286  <<") combination");
287  return StatusCode::FAILURE;
288  }
289  return StatusCode::SUCCESS;
290 }

◆ processRobFragment_()

StatusCode LVL1BS::PpmByteStreamReadV1V2Tool::processRobFragment_ ( State &  state,
const ROBIterator &  robFrag,
const RequestType &  requestedType 
) const
private

Definition at line 156 of file PpmByteStreamReadV1V2Tool.cxx.

159 {
160  auto rob = **robIter;
161 
162  ATH_MSG_DEBUG(
163  "Treating ROB fragment source id #" << MSG::hex << rob.rob_source_id());
164 
165 
166  state.m_rodSourceId = rob.rod_source_id();
167  state.m_robSourceId = rob.source_id();
168  const auto sourceID = (state.m_rodSourceId >> 16) & 0xff;
169  const auto rodCrate = m_srcIdMap->crate(state.m_rodSourceId);
170  const auto rodSlink = m_srcIdMap->slink(state.m_rodSourceId);
171  // -------------------------------------------------------------------------
172  // Check Rob status
173  if (rob.nstatus() > 0) {
174  ROBPointer robData;
175  rob.status(robData);
176  if (*robData != 0) {
177  ATH_MSG_WARNING("ROB status error - skipping fragment");
178  m_errorTool->robError(state.m_rodSourceId, *robData);
179  return StatusCode::FAILURE;
180  }
181  }
182  // -------------------------------------------------------------------------
183  RODPointer payloadBeg;
184  RODPointer payloadEnd;
185  RODPointer payload;
186 
187  rob.rod_data(payloadBeg);
188  payloadEnd = payloadBeg + rob.rod_ndata();
189  payload = payloadBeg;
190  // -------------------------------------------------------------------------
191  if (payload == payloadEnd) {
192  ATH_MSG_DEBUG("ROB fragment empty");
193  return StatusCode::FAILURE;
194  }
195  // -------------------------------------------------------------------------
196 
197 
198  uint16_t rodVer = rob.rod_version() & 0xffff;
199  uint32_t rodRunNumber = rob.rod_run_no() & 0xffffff;
200  state.m_verCode = ((rodVer & 0xfff) << 4) | 1;
201 
202 
203  if (sourceID != state.m_subDetectorID) {
204  ATH_MSG_ERROR("Wrong subdetector source id for requested objects: " << state.m_rodSourceId);
205  return StatusCode::FAILURE;
206  }
207 
208  ATH_MSG_DEBUG("Treating crate " << rodCrate << " slink " << rodSlink);
209  state.m_caloUserHeader = CaloUserHeader(*payload);
210  if (!state.m_caloUserHeader.isValid()) {
211  ATH_MSG_ERROR("Invalid or missing user header");
212  return StatusCode::FAILURE;
213  }
214 
215  ATH_MSG_DEBUG(
216  "Run number: " << MSG::dec << rodRunNumber << endmsg
217  << "Version code: 0x" << MSG::hex << int(state.m_verCode) << MSG::dec
218  << endmsg << "LUT triggered slice offset: "
219  << int(state.m_caloUserHeader.lut()) << endmsg
220  << "FADC triggered slice offset: " << int(state.m_caloUserHeader.ppFadc())
221  << endmsg << "FADC baseline lower bound: "
222  << int(state.m_caloUserHeader.ppLowerBound()));
223 
224  int indata = 0;
225  uint8_t blockType = 0;
226  int subBlock = 0;
227 
228  for (; payload != payloadEnd; ++payload) {
229  if (CaloUserHeader::isValid(*payload) && (subBlock == 0)) {
230 
231  } else if (SubBlockHeader::isSubBlockHeader(*payload)) {
232  indata = 0;
233  CHECK(processPpmBlock_(state));
234 
235  state.m_ppLuts.clear();
236  state.m_ppFadcs.clear();
237  state.m_ppBlock.clear();
238 
239  blockType = (*payload >> 28) & 0xf;
240 
241  if ((blockType & 0xd) == 0xc) {
242  state.m_subBlockHeader = SubBlockHeader(*payload);
243  ATH_MSG_VERBOSE(
244  "SubBlock version #" << int(state.m_subBlockHeader.version())
245  << " format #" << int(state.m_subBlockHeader.format())
246  << " seqNum (compVer) #" << int(state.m_subBlockHeader.seqNum())
247  << " nslice1 #" << int(state.m_subBlockHeader.nSlice1())
248  << " nslice2 #" << int(state.m_subBlockHeader.nSlice2())
249  );
250  subBlock = blockType & 0xe;
251  } else if (blockType == (subBlock | 1)) {
252  processSubBlockStatus_(state, state.m_subBlockHeader.crate(), state.m_subBlockHeader.module(), *payload);
253  subBlock = 0;
254  }
255  } else {
256  switch(state.m_subDetectorID){
257  case eformat::TDAQ_CALO_PREPROC:
258  CHECK(processPpmWord_(state, *payload, indata));
259  break;
260  default:
261  break;
262  }
263  indata++;
264  }
265  }
266  CHECK(processPpmBlock_(state));
267  state.m_ppLuts.clear();
268  state.m_ppFadcs.clear();
269  state.m_ppBlock.clear();
270  return StatusCode::SUCCESS;
271 }

◆ processSubBlockStatus_()

void LVL1BS::PpmByteStreamReadV1V2Tool::processSubBlockStatus_ ( State &  state,
uint8_t  crate,
uint8_t  module,
uint32_t  word 
) const
private

Definition at line 911 of file PpmByteStreamReadV1V2Tool.cxx.

913 {
914  int curr = state.m_triggerTowers->size() - 1;
915  for(int i=0; i < s_channels; ++i){
916  if (curr < 0){
917  break;
918  }
919  auto tt = (*state.m_triggerTowers)[curr--];
920  if (tt->coolId() >> 16 & crateModuleMask(crate, module)){
921  LVL1::DataError errorBits( tt->errorWord() );
922  errorBits.set(LVL1::DataError::SubStatusWord, payload);
923  tt->setErrorWord( errorBits.error() );
924  }else{
925  break;
926  }
927  }
928 }

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

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

◆ 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_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_errorTool

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

Definition at line 204 of file PpmByteStreamReadV1V2Tool.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_maxSizeSeen

std::atomic<size_t> LVL1BS::PpmByteStreamReadV1V2Tool::m_maxSizeSeen
mutableprivate

Definition at line 216 of file PpmByteStreamReadV1V2Tool.h.

◆ m_ppmMaps

ToolHandle<LVL1::IL1CaloMappingTool> LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmMaps
private

Channel mapping tool.

Definition at line 206 of file PpmByteStreamReadV1V2Tool.h.

◆ m_ppmSourceIDs

std::vector<uint32_t> LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmSourceIDs
private

Definition at line 211 of file PpmByteStreamReadV1V2Tool.h.

◆ m_ppmSourceIDsMuon

std::vector<uint32_t> LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmSourceIDsMuon
private

Definition at line 212 of file PpmByteStreamReadV1V2Tool.h.

◆ m_ppmSourceIDsSpare

std::vector<uint32_t> LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmSourceIDsSpare
private

Definition at line 213 of file PpmByteStreamReadV1V2Tool.h.

◆ m_robDataProvider

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

Service for reading bytestream.

Definition at line 208 of file PpmByteStreamReadV1V2Tool.h.

◆ m_srcIdMap

L1CaloSrcIdMap* LVL1BS::PpmByteStreamReadV1V2Tool::m_srcIdMap
private

Definition at line 214 of file PpmByteStreamReadV1V2Tool.h.

◆ m_useSWROD

bool LVL1BS::PpmByteStreamReadV1V2Tool::m_useSWROD = false
private

Definition at line 226 of file PpmByteStreamReadV1V2Tool.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ s_channels

const uint8_t LVL1BS::PpmByteStreamReadV1V2Tool::s_channels = 64
staticprivate

Definition at line 223 of file PpmByteStreamReadV1V2Tool.h.

◆ s_crates

const uint8_t LVL1BS::PpmByteStreamReadV1V2Tool::s_crates = 8
staticprivate

Definition at line 220 of file PpmByteStreamReadV1V2Tool.h.

◆ s_maxtowers

const uint16_t LVL1BS::PpmByteStreamReadV1V2Tool::s_maxtowers = s_crates * s_modules * s_channels
staticprivate

Definition at line 224 of file PpmByteStreamReadV1V2Tool.h.

◆ s_modules

const uint8_t LVL1BS::PpmByteStreamReadV1V2Tool::s_modules = 16
staticprivate

Definition at line 221 of file PpmByteStreamReadV1V2Tool.h.

◆ s_submodules

const uint8_t LVL1BS::PpmByteStreamReadV1V2Tool::s_submodules = 16
staticprivate

Definition at line 222 of file PpmByteStreamReadV1V2Tool.h.

The documentation for this class was generated from the following files:
LVL1::DataError::PinParity
@ PinParity
Definition: DataError.h:35
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:215
LVL1::DataError::Timeout
@ Timeout
Definition: DataError.h:33
test_pyathena.eta
eta
Definition: test_pyathena.py:10
CxxUtils::atomic_fetch_max
T atomic_fetch_max(std::atomic< T > *a, T v, std::memory_order memorder=std::memory_order_seq_cst)
Atomically calculate maximum.
Definition: atomic_fetch_minmax.h:42
LVL1BS::L1CaloSrcIdMap::slink
int slink(uint32_t code) const
Return slink from unpacked moduleID.
Definition: L1CaloSrcIdMap.cxx:73
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmBlock_
StatusCode processPpmBlock_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:293
LVL1BS::PpmByteStreamReadV1V2Tool::ROBIterator
IROBDataProviderSvc::VROBFRAG::const_iterator ROBIterator
Definition: PpmByteStreamReadV1V2Tool.h:77
LVL1::DataError
Error data.
Definition: DataError.h:27
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
LVL1BS::L1CaloSrcIdMap::useSWROD
static void useSWROD(bool in)
Flag to decide if SWROD readout should be used instead of legacy.
Definition: L1CaloSrcIdMap.h:30
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
vtune_athena.format
format
Definition: vtune_athena.py:14
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
LVL1BS::PpmByteStreamReadV1V2Tool::m_maxSizeSeen
std::atomic< size_t > m_maxSizeSeen
Definition: PpmByteStreamReadV1V2Tool.h:216
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
LVL1BS::PpmByteStreamReadV1V2Tool::s_submodules
static const uint8_t s_submodules
Definition: PpmByteStreamReadV1V2Tool.h:222
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmBlockR4V1_
StatusCode processPpmBlockR4V1_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:577
LVL1BS::PpmByteStreamReadV1V2Tool::m_errorTool
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool > m_errorTool
Definition: PpmByteStreamReadV1V2Tool.h:204
L1Topo::blockType
L1Topo::BlockTypes blockType(const uint32_t word, uint32_t offset=28, uint32_t size=0x0f)
Function to return the block type of a data word from L1Topo
Definition: BlockTypes.cxx:9
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
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
LVL1BS::PpmByteStreamReadV1V2Tool::addTriggerTowerV1_
StatusCode addTriggerTowerV1_(State &state, uint8_t crate, uint8_t module, uint8_t channel, const std::vector< uint16_t > &luts, const std::vector< uint16_t > &fadc) const
Definition: PpmByteStreamReadV1V2Tool.cxx:1070
fmt
const char *const fmt
Definition: TripleGaussCollFit.cxx:84
LVL1BS::PpmByteStreamReadV1V2Tool::processRobFragment_
StatusCode processRobFragment_(State &state, const ROBIterator &robFrag, const RequestType &requestedType) const
Definition: PpmByteStreamReadV1V2Tool.cxx:156
LVL1BS::PpmByteStreamReadV1V2Tool::convert
StatusCode convert(xAOD::TriggerTowerContainer *const ttCollection) const
Convert ROB fragments to trigger towers.
Definition: PpmByteStreamReadV1V2Tool.cxx:134
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
LVL1::DataError::MCMAbsent
@ MCMAbsent
Definition: DataError.h:33
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmCompressedR3V1_
StatusCode processPpmCompressedR3V1_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:416
LVL1BS::PpmByteStreamReadV1V2Tool::getPpmAdcSamplesR3_
std::vector< uint16_t > getPpmAdcSamplesR3_(State &state, BitReader &br, uint8_t format, uint8_t minIndex) const
Definition: PpmByteStreamReadV1V2Tool.cxx:500
LVL1BS::SubBlockHeader::isSubBlockHeader
bool isSubBlockHeader() const
Definition: SubBlockHeader.cxx:57
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition: gFexGlobalRoI_v1.cxx:55
LVL1BS::PpmByteStreamReadV1V2Tool::m_srcIdMap
L1CaloSrcIdMap * m_srcIdMap
Definition: PpmByteStreamReadV1V2Tool.h:214
LVL1BS::PpmByteStreamReadV1V2Tool::m_robDataProvider
ServiceHandle< IROBDataProviderSvc > m_robDataProvider
Service for reading bytestream.
Definition: PpmByteStreamReadV1V2Tool.h:208
ITkPixEncoding::lut
constexpr auto lut(Generator &&f)
Definition: ITkPixQCoreEncodingLUT.h:19
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
LVL1BS::PpmByteStreamReadV1V2Tool::processSubBlockStatus_
void processSubBlockStatus_(State &state, uint8_t crate, uint8_t module, uint32_t word) const
Definition: PpmByteStreamReadV1V2Tool.cxx:911
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmMaps
ToolHandle< LVL1::IL1CaloMappingTool > m_ppmMaps
Channel mapping tool.
Definition: PpmByteStreamReadV1V2Tool.h:206
LVL1::DataError::SubStatusWord
@ SubStatusWord
Definition: DataError.h:44
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
python.PyAthena.module
module
Definition: PyAthena.py:131
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmSourceIDs
std::vector< uint32_t > m_ppmSourceIDs
Definition: PpmByteStreamReadV1V2Tool.h:211
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
LVL1BS::CaloUserHeader::isValid
bool isValid() const
Definition: CaloUserHeader.cxx:46
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
asg::AsgTool::AsgTool
AsgTool(const std::string &name)
Constructor specifying the tool instance's name.
Definition: AsgTool.cxx:58
LVL1BS::PpmByteStreamReadV1V2Tool::s_channels
static const uint8_t s_channels
Definition: PpmByteStreamReadV1V2Tool.h:223
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmStandardR4V1_
StatusCode processPpmStandardR4V1_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:837
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LVL1BS::PpmByteStreamReadV1V2Tool::m_useSWROD
bool m_useSWROD
Definition: PpmByteStreamReadV1V2Tool.h:226
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
lumiFormat.i
int i
Definition: lumiFormat.py:85
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
LVL1BS::PpmByteStreamReadV1V2Tool::interpretPpmHeaderR4V1_
void interpretPpmHeaderR4V1_(BitReader &br, uint8_t numAdc, int8_t &encoding, int8_t &minIndex) const
Definition: PpmByteStreamReadV1V2Tool.cxx:739
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
generateReferenceFile.encoding
encoding
Definition: generateReferenceFile.py:15
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
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
MuonR4::State
CalibratedSpacePoint::State State
Definition: SpacePointCalibrator.cxx:33
LVL1BS::PpmByteStreamReadV1V2Tool::addTriggerTowerV2_
StatusCode addTriggerTowerV2_(State &state, uint8_t crate, uint8_t module, uint8_t channel, std::vector< uint8_t > &&lcpVal, std::vector< uint8_t > &&lcpBcidVec, std::vector< uint8_t > &&ljeVal, std::vector< uint8_t > &&ljeSat80Vec, std::vector< uint16_t > &&adcVal, std::vector< uint8_t > &&adcExt, std::vector< int16_t > &&pedCor, std::vector< uint8_t > &&pedEn) const
Definition: PpmByteStreamReadV1V2Tool.cxx:996
xAOD::TriggerTower_v2
Description of TriggerTower_v2.
Definition: TriggerTower_v2.h:49
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
LVL1::DataError::EventMismatch
@ EventMismatch
Definition: DataError.h:34
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
LVL1::DataError::ASICFull
@ ASICFull
Definition: DataError.h:34
hist_file_dump.f
f
Definition: hist_file_dump.py:140
IROBDataProviderSvc::VROBFRAG
std::vector< const ROBF * > VROBFRAG
Definition: IROBDataProviderSvc.h:27
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
plotBeamSpotCompare.xd
xd
Definition: plotBeamSpotCompare.py:219
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmNeutral_
StatusCode processPpmNeutral_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:331
LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmSourceIDsSpare
std::vector< uint32_t > m_ppmSourceIDsSpare
Definition: PpmByteStreamReadV1V2Tool.h:213
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmErrorBits_
void processPpmErrorBits_(State &state, uint8_t crate, uint8_t module, BitReader &br) const
Definition: PpmByteStreamReadV1V2Tool.cxx:931
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmBlockR3V1_
StatusCode processPpmBlockR3V1_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:825
LVL1::TrigT1CaloDefs::xAODTriggerTowerLocation
static const std::string xAODTriggerTowerLocation
Definition: TrigT1CaloDefs.h:36
LVL1::DataError::ChannelDisabled
@ ChannelDisabled
Definition: DataError.h:33
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
LVL1BS::L1CaloSubBlock::UNPACK_EXCESS_DATA
@ UNPACK_EXCESS_DATA
Definition: L1CaloSubBlock.h:41
LVL1BS::PpmByteStreamReadV1V2Tool::initSourceIDs
void initSourceIDs()
Definition: PpmByteStreamReadV1V2Tool.cxx:1106
LVL1BS::PpmByteStreamReadV1V2Tool::RODPointer
OFFLINE_FRAGMENTS_NAMESPACE::PointerType RODPointer
Definition: PpmByteStreamReadV1V2Tool.h:79
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmWord_
StatusCode processPpmWord_(State &state, uint32_t word, int indata) const
Definition: PpmByteStreamReadV1V2Tool.cxx:273
a
TList * a
Definition: liststreamerinfos.cxx:10
LVL1BS::PpmByteStreamReadV1V2Tool::RequestType::PPM
@ PPM
h
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
LVL1BS::PpmByteStreamReadV1V2Tool::m_ppmSourceIDsMuon
std::vector< uint32_t > m_ppmSourceIDsMuon
Definition: PpmByteStreamReadV1V2Tool.h:212
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LVL1::DataError::BunchMismatch
@ BunchMismatch
Definition: DataError.h:34
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmCompressedR4V1_
StatusCode processPpmCompressedR4V1_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:589
LVL1BS::PpmByteStreamReadV1V2Tool::processPpmStandardR3V1_
StatusCode processPpmStandardR3V1_(State &state) const
Definition: PpmByteStreamReadV1V2Tool.cxx:897
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::PpmByteStreamReadV1V2Tool::getPpmAdcSamplesR4_
std::vector< uint16_t > getPpmAdcSamplesR4_(State &state, BitReader &br, uint8_t encoding, uint8_t minIndex) const
Definition: PpmByteStreamReadV1V2Tool.cxx:790
LVL1::DataError::FIFOCorrupt
@ FIFOCorrupt
Definition: DataError.h:35
LVL1BS::PpmByteStreamReadV1V2Tool::ROBPointer
OFFLINE_FRAGMENTS_NAMESPACE::PointerType ROBPointer
Definition: PpmByteStreamReadV1V2Tool.h:78
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
LVL1BS::L1CaloSrcIdMap::maxSlinks
int maxSlinks() const
Return the maximum possible number of slinks.
Definition: L1CaloSrcIdMap.cxx:82
SG::DataProxy
Definition: DataProxy.h:45
error
Definition: IImpactPoint3dEstimator.h:70
TileDCSDataPlotter.tt
tt
Definition: TileDCSDataPlotter.py:876
python.SystemOfUnits.pc
float pc
Definition: SystemOfUnits.py:114
fitman.k
k
Definition: fitman.py:528
xAOD::TriggerTower
TriggerTower_v2 TriggerTower
Define the latest version of the TriggerTower class.
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/TriggerTower.h:16
PlotCalibFromCool.br
br
Definition: PlotCalibFromCool.py:355
LVL1BS::PpmByteStreamReadV1V2Tool::ppmSourceIDs
const std::vector< uint32_t > & ppmSourceIDs(State &state, const std::string &sgKey) const
Return reference to vector with all possible Source Identifiers.
Definition: PpmByteStreamReadV1V2Tool.cxx:1132
Generated on Tue Sep 2 2025 22:16:31 for ATLAS Offline Software by   doxygen 1.8.18