ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
MuCTPIPhase1ByteStreamAlgo Class Reference

this is done in the original (run2) tool; trying to replace this with an include above. More...

#include <MuCTPIPhase1ByteStreamAlgo.h>

Inheritance diagram for MuCTPIPhase1ByteStreamAlgo:
Collaboration diagram for MuCTPIPhase1ByteStreamAlgo:

Public Member Functions

 MuCTPIPhase1ByteStreamAlgo (const std::string &name, ISvcLocator *svcLoc)
 Default constructor. More...
 
virtual StatusCode initialize () override
 
virtual StatusCode execute (const EventContext &eventContext) const override
 
virtual StatusCode finalize () override
 
StatusCode convert (const IROBDataProviderSvc::ROBF *rob, SG::WriteHandle< MuCTPI_Phase1_RDO > &outputHandle) const
 Convert ROBFragment to MuCTPI_RDO. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
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 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

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

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

Gaudi::Property< uint32_t > m_robId {this, "ROBID", 0x760000, "MuCTPI DAQ readout ROB ID"}
 Object storing the various IDs of the MuCTPI fragment. More...
 
ServiceHandle< IROBDataProviderSvcm_robDataProviderSvc { this, "ROBDataProviderSvc", "ROBDataProviderSvc", "ROB data provider"}
 ROBDataProvider service handle. More...
 
SG::WriteHandleKey< MuCTPI_Phase1_RDOm_MuCTPI_Phase1_RDOKey { this, "MuCTPI_Phase1_RDOKey", "MUCTPI_Phase1_RDO" }
 
std::vector< uint32_t > m_muctpi_Nbits = {3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1}
 
Gaudi::Property< std::string > m_alias_db {this,"TriggerDBAlias","TRIGGERDB_RUN3","Alias to the TriggerDB to download CTP configuration from"}
 
Gaudi::Property< bool > m_doTopo
 Other properties. More...
 
const std::string m_barrelRoIFile = "TrigConfMuctpi/Data_ROI_Mapping_Barrel_040422.txt"
 
const std::string m_ecfRoIFile = "TrigConfMuctpi/Data_RoI_Mapping_EF_040422.txt"
 
const std::string m_side0LUTFile = "TrigConfMuctpi/lookup_0_040422.json"
 
const std::string m_side1LUTFile = "TrigConfMuctpi/lookup_1_040422.json"
 
LVL1MUCTPIPHASE1::L1TopoLUT m_l1topoLUT
 Helper members. More...
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. 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

this is done in the original (run2) tool; trying to replace this with an include above.

Algo doing the ROB -> MuCTPI_Phase1_RDO ByteStream conversion

Definition at line 34 of file MuCTPIPhase1ByteStreamAlgo.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuCTPIPhase1ByteStreamAlgo()

MuCTPIPhase1ByteStreamAlgo::MuCTPIPhase1ByteStreamAlgo ( const std::string &  name,
ISvcLocator *  svcLoc 
)

Default constructor.

The constructor takes care of correctly constructing the base class and declaring the tool's interface to the framework.

Definition at line 22 of file MuCTPIPhase1ByteStreamAlgo.cxx.

23  : AthReentrantAlgorithm( name, svcLoc) {}

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ convert()

StatusCode MuCTPIPhase1ByteStreamAlgo::convert ( const IROBDataProviderSvc::ROBF rob,
SG::WriteHandle< MuCTPI_Phase1_RDO > &  outputHandle 
) const

Convert ROBFragment to MuCTPI_RDO.

Conversion from eformat::ROBFragment to RDO.

This is called from the MuCTPIByteStreamCnv::createObj method.

Definition at line 135 of file MuCTPIPhase1ByteStreamAlgo.cxx.

135  {
136 
137  ATH_MSG_DEBUG("executing convert() from ROBFragment to RDO");
138  // check ROD source ID
139  const uint32_t rodId = rob->rod_source_id();
140  // check BC ID
141  const uint32_t bcId = rob->rod_bc_id();
142 
143  ATH_MSG_DEBUG(" expected ROD sub-detector ID: " << std::hex << m_robId << " ID found: " << std::hex << rodId << std::dec);
144 
145  if( rodId != m_robId ) {
146  ATH_MSG_ERROR("Wrong ROD ID found in the MuCTPI ROB fragment!");
147  return StatusCode::FAILURE;
148  }
149 
150  ATH_MSG_VERBOSE(" ROD Header BCID " << bcId << ", dumping MuCTPI words:");
151 
152  const uint32_t* it_data;
153  rob->rod_data( it_data );
154  const uint32_t ndata = rob->rod_ndata();
155  ATH_MSG_DEBUG("MUCTPI DQ DEBUG: number of ROB data words: " << std::dec << ndata);
156 
157  //slices
158  std::vector< LVL1::MuCTPIBits::Slice > slices;
160  bool firstSlice=true;
161  std::vector<size_t> errorBits;
162  uint64_t sliceMultiplicity=0;//grouping the 3 multiplicity words, to be processed at the end of the slice
163 
164  for( uint32_t iWord = 0; iWord < ndata; ++iWord, ++it_data ) {
165 
166  //for each word, get it, find type, and add in Slice struct.
167  uint32_t word = static_cast< uint32_t >( *it_data );
168  ATH_MSG_DEBUG("MUCTPI raw word " << iWord << ": 0x" << std::hex << word << std::dec);
170 
171  switch (wordType) {
173 
174  ATH_MSG_DEBUG(" MUCTPI DQ DEBUG: Timeslice found: "<< std::hex << word);
175 
176  //add previous slice if any
177  if(!firstSlice)
178  {
179  ATH_MSG_DEBUG(" MUCTPI DQ DEBUG: new timeslice found (pushing)");
180  slices.push_back(slice);
181  }
182  else
183  firstSlice=false;
184 
185  //make new slice (to be improved, since "new" will give pointer)
187  slice = s;
188 
189  const auto header = LVL1::MuCTPIBits::timesliceHeader(word);
190  ATH_MSG_DEBUG("This is a timeslice header word with BCID=" << header.bcid
191  << ", NTOB=" << header.tobCount << ", NCAND=" << header.candCount);
192  slice.bcid = header.bcid;
193  slice.nCand = header.candCount;
194  slice.nTOB = header.tobCount;
195  break;
196  }
199  ATH_MSG_DEBUG("This is a multiplicity word #" << tmNum);
200 
201  if(m_muctpi_Nbits.size()==32)
202  {
203  //fill mult word into temp container until 3rd word is found
204  if(tmNum==1)
205  sliceMultiplicity |= ( (uint64_t)LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART1_SHIFT, LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART1_MASK) ) << LVL1::MuCTPIBits::RUN3_MULTIPLICITY_ENC_PART1_SHIFT;
206  else if(tmNum==2)
207  sliceMultiplicity |= ( (uint64_t)LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART2_SHIFT, LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART2_MASK) ) << LVL1::MuCTPIBits::RUN3_MULTIPLICITY_ENC_PART2_SHIFT;
208  else if(tmNum==3)
209  sliceMultiplicity |= ( (uint64_t)LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART3_SHIFT, LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART3_MASK) ) << LVL1::MuCTPIBits::RUN3_MULTIPLICITY_ENC_PART3_SHIFT;
210 
211  //flags from third word
212  //AND: process multiplicity for the slice!!!
213  if(tmNum==3)
214  {
215  slice.mlt.nswMon = LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_NSW_MONITORING_TRIGGER_SHIFT, LVL1::MuCTPIBits::RUN3_NSW_MONITORING_TRIGGER_MASK);
216  slice.mlt.candOverflow = LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_OVERFLOW_SHIFT, LVL1::MuCTPIBits::RUN3_MULTIPLICITY_OVERFLOW_MASK);
217  slice.mlt.bits = sliceMultiplicity;
218 
219  //process the long mult word into 32 mlt thr counters
220  for(uint iThr=0;iThr<m_muctpi_Nbits.size();iThr++)
221  {
222  uint thismask=0;
223  if(m_muctpi_Nbits[iThr]==1)
224  thismask=0x1;
225  else if(m_muctpi_Nbits[iThr]==2)
226  thismask=0x3;
227  else if(m_muctpi_Nbits[iThr]==3)
228  thismask=0x7;
229 
230  //keep only the part of the 64bit word corresponding to the nbits value
231  slice.mlt.cnt.push_back( sliceMultiplicity & thismask);
232  //"throw away" the part of the 64bit word that we just used
233  sliceMultiplicity >>= m_muctpi_Nbits[iThr];
234  }
235 
236  sliceMultiplicity=0;//cleaning just in case..
237  }
238 
239  }
240  else
241  {
242  //if nbits size !=32, then it's not set
243  //for now, ignore, and can fill the histos with the Mult bits, as they come
244  //without decoding
245  //=>suppress this warning
246  //ATH_MSG_WARNING("MUCTPI DQ DEBUG: skipping Mult processing, no nbits defined");
247 
248  //todo: add code + histos for Mult bits
249  }
250 
251  break;
252  }
254  ATH_MSG_DEBUG("This is a RoI candidate word");
255 
256  LVL1::MuCTPIBits::Candidate thiscand(word);
257 
258  // We calculate eta/phi coordinates for each candidate with the
259  // full resolution available.
260  if(thiscand.type == LVL1::MuCTPIBits::SubsysID::Barrel)
261  {
262  thiscand.eta = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).eta;
263  thiscand.phi = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).phi;
264  //ATH_MSG_INFO("Candidate Pt " << thiscand.pt);
265  thiscand.mappedPt = LVL1::MuCTPIBits::RPCtoTGC_pt_map[thiscand.pt];
266  //ATH_MSG_INFO("Candidate mapped Pt " << thiscand.mappedPt);
267  }
268  else if(thiscand.type == LVL1::MuCTPIBits::SubsysID::Endcap)
269  {
270  thiscand.eta = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).eta;
271  thiscand.phi = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).phi;
272  }
273  else if(thiscand.type == LVL1::MuCTPIBits::SubsysID::Forward)
274  {
275  thiscand.eta = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).eta;
276  thiscand.phi = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).phi;
277  }
278  slice.cand.push_back(thiscand);
279  break;
280  }
282  ATH_MSG_DEBUG("This is a Topo TOB word "<< std::hex << word);
283  LVL1::MuCTPIBits::TopoTOB thistob(word);
284 
285  if(thistob.det == 0) // BA
286  {
287  try
288  {
289  thistob.roi = m_l1topoLUT.getBarrelROI(thistob.side, thistob.sec, thistob.barrel_eta_lookup, thistob.barrel_phi_lookup);
290  }
291  catch (const std::out_of_range& e) // Occurs when getBarrelROI fails to find entry in the map
292  {
293  ++barrelROIFailCounter;
294  ATH_MSG_WARNING("TopoTOB word not found in LUT!"
295  << " (" << e.what() << " exception)"
296  << " Word info: det = " << thistob.det
297  << ", subsystem = " << thistob.subsystem
298  << ", side = " << thistob.side
299  << ", sector = " << thistob.sec
300  << ", ieta = " << thistob.barrel_eta_lookup
301  << ", iphi = " << thistob.barrel_phi_lookup);
302  break;
303  }
304  thistob.etaDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).eta;
305  thistob.phiDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).phi;
306  }
307  else // FW or EC
308  {
309  // FW and EC have the ROI initialized in the constructor of the Topo word, because it is encoded in eta_raw and phi_raw
310  thistob.etaDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).eta;
311  thistob.phiDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).phi;
312  }
313  slice.tob.push_back(thistob);
314  break;
315  }
317  ATH_MSG_DEBUG("This is a status word"<< std::hex << word);
319  if (!errorBits.empty()) {
320  ATH_MSG_DEBUG("MUCTPI ROD data flagged with errors. The data status word is 0x" << std::hex << word << std::dec);
321  for (size_t bit : errorBits) {
322  ATH_MSG_DEBUG("Error bit " << bit << ": " << LVL1::MuCTPIBits::DataStatusWordErrors.at(bit));
323  }
324  }
325  break;
326  }
327  default: {
328  ATH_MSG_ERROR("The MUCTPI word 0x" << std::hex << word << std::dec << " does not match any known word type");
329  return StatusCode::FAILURE;
330  }//default
331  }//switch
332  }//for each word
333 
334  //add last timeslice in vector, since there is no end-slice flag
335  ATH_MSG_DEBUG(" MUCTPI DQ DEBUG: out of words (pushing last slice)");
336  slices.push_back( slice );
337 
338  // Check that the number of exceptions is below a limit based on the number of slices.
339  // Exceptions can occur if word is present in multiple timeslices for same event.
340  // This allows for cases where we have one or two bad words per event, but not where lots of map errors arise.
341  if (barrelROIFailCounter == slices.size() + 2 )
342  {
343  ATH_MSG_ERROR("TopoTOB word exception count exceeded limit!");
344  return StatusCode::FAILURE;
345  }
346 
347  // create MuCTPI RDO
348  ATH_CHECK(outputHandle.record(
349  std::make_unique<MuCTPI_Phase1_RDO>(std::move(slices), std::move(errorBits))
350  ));
351  return StatusCode::SUCCESS;
352 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

◆ execute()

StatusCode MuCTPIPhase1ByteStreamAlgo::execute ( const EventContext &  eventContext) const
overridevirtual

Definition at line 110 of file MuCTPIPhase1ByteStreamAlgo.cxx.

110  {
111  ATH_MSG_DEBUG("Executing " << name());
112 
113  // Retrieve the BS data for all tools in one request to parallelise DCM->ROS network requests
115  std::vector<uint32_t> robID = { m_robId };// Source ID of MIROD
116  //get rob fragment(s)
117  m_robDataProviderSvc->getROBData(eventContext, robID, vrobf, name());
118  //should only receive exactly 1 fragment; make sure:
119  if(vrobf.size()!=1)
120  {
121  ATH_MSG_ERROR("Wrong number of MUCTPI fragment in event: vrobf.size()="<<vrobf.size());
122  return StatusCode::FAILURE;
123  }
124 
125  //make the conversion, i.e. make the RDO, record it
127  ATH_CHECK(convert(vrobf[0],outputHandle));
128  return StatusCode::SUCCESS;
129 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ finalize()

StatusCode MuCTPIPhase1ByteStreamAlgo::finalize ( )
overridevirtual

Definition at line 354 of file MuCTPIPhase1ByteStreamAlgo.cxx.

355 {
356  if (barrelROIFailCounter != 0) ATH_MSG_WARNING(barrelROIFailCounter << " TopoTOB words could not retrieve RoIs in the barrel");
357  return StatusCode::SUCCESS;
358 }

◆ initialize()

StatusCode MuCTPIPhase1ByteStreamAlgo::initialize ( )
overridevirtual

fetch nbits vector from l1menu (todo: fix) bool success=false; TrigConf::L1CTPFiles ctpfiles; SG::ReadHandleKey<TrigConf::L1Menu> L1MenuKey{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu"};

ATH_CHECK(L1MenuKey.initialize()); if(L1MenuKey.initialize()) { SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(L1MenuKey);

if (!l1Menu.isValid()) { ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES L1 menu INvalid! Cannot read nbits for mlt word"); } else { ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu valid"); uint smk = l1Menu->smk(); TrigConf::TrigDBCTPFilesLoader db_loader(m_alias_db); options below added according to TrigConf::L1CTPFiles header file ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu load files with smk="<<smk); try{success = db_loader.loadHardwareFiles(smk, ctpfiles,0x08);} catch(std::exception& e){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES loadHardwareFiles exception: "<<e.what()); } catch(...){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES loadHardwareFiles: Unknown exception"); }

ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES success="<<success); } if(!ctpfiles.hasCompleteMuctpiData()) { ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES Incomplete MUCTPI data from TriggerDB"); } else if(success) { ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu load files success!"); try { m_muctpi_Nbits = (std::vector<uint32_t>) ctpfiles.muctpi_Nbits(); if(m_muctpi_Nbits.size()!=32) ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES MUCTPI data from TriggerDB - nbits wrong size: "<<std::dec << m_muctpi_Nbits.size()); else ATH_MSG_WARNING("MUCTPI DQ DEBUG: CTPFILES MUCTPI data from TriggerDB - nbits GOOD SIZE!");

ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu GOT muctpi nbits");

} catch(std::exception& e){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES exception: "<<e.what()); } catch(...){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES: Unknown exception"); } }

} return StatusCode::SUCCESS;

Definition at line 25 of file MuCTPIPhase1ByteStreamAlgo.cxx.

26 {
27  ATH_MSG_DEBUG("Initialising " << name());
28 
29  ATH_CHECK( m_MuCTPI_Phase1_RDOKey.initialize(/*m_processMuctpi=*/true) );
30 
31  //needed to enable the decoding of eta and phi
32  ATH_MSG_INFO("--- ENABLING THE DECODING");
33  const std::string barrelFileName = PathResolverFindCalibFile( m_barrelRoIFile );
34  ATH_MSG_INFO("--- - CHECK BARREL FILE NAME" << barrelFileName);
35  const std::string ecfFileName = PathResolverFindCalibFile( m_ecfRoIFile );
36  ATH_MSG_INFO("--- - CHECK ECF FILE NAME" << ecfFileName);
37  const std::string side0LUTFileName = PathResolverFindCalibFile( m_side0LUTFile );
38  ATH_MSG_INFO("--- - CHECK SIDE0 LUT FILE NAME" << side0LUTFileName);
39  const std::string side1LUTFileName = PathResolverFindCalibFile( m_side1LUTFile );
40  ATH_MSG_INFO("--- - INFO SIDE1 LUT FILE NAME" << side1LUTFileName);
41 
42  CHECK( m_l1topoLUT.initializeLUT(barrelFileName,
43  ecfFileName,
44  side0LUTFileName,
45  side1LUTFileName) );
46 
47  //return here while looking for fix for this
48  return StatusCode::SUCCESS;
49 
50  //this didn't work yet locally (offline). Waiting for feedback and should cleanup or reinclude soon.
51  //not critical; can run without it.
108 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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_alias_db

Gaudi::Property<std::string> MuCTPIPhase1ByteStreamAlgo::m_alias_db {this,"TriggerDBAlias","TRIGGERDB_RUN3","Alias to the TriggerDB to download CTP configuration from"}
private

Definition at line 59 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_barrelRoIFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_barrelRoIFile = "TrigConfMuctpi/Data_ROI_Mapping_Barrel_040422.txt"
private

Definition at line 65 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doTopo

Gaudi::Property<bool> MuCTPIPhase1ByteStreamAlgo::m_doTopo
private
Initial value:
{
this, "DoTopo", false, "Enable decoding/encoding MUCTPI Topo TOBs"}

Other properties.

Definition at line 62 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_ecfRoIFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_ecfRoIFile = "TrigConfMuctpi/Data_RoI_Mapping_EF_040422.txt"
private

Definition at line 66 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_l1topoLUT

LVL1MUCTPIPHASE1::L1TopoLUT MuCTPIPhase1ByteStreamAlgo::m_l1topoLUT
private

Helper members.

Definition at line 71 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_muctpi_Nbits

std::vector<uint32_t> MuCTPIPhase1ByteStreamAlgo::m_muctpi_Nbits = {3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1}
private

Definition at line 58 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_MuCTPI_Phase1_RDOKey

SG::WriteHandleKey<MuCTPI_Phase1_RDO> MuCTPIPhase1ByteStreamAlgo::m_MuCTPI_Phase1_RDOKey { this, "MuCTPI_Phase1_RDOKey", "MUCTPI_Phase1_RDO" }
private

Definition at line 56 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_robDataProviderSvc

ServiceHandle<IROBDataProviderSvc> MuCTPIPhase1ByteStreamAlgo::m_robDataProviderSvc { this, "ROBDataProviderSvc", "ROBDataProviderSvc", "ROB data provider"}
private

ROBDataProvider service handle.

Definition at line 54 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_robId

Gaudi::Property<uint32_t> MuCTPIPhase1ByteStreamAlgo::m_robId {this, "ROBID", 0x760000, "MuCTPI DAQ readout ROB ID"}
private

Object storing the various IDs of the MuCTPI fragment.

Definition at line 51 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_side0LUTFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_side0LUTFile = "TrigConfMuctpi/lookup_0_040422.json"
private

Definition at line 67 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_side1LUTFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_side1LUTFile = "TrigConfMuctpi/lookup_1_040422.json"
private

Definition at line 68 of file MuCTPIPhase1ByteStreamAlgo.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
LVL1::MuCTPIBits::WordType
WordType
Definition: HelpersPhase1.h:16
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
MuCTPIPhase1ByteStreamAlgo::m_l1topoLUT
LVL1MUCTPIPHASE1::L1TopoLUT m_l1topoLUT
Helper members.
Definition: MuCTPIPhase1ByteStreamAlgo.h:71
LVL1::MuCTPIBits::WordType::Candidate
@ Candidate
LVL1MUCTPIPHASE1::L1TopoLUT::getBarrelROI
unsigned short getBarrelROI(unsigned short side, unsigned short sector, unsigned short ieta, unsigned short iphi) const
Definition: L1TopoLUT.cxx:232
LVL1::MuCTPIBits::getDataStatusWordErrors
std::vector< size_t > getDataStatusWordErrors(uint32_t word)
Decode the data status word (returns a vector of bit indices for the errors set - empty if no errors)
Definition: HelpersPhase1.h:186
LVL1::MuCTPIBits::getWordType
constexpr WordType getWordType(uint32_t word)
Determine the type of a MUCTPI ROD word.
Definition: HelpersPhase1.h:64
header
Definition: hcg.cxx:526
LVL1::MuCTPIBits::maskedWord
constexpr uint32_t maskedWord(uint32_t word, uint32_t shift, uint32_t mask)
Extract sub-word from 32-bit word by applying a shift and a mask.
Definition: HelpersPhase1.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MuCTPIPhase1ByteStreamAlgo::m_robId
Gaudi::Property< uint32_t > m_robId
Object storing the various IDs of the MuCTPI fragment.
Definition: MuCTPIPhase1ByteStreamAlgo.h:51
MuCTPIPhase1ByteStreamAlgo::m_ecfRoIFile
const std::string m_ecfRoIFile
Definition: MuCTPIPhase1ByteStreamAlgo.h:66
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
LVL1::MuCTPIBits::WordType::Topo
@ Topo
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
MuCTPIPhase1ByteStreamAlgo::m_side1LUTFile
const std::string m_side1LUTFile
Definition: MuCTPIPhase1ByteStreamAlgo.h:68
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LVL1::MuCTPIBits::SubsysID::Endcap
@ Endcap
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
LVL1::MuCTPIBits::multiplicityWordNumber
constexpr uint32_t multiplicityWordNumber(uint32_t word)
Decode the index of the multitpicity word, which is 1, 2, or 3.
Definition: HelpersPhase1.h:154
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
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuCTPIPhase1ByteStreamAlgo::convert
StatusCode convert(const IROBDataProviderSvc::ROBF *rob, SG::WriteHandle< MuCTPI_Phase1_RDO > &outputHandle) const
Convert ROBFragment to MuCTPI_RDO.
Definition: MuCTPIPhase1ByteStreamAlgo.cxx:135
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
LVL1MUCTPIPHASE1::L1TopoLUT::getCoordinates
L1TopoCoordinates getCoordinates(const unsigned short &side, const unsigned short &subsystem, const unsigned short &sectorID, const unsigned short &roi) const
Definition: L1TopoLUT.cxx:218
LVL1::MuCTPIBits::SubsysID::Forward
@ Forward
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
MuCTPIPhase1ByteStreamAlgo::m_side0LUTFile
const std::string m_side0LUTFile
Definition: MuCTPIPhase1ByteStreamAlgo.h:67
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
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
LVL1::MuCTPIBits::Candidate
Definition: HelpersPhase1.h:215
IROBDataProviderSvc::VROBFRAG
std::vector< const ROBF * > VROBFRAG
Definition: IROBDataProviderSvc.h:27
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
LVL1::MuCTPIBits::timesliceHeader
constexpr auto timesliceHeader(uint32_t word)
Decode timeslice word.
Definition: HelpersPhase1.h:81
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
bcId
uint16_t bcId(uint32_t data)
Definition: TgcByteStreamData.h:326
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LVL1::MuCTPIBits::TopoTOB
Definition: HelpersPhase1.h:307
LVL1::MuCTPIBits::WordType::Multiplicity
@ Multiplicity
LVL1MUCTPIPHASE1::L1TopoCoordinates::eta
double eta
Definition: L1TopoLUT.h:30
MuCTPIPhase1ByteStreamAlgo::m_barrelRoIFile
const std::string m_barrelRoIFile
Definition: MuCTPIPhase1ByteStreamAlgo.h:65
LVL1::MuCTPIBits::WordType::Status
@ Status
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
LVL1::MuCTPIBits::RPCtoTGC_pt_map
const uint32_t RPCtoTGC_pt_map[7]
Definition: HelpersPhase1.h:20
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
a
TList * a
Definition: liststreamerinfos.cxx:10
h
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
MuCTPIPhase1ByteStreamAlgo::m_robDataProviderSvc
ServiceHandle< IROBDataProviderSvc > m_robDataProviderSvc
ROBDataProvider service handle.
Definition: MuCTPIPhase1ByteStreamAlgo.h:54
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LVL1::MuCTPIBits::Slice
Definition: HelpersPhase1.h:384
LVL1MUCTPIPHASE1::L1TopoCoordinates::phi
double phi
Definition: L1TopoLUT.h:31
LVL1MUCTPIPHASE1::L1TopoLUT::initializeLUT
bool initializeLUT(const std::string &barrelFileName, const std::string &ecfFileName, const std::string &side0LUTFileName, const std::string &side1LUTFileName)
Definition: L1TopoLUT.cxx:101
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
MuCTPIPhase1ByteStreamAlgo::m_MuCTPI_Phase1_RDOKey
SG::WriteHandleKey< MuCTPI_Phase1_RDO > m_MuCTPI_Phase1_RDOKey
Definition: MuCTPIPhase1ByteStreamAlgo.h:56
MuCTPIPhase1ByteStreamAlgo::m_muctpi_Nbits
std::vector< uint32_t > m_muctpi_Nbits
Definition: MuCTPIPhase1ByteStreamAlgo.h:58
LVL1::MuCTPIBits::WordType::Timeslice
@ Timeslice
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
LVL1::MuCTPIBits::SubsysID::Barrel
@ Barrel
keylayer_zslicemap.slices
slices
Definition: keylayer_zslicemap.py:112
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >