ATLAS Offline Software
L1TopoOnlineMonitor.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // Local includes
6 #include "L1TopoOnlineMonitor.h"
7 
8 // Trigger includes
11 #include "L1TopoRDO/Helpers.h"
12 #include "L1TopoRDO/L1TopoROD.h"
13 #include "L1TopoRDO/L1TopoFPGA.h"
14 #include "L1TopoRDO/L1TopoResult.h"
15 
16 // System includes
17 #include <utility>
18 
19 
20 // Local helper constants and functions
21 namespace {
23  template<size_t N>
24  std::vector<size_t> bitsetIndices(const std::bitset<N>& bits) {
25  std::vector<size_t> indices;
26  indices.reserve(bits.count());
27  for (size_t i=0; i<bits.size(); ++i) {
28  if (bits[i]) indices.push_back(i);
29  }
30  return indices;
31  }
32 }
33 
34 // =============================================================================
35 // Standard constructor
36 // =============================================================================
37 L1TopoOnlineMonitor::L1TopoOnlineMonitor(const std::string& name, ISvcLocator* svcLoc)
38  : AthMonitorAlgorithm(name, svcLoc),
39  m_ctpIds(0)
40 {}
41 
42 // =============================================================================
43 // Implementation of AthReentrantAlgorithm::initialize
44 // =============================================================================
46 
47  m_rateHdwNotSim.reset(new float[s_nTopoCTPOutputs]);
48  m_rateSimNotHdw.reset(new float[s_nTopoCTPOutputs]);
49  m_rateHdwAndSim.reset(new float[s_nTopoCTPOutputs]);
50  m_rateHdwSim.reset(new float[s_nTopoCTPOutputs]);
51  m_countHdwNotSim.reset(new float[s_nTopoCTPOutputs]);
52  m_countSimNotHdw.reset(new float[s_nTopoCTPOutputs]);
53  m_countHdwSim.reset(new float[s_nTopoCTPOutputs]);
54  m_countHdw.reset(new float[s_nTopoCTPOutputs]);
55  m_countSim.reset(new float[s_nTopoCTPOutputs]);
56  m_countAny.reset(new float[s_nTopoCTPOutputs]);
60  m_overflow_rateHdwSim.reset(new float[s_nTopoCTPOutputs]);
63  m_overflow_countHdwSim.reset(new float[s_nTopoCTPOutputs]);
64  m_overflow_countHdw.reset(new float[s_nTopoCTPOutputs]);
65  m_overflow_countSim.reset(new float[s_nTopoCTPOutputs]);
66  m_overflow_countAny.reset(new float[s_nTopoCTPOutputs]);
67 
68  m_currentHdwBit.reset(new float[s_nTopoCTPOutputs]);
69  m_currentSimBit.reset(new float[s_nTopoCTPOutputs]);
70 
71  for (size_t i=0;i<s_nTopoCTPOutputs;i++){
72  m_rateHdwNotSim[i] = 0;
73  m_rateSimNotHdw[i] = 0;
74  m_rateHdwAndSim[i] = 0;
75  m_rateHdwSim[i] = 0;
76  m_countHdwNotSim[i] = 0;
77  m_countSimNotHdw[i] = 0;
78  m_countHdwSim[i] = 0;
79  m_countHdw[i] = 0;
80  m_countSim[i] = 0;
81  m_countAny[i] = 0;
92 
93  m_currentHdwBit[i] = 0;
94  m_currentSimBit[i] = 0;
95  }
96 
97  ATH_CHECK(m_l1topoKey.initialize());
100  ATH_CHECK(m_monTool.retrieve(DisableTool{m_monTool.name().empty()}));
101  ATH_CHECK(m_errorFlagsKey.initialize());
102 
103  const TrigConf::L1Menu * l1menu = nullptr;
104  ATH_CHECK( m_detStore->retrieve(l1menu) );
105 
106  auto & conn2EL = l1menu->connector("Topo2El");
107  auto & conn3EL = l1menu->connector("Topo3El");
108 
109  auto & connOpt0 = l1menu->connector("Topo1Opt0");
110  auto & connOpt1 = l1menu->connector("Topo1Opt1");
111  auto & connOpt2 = l1menu->connector("Topo1Opt2");
112  auto & connOpt3 = l1menu->connector("Topo1Opt3");
113 
114  m_TopoAlgTriggerNames.reserve(32*4);
115  m_TopoAlgTriggerNotVetoed.resize(32*4);
116  m_TopoMultTriggerNames.reserve(64*4);
117  m_TopoMultTriggerNotVetoed.resize(64*4);
118 
119  //TopoOpt
120  auto & tlopt0 = connOpt0.triggerLines();
121  auto & tlopt1 = connOpt1.triggerLines();
122  auto & tlopt2 = connOpt2.triggerLines();
123  auto & tlopt3 = connOpt3.triggerLines();
124 
125  long unsigned int size_tlopt0 = tlopt0.size();
126  long unsigned int size_tlopt1 = tlopt1.size();
127  long unsigned int size_tlopt2 = tlopt2.size();
128  long unsigned int size_tlopt3 = tlopt3.size();
129 
130  long unsigned int total_size_opt = size_tlopt0+size_tlopt1+size_tlopt2+size_tlopt3;
131 
132  for (size_t j = 0; j < size_tlopt0; ++j) m_TopoMultTriggerNames.push_back(tlopt0[j].name());
133  for (size_t j = 0; j < size_tlopt1; ++j) m_TopoMultTriggerNames.push_back(tlopt1[j].name());
134  for (size_t j = 0; j < size_tlopt2; ++j) m_TopoMultTriggerNames.push_back(tlopt2[j].name());
135  for (size_t j = 0; j < size_tlopt3; ++j) m_TopoMultTriggerNames.push_back(tlopt3[j].name());
136 
137  //Topo2a
138  auto & tl2a0 = conn2EL.triggerLines(0, 0); //clock 0
139  auto & tl2a1 = conn2EL.triggerLines(0, 1); //clock 1
140  long unsigned int size_tl2a0 = tl2a0.size();
141  long unsigned int size_tl2a1 = tl2a1.size();
142  //Topo2b
143  auto & tl2b0 = conn2EL.triggerLines(1, 0); //clock 0
144  auto & tl2b1 = conn2EL.triggerLines(1, 1); //clock 1
145  long unsigned int size_tl2b0 = tl2b0.size();
146  long unsigned int size_tl2b1 = tl2b1.size();
147  //Topo3a
148  auto & tl3a0 = conn3EL.triggerLines(0, 0); //clock 0
149  auto & tl3a1 = conn3EL.triggerLines(0, 1); //clock 1
150  long unsigned int size_tl3a0 = tl3a0.size();
151  long unsigned int size_tl3a1 = tl3a1.size();
152  //Topo3b
153  auto & tl3b0 = conn3EL.triggerLines(1, 0); //clock 0
154  auto & tl3b1 = conn3EL.triggerLines(1, 1); //clock 1
155  long unsigned int size_tl3b0 = tl3b0.size();
156  long unsigned int size_tl3b1 = tl3b1.size();
157 
158  for (size_t i = 0; i < 16; ++i) {
159  if (i < size_tl2a0) m_TopoAlgTriggerNames.push_back(tl2a0[i].name());
160  else m_TopoAlgTriggerNames.push_back("Empty");
161  if (i < size_tl2a1) m_TopoAlgTriggerNames.push_back(tl2a1[i].name());
162  else m_TopoAlgTriggerNames.push_back("Empty");
163  }
164 
165  for (size_t i = 0; i < 16; ++i) {
166  if (i < size_tl2b0) m_TopoAlgTriggerNames.push_back(tl2b0[i].name());
167  else m_TopoAlgTriggerNames.push_back("Empty");
168  if (i < size_tl2b1) m_TopoAlgTriggerNames.push_back(tl2b1[i].name());
169  else m_TopoAlgTriggerNames.push_back("Empty");
170  }
171 
172  for (size_t i = 0; i < 16; ++i) {
173  if (i < size_tl3a0) m_TopoAlgTriggerNames.push_back(tl3a0[i].name());
174  else m_TopoAlgTriggerNames.push_back("Empty");
175  if (i < size_tl3a1) m_TopoAlgTriggerNames.push_back(tl3a1[i].name());
176  else m_TopoAlgTriggerNames.push_back("Empty");
177  }
178 
179  for (size_t i = 0; i < 16; ++i) {
180  if (i < size_tl3b0) m_TopoAlgTriggerNames.push_back(tl3b0[i].name());
181  else m_TopoAlgTriggerNames.push_back("Empty");
182  if (i < size_tl3b1) m_TopoAlgTriggerNames.push_back(tl3b1[i].name());
183  else m_TopoAlgTriggerNames.push_back("Empty");
184  }
185 
186  //Fill Vector of booleans to fill corresponding triggers
187  //Only elements with a corresponding Veto are set to false
188 
189  for (size_t j = 0; j < total_size_opt; ++j) {
190  m_TopoMultTriggerNotVetoed[j] = true;
191  for (const std::string& VetoedElement : m_MultiplicityVetoList) {
192  if ( !m_TopoMultTriggerNotVetoed[j] || m_TopoMultTriggerNames[j].find(VetoedElement)!= std::string::npos) m_TopoMultTriggerNotVetoed[j] = false;
193  else m_TopoMultTriggerNotVetoed[j] = true;
194  }
195  }
196 
197  for (int j =0; j<128;j++){
198  m_TopoAlgTriggerNotVetoed[j] = true;
199  for (const std::string& VetoedElement : m_AlgorithmVetoList) {
200  if ( !m_TopoAlgTriggerNotVetoed[j] || m_TopoAlgTriggerNames[j].find(VetoedElement)!= std::string::npos) m_TopoAlgTriggerNotVetoed[j] = false;
201  else m_TopoAlgTriggerNotVetoed[j] = true;
202  }
203  }
204 
206 }
207 
209 
210  const TrigConf::L1Menu * l1menu = nullptr;
211  ATH_CHECK( m_detStore->retrieve(l1menu) );
212 
214 
216 
217  return StatusCode::SUCCESS;
218 }
219 
220 
221 StatusCode L1TopoOnlineMonitor::fillHistograms( const EventContext& ctx ) const {
222 
223  // Create and record the ErrorFlags container
225  ATH_CHECK(errorFlagsCont.record(std::make_unique<xAOD::TrigCompositeContainer>(),
226  std::make_unique<xAOD::TrigCompositeAuxContainer>()));
227  ATH_MSG_DEBUG("Recorded TrigCompositeContainer with key " << m_errorFlagsKey.key());
228 
229  // Create the ErrorFlags object
230  errorFlagsCont->push_back(new xAOD::TrigComposite);
231  xAOD::TrigComposite& errorFlags = *(errorFlagsCont->back());
232  resetFlags(errorFlags);
233 
234 
235  DecisionBits decisionBits{};
236  enum class MonFunction : uint8_t {doSimMon=0, doHwMonCTP, doHwMon, doComp, doMultComp};
237  std::vector<uint8_t> failedMonFunctions;
238  std::vector<std::vector<unsigned>> multWeightsSim;
239  std::vector<std::vector<unsigned>> multWeightsHdw;
240 
241  if (m_doHwMon) {
242  StatusCode sc = doHwMon(decisionBits,multWeightsHdw,ctx);
243  ATH_MSG_DEBUG("Executed doHWMon: " << (sc.isFailure() ? "failed" : "ok"));
244  if (sc.isFailure()) {
245  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doHwMon));
246  }
247  }
248 
249  if (m_doHwMonCTP) {
250  StatusCode sc = doHwMonCTP(decisionBits,ctx);
251  ATH_MSG_DEBUG("Executed doHWMonCTP: " << (sc.isFailure() ? "failed" : "ok"));
252  if (sc.isFailure()) {
253  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doHwMonCTP));
254  }
255  }
256 
257  if (m_doSimMon) {
258  StatusCode sc = doSimMon(decisionBits,multWeightsSim,ctx);
259  ATH_MSG_DEBUG("Executed doSimMon: " << (sc.isFailure() ? "failed" : "ok"));
260  if (sc.isFailure()) {
261  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doSimMon));
262  }
263  }
264 
265  if (m_doComp) {
266  StatusCode sc = doComp(decisionBits,ctx);
267  ATH_MSG_DEBUG("Executed doComp: " << (sc.isFailure() ? "failed" : "ok"));
268  if (sc.isFailure()) {
269  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doComp));
270  }
271  }
272 
273  if (m_doMultComp) {
274  StatusCode sc = doMultComp(multWeightsSim,multWeightsHdw,ctx);
275  ATH_MSG_DEBUG("Executed doMultComp: " << (sc.isFailure() ? "failed" : "ok"));
276  if (sc.isFailure()) {
277  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doMultComp));
278  }
279  }
280 
281  auto monFailedMonFunctions = Monitored::Collection("MonitoringFailures", failedMonFunctions);
282  Monitored::Group(m_monTool, monFailedMonFunctions);
283 
284  return StatusCode::SUCCESS;
285 }
286 
287 
288 StatusCode L1TopoOnlineMonitor::doSimMon( DecisionBits& decisionBits, std::vector<std::vector<unsigned>> &multWeights, const EventContext& ctx ) const {
289 
290 
292  if(!cont.isValid()){
293  ATH_MSG_FATAL("Could not retrieve L1Topo EDM Container from the Simulation.");
294  return StatusCode::FAILURE;
295  }
296 
297  ATH_MSG_DEBUG("----got L1Topo container: " << cont.key());
298 
299  std::bitset<s_nTopoCTPOutputs>& triggerBitsSim = DecisionBits::createBits(decisionBits.triggerBitsSim);
300  std::bitset<s_nTopoCTPOutputs>& overflowBitsSim = DecisionBits::createBits(decisionBits.overflowBitsSim);
301  std::bitset<s_nTopoCTPOutputs>& ambiguityBitsSim = DecisionBits::createBits(decisionBits.ambiguityBitsSim);
302  std::unordered_map<unsigned,std::bitset<s_nTopoCTPOutputs>> multWeightsMap;
303  for(const auto l1topo_dec : * cont){
304  ATH_MSG_DEBUG( "Reading L1Topo EDM:: Connection ID: " << l1topo_dec->connectionId() << " Clock: " << l1topo_dec->clock() << " Bit-length: " << l1topo_dec->bitWidth() << " Word: " << l1topo_dec->topoWord() << " Word64: " << l1topo_dec->topoWord64() );
305 
306  if (l1topo_dec->bitWidth() == 32) {
307  std::vector<unsigned> topoword;
308  std::vector<unsigned> topowordOverflow;
309  for(unsigned int i=0; i<32; ++i) {
310  uint32_t mask = 0x1; mask <<= i;
311  if ((l1topo_dec->topoWord() & mask) !=0) {
312  if (l1topo_dec->connectionId()==2 || l1topo_dec->connectionId()==3) { // TOPO2EL and TOPO3EL (L1TopoCommon/Types.h)
313  topoword.push_back(32*l1topo_dec->clock()+i);
314  uint32_t pos = 32*(l1topo_dec->clock()+(l1topo_dec->connectionId()==2 ? 0 : 2))+i;
315  triggerBitsSim[pos] = ((!decisionBits.triggerBits.has_value() || m_forceCTPasHdw) && m_ctpIds[pos]>=512) ? false : true;
316  }
317  if (l1topo_dec->connectionId()==22 || l1topo_dec->connectionId()==23) { // AMBIGUITYTOPO2EL and AMBIGUITYTOPO3EL
318  uint32_t pos_ambiguity = 32*(l1topo_dec->clock()+(l1topo_dec->connectionId()==22 ? 0 : 2))+i;
319  ambiguityBitsSim[pos_ambiguity] = ((!decisionBits.ambiguityBitsSim.has_value() || m_forceCTPasHdw) && m_ctpIds[pos_ambiguity]>=512) ? false : true;
320  }
321  }
322  if ((l1topo_dec->topoWordOverflow() & mask) !=0) {
323  topowordOverflow.push_back(32*l1topo_dec->clock()+i);
324  uint32_t pus = 32*(l1topo_dec->clock()+(l1topo_dec->connectionId()==12 ? 0 : 2))+i;
325  overflowBitsSim[pus] = ((!decisionBits.overflowBitsSim.has_value() || m_forceCTPasHdw) && m_ctpIds[pus]>=512) ? false : true;
326  }
327  }
328  std::string name = "CableElec_";
329  name += std::to_string(l1topo_dec->connectionId());
330  auto monTopoDec = Monitored::Collection(name, topoword);
331  Monitored::Group(m_monTool,monTopoDec);
332  }
333  else if (l1topo_dec->bitWidth() == 64) {
334  for (size_t i=0;i<64;i++) {
335  unsigned index = i+l1topo_dec->clock()*64;
336  uint64_t mask = 0x1; mask <<= i;
337  if ((l1topo_dec->topoWord64() & mask) !=0) {
338  multWeightsMap[static_cast<unsigned>(l1topo_dec->connectionId() - 4)].set(index);
339  }
340  }
341  }
342  else {
343  ATH_MSG_DEBUG( "Unknown Bit-length: " << l1topo_dec->bitWidth() );
344  return StatusCode::FAILURE;
345  }
346  }
347 
348  for (unsigned key=0;key<4;key++) {
349  std::vector<unsigned> vecCount, vecIndices;
350  unsigned indices = 0;
351  for (auto startbit : m_startbit[key]) {
352  unsigned count = 0;
353  for (size_t i=0;i<startbit.second;i++){
354  if (multWeightsMap[key][startbit.first+i]) {
355  count += 1 * pow(2,i);
356  }
357  }
358  vecCount.push_back(count);
359  vecIndices.push_back(indices);
360  indices++;
361  }
362  multWeights.push_back(vecCount);
363  std::string name = "CableOpti_"+std::to_string(key);
364  auto monMult = Monitored::Collection(name, vecIndices);
365  auto monMultWeight = Monitored::Collection(name+"_weight", vecCount);
366  Monitored::Group(m_monTool,monMult,monMultWeight);
367  }
368 
369  std::vector<size_t> triggerBitIndicesSim = bitsetIndices(triggerBitsSim);
370  std::vector<size_t> overflowBitIndicesSim = bitsetIndices(overflowBitsSim);
371  std::vector<size_t> ambiguityBitIndicesSim = bitsetIndices(ambiguityBitsSim);
372  auto monTopoSim = Monitored::Collection("TopoSim", triggerBitIndicesSim);
373  auto monTopoSimOverflow = Monitored::Collection("TopoSim_overflows", overflowBitIndicesSim);
374  auto monTopoSimAmbiguity = Monitored::Collection("TopoSim_ambiguity", ambiguityBitIndicesSim);
375  Monitored::Group(m_monTool,monTopoSim);
376  Monitored::Group(m_monTool,monTopoSimOverflow);
377  Monitored::Group(m_monTool,monTopoSimAmbiguity);
378 
379  return StatusCode::SUCCESS;
380 }
381 
382 StatusCode L1TopoOnlineMonitor::doHwMonCTP( DecisionBits& decisionBits, const EventContext& ctx ) const {
383 
384  // Retrieve CTP DAQ data for comparison
386  if (!ctpRdo.isValid()) {
387  ATH_MSG_DEBUG("Failed to retrieve CTP_RDO object (converted from CTP DAQ ROB) with key \""
388  << m_ctpRdoKey.key() << "\". Skipping CTP hardware comparison");
389  return StatusCode::FAILURE;
390  }
391 
392  // CTP RDO contains 17 TBP words for a number of BCs, so use CTP_Decoder to access accepted BC
394  ctp.setRDO(ctpRdo.cptr());
395  const uint32_t l1aPos = ctpRdo->getL1AcceptBunchPosition();
396  if (l1aPos >= ctp.getBunchCrossings().size()) {
397  ATH_MSG_DEBUG("CTP_RDO gave invalid l1aPos. Skipping CTP hardware comparison");
398  return StatusCode::FAILURE;
399  }
400  ATH_MSG_DEBUG("CTP l1aPos, size: " << l1aPos << ", " << ctp.getBunchCrossings().size());
401  const CTP_BC& ctpL1a = ctp.getBunchCrossings().at(l1aPos);
402 
403  // Fill decision bits from CTP RDO
404  std::bitset<s_nTopoCTPOutputs>& triggerBitsCtp = DecisionBits::createBits(decisionBits.triggerBitsCtp);
405  static constexpr size_t ctpTBPSize{512};
406  const std::bitset<ctpTBPSize>& tbp = ctpL1a.getTBP();
407  ATH_MSG_VERBOSE("CTP TBP bits: " << tbp.to_string());
408 
409  for (size_t i=0; i<s_nTopoCTPOutputs; ++i) {
410  if (m_ctpIds[i] < 512)
411  {triggerBitsCtp[i] = tbp.test(m_ctpIds[i]);}
412  else
413  {triggerBitsCtp[i] = false;}
414  }
415 
416  std::vector<size_t> triggerBitIndicesCtp = bitsetIndices(triggerBitsCtp);
417  auto monTopoCtp = Monitored::Collection("TopoCTP", triggerBitIndicesCtp);
418  Monitored::Group(m_monTool,monTopoCtp);
419 
420  return StatusCode::SUCCESS;
421 }
422 
423 StatusCode L1TopoOnlineMonitor::doHwMon( DecisionBits& decisionBits, std::vector<std::vector<unsigned>> &multWeights, const EventContext& ctx ) const {
424 
426  if(!cont.isValid()){
427  ATH_MSG_WARNING("Could not retrieve L1Topo RAW Data Container from the BS data.");
428  return StatusCode::FAILURE;
429  }
430 
431  ATH_MSG_DEBUG("----got L1Topo Raw Data container: " << cont.key());
432 
433  std::bitset<s_nTopoCTPOutputs>& triggerBits = DecisionBits::createBits(decisionBits.triggerBits);
434  std::bitset<s_nTopoCTPOutputs>& overflowBits = DecisionBits::createBits(decisionBits.overflowBits);
435 
436  std::unique_ptr<L1Topo::L1TopoResult> l1topoResult = std::make_unique<L1Topo::L1TopoResult>(*cont);
437  if (!l1topoResult->getStatus()) {
438  ATH_MSG_WARNING("Decoding L1Topo results failed!!");
439  return StatusCode::FAILURE;
440  }
441 
442  if (m_doHwErrorMon){
443  // Error monitoring ---------------------------------------------------------
444  enum class MonFunction : uint8_t {doRODct, doRODpc, doRODhc, doRODpe, doRODlm, doRODhm, doRODpt};
445  std::vector<uint8_t> rodErrors;
446  if (l1topoResult->getROD(0)->ct() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODct)); }
447  if (l1topoResult->getROD(0)->pc() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODpc)); }
448  if (l1topoResult->getROD(0)->hc() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODhc)); }
449  if (l1topoResult->getROD(0)->pe() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODpe)); }
450  if (l1topoResult->getROD(0)->lm() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODlm)); }
451  if (l1topoResult->getROD(0)->hm() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODhm)); }
452  if (l1topoResult->getROD(0)->pt() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODpt)); }
453  auto monErrorsROD = Monitored::Collection("ROD_Errors", rodErrors);
454  Monitored::Group(m_monTool, monErrorsROD);
455  }
456 
457  for (unsigned i=0;i<l1topoResult->getFPGASize();i++) {
458  unsigned topoNumber = l1topoResult->getFPGA(i)->topoNumber();
459  unsigned fpgaNumber = l1topoResult->getFPGA(i)->fpgaNumber();
460 
461  auto mon_fpga_error = Monitored::Scalar<unsigned>("FPGA_Errors");
462  auto mon_fpga_labels = Monitored::Scalar("FPGA_Labels", (topoNumber*2)-fpgaNumber-1);
463 
464  if (l1topoResult->getFPGA(i)->ct() != 0) {
465  mon_fpga_error = 0;
466  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
467  }
468  if (l1topoResult->getFPGA(i)->sm() != 0) {
469  mon_fpga_error = 1;
470  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
471  }
472  if (l1topoResult->getFPGA(i)->pe() != 0) {
473  mon_fpga_error = 2;
474  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
475  }
476  if (l1topoResult->getFPGA(i)->lm() != 0) {
477  mon_fpga_error = 3;
478  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
479  }
480  if (l1topoResult->getFPGA(i)->hm() != 0) {
481  mon_fpga_error = 4;
482  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
483  }
484  if (l1topoResult->getFPGA(i)->pt() != 0) {
485  mon_fpga_error = 5;
486  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
487  }
488  }
489 
490  // Multiplicities ---------------------------------------------------------
491  std::vector<unsigned> topo1Opt0,topo1Opt1,topo1Opt2,topo1Opt3;
492  std::vector<unsigned> topo1Opt0Indices,topo1Opt1Indices,topo1Opt2Indices,topo1Opt3Indices;
493 
494  unsigned indices=0;
495  for (auto startbit : m_startbit[0]) {
496  unsigned count = 0;
497  for (size_t i=0;i<startbit.second;i++){
498  if (l1topoResult->getTopo1Opt0()[startbit.first+i]) {
499  count += 1 * pow(2,i);
500  }
501  }
502  topo1Opt0.push_back(count);
503  topo1Opt0Indices.push_back(indices);
504  indices++;
505  }
506  indices=0;
507  for (auto startbit : m_startbit[1]) {
508  unsigned count = 0;
509  for (size_t i=0;i<startbit.second;i++){
510  if (l1topoResult->getTopo1Opt1()[startbit.first+i]) {
511  count += 1 * pow(2,i);
512  }
513  }
514  topo1Opt1.push_back(count);
515  topo1Opt1Indices.push_back(indices);
516  indices++;
517  }
518  indices=0;
519  for (auto startbit : m_startbit[2]) {
520  unsigned count = 0;
521  for (size_t i=0;i<startbit.second;i++){
522  if (l1topoResult->getTopo1Opt2()[startbit.first+i]) {
523  count += 1 * pow(2,i);
524  }
525  }
526  topo1Opt2.push_back(count);
527  topo1Opt2Indices.push_back(indices);
528  indices++;
529  }
530  indices=0;
531  for (auto startbit : m_startbit[3]) {
532  unsigned count = 0;
533  for (size_t i=0;i<startbit.second;i++){
534  if (l1topoResult->getTopo1Opt3()[startbit.first+i]) {
535  count += 1 * pow(2,i);
536  }
537  }
538  topo1Opt3.push_back(count);
539  topo1Opt3Indices.push_back(indices);
540  indices++;
541  }
542 
543  auto monTopo1Opt0 = Monitored::Collection("HdwTopo1Opt0", topo1Opt0Indices);
544  auto monTopo1Opt0Weight = Monitored::Collection("HdwTopo1Opt0_weight", topo1Opt0);
545  Monitored::Group(m_monTool, monTopo1Opt0, monTopo1Opt0Weight);
546  multWeights.push_back(topo1Opt0);
547 
548  auto monTopo1Opt1 = Monitored::Collection("HdwTopo1Opt1", topo1Opt1Indices);
549  auto monTopo1Opt1Weight = Monitored::Collection("HdwTopo1Opt1_weight", topo1Opt1);
550  Monitored::Group(m_monTool, monTopo1Opt1, monTopo1Opt1Weight);
551  multWeights.push_back(topo1Opt1);
552 
553  auto monTopo1Opt2 = Monitored::Collection("HdwTopo1Opt2", topo1Opt2Indices);
554  auto monTopo1Opt2Weight = Monitored::Collection("HdwTopo1Opt2_weight", topo1Opt2);
555  Monitored::Group(m_monTool, monTopo1Opt2, monTopo1Opt2Weight);
556  multWeights.push_back(topo1Opt2);
557 
558  auto monTopo1Opt3 = Monitored::Collection("HdwTopo1Opt3", topo1Opt3Indices);
559  auto monTopo1Opt3Weight = Monitored::Collection("HdwTopo1Opt3_weight", topo1Opt3);
560  Monitored::Group(m_monTool, monTopo1Opt3, monTopo1Opt3Weight);
561  multWeights.push_back(topo1Opt3);
562 
563  // Decisions ---------------------------------------------------------------
564  triggerBits = l1topoResult->getDecisions();
565  overflowBits = l1topoResult->getOverflows();
566 
567  const std::vector<size_t> triggerBitIndicesHdw = bitsetIndices(triggerBits);
568  const std::vector<size_t> overflowBitIndicesHdw = bitsetIndices(overflowBits);
569 
570  ATH_MSG_VERBOSE("trigger bits: " << triggerBits.to_string() );
571  ATH_MSG_VERBOSE("overflow bits: " << overflowBits.to_string() );
572 
573  auto monHdw = Monitored::Collection("HdwResults", triggerBitIndicesHdw);
574  auto monOverflow = Monitored::Collection("OverflowResults", overflowBitIndicesHdw);
575 
576  Monitored::Group(m_monTool, monHdw, monOverflow);
577 
578  return StatusCode::SUCCESS;
579 }
580 
581 StatusCode L1TopoOnlineMonitor::doComp( DecisionBits& decisionBits, const EventContext& ctx ) const {
582  if (!decisionBits.triggerBitsSim.has_value()) {
583  ATH_MSG_DEBUG("Simulation bits not set. Skipping simulation to hardware comparison");
584  return StatusCode::FAILURE;
585  }
586 
587  std::bitset<s_nTopoCTPOutputs> triggerBitsSim = decisionBits.triggerBitsSim.value(); // Alias
588  std::bitset<s_nTopoCTPOutputs> triggerBitsHdw;
589 
590  if (decisionBits.triggerBits.has_value() && !m_forceCTPasHdw)
591  {triggerBitsHdw = decisionBits.triggerBits.value();}
592  else if (decisionBits.triggerBitsCtp.has_value())
593  {triggerBitsHdw = decisionBits.triggerBitsCtp.value();}
594  else {
595  ATH_MSG_DEBUG("Hardware bits not set. Skipping simulation to hardware comparison");
596  return StatusCode::FAILURE;
597  }
598 
599  std::bitset<s_nTopoCTPOutputs> triggerBitsSimNotHdw = triggerBitsSim & (~triggerBitsHdw);
600  std::bitset<s_nTopoCTPOutputs> triggerBitsHdwNotSim = triggerBitsHdw & (~triggerBitsSim);
601  std::bitset<s_nTopoCTPOutputs> triggerBitsHdwSim = triggerBitsHdw & triggerBitsSim;
602  std::bitset<s_nTopoCTPOutputs> triggerBitsAny = triggerBitsHdw | triggerBitsSim;
603 
604  std::bitset<s_nTopoCTPOutputs>& overflowBitsSim = decisionBits.overflowBitsSim.value();
605  std::bitset<s_nTopoCTPOutputs>& overflowBitsHdw = decisionBits.overflowBits.value();
606  std::bitset<s_nTopoCTPOutputs> overflowBitsSimNotHdw = overflowBitsSim & (~overflowBitsHdw);
607  std::bitset<s_nTopoCTPOutputs> overflowBitsHdwNotSim = overflowBitsHdw & (~overflowBitsSim);
608  std::bitset<s_nTopoCTPOutputs> overflowBitsHdwSim = overflowBitsHdw & overflowBitsSim;
609  std::bitset<s_nTopoCTPOutputs> overflowBitsAny = overflowBitsHdw | overflowBitsSim;
610 
611  std::bitset<s_nTopoCTPOutputs>& ambiguityBitsSim = decisionBits.ambiguityBitsSim.value();
612  std::bitset<s_nTopoCTPOutputs> ambiguitySimANDHdw = ambiguityBitsSim & triggerBitsHdwSim;
613  std::bitset<s_nTopoCTPOutputs> ambiguityMismatch = ambiguityBitsSim & (triggerBitsSimNotHdw | triggerBitsHdwNotSim);
614 
615  std::vector<size_t> triggerBitIndicesSimNotHdw = bitsetIndices(triggerBitsSimNotHdw);
616  std::vector<size_t> triggerBitIndicesHdwNotSim = bitsetIndices(triggerBitsHdwNotSim);
617  std::vector<size_t> ambiguitySimANDHdwBitIndices = bitsetIndices(ambiguitySimANDHdw);
618  std::vector<size_t> ambiguityMismatchBitIndices = bitsetIndices(ambiguityMismatch);
619  auto monSimNotHdw = Monitored::Collection("SimNotHdwL1TopoResult", triggerBitIndicesSimNotHdw);
620  auto monHdwNotSim = Monitored::Collection("HdwNotSimL1TopoResult", triggerBitIndicesHdwNotSim);
621  auto monAmbiguitySimANDHdw = Monitored::Collection("Ambiguity_SimANDHdwDecisions", ambiguitySimANDHdwBitIndices);
622  auto monAmbiguityMismatch = Monitored::Collection("Ambiguity_DecisionMismatches", ambiguityMismatchBitIndices);
623 
624  Monitored::Group(m_monTool, monSimNotHdw, monHdwNotSim, monAmbiguitySimANDHdw, monAmbiguityMismatch);
625 
626  float rate=0;
627  float rate_overflow=0;
628 
629  auto lbn = Monitored::Scalar<int>("LBN",GetEventInfo(ctx)->lumiBlock());
630  auto mon_trig_allboards = Monitored::Scalar<unsigned>("L1TopoAlgorithmAllBoards");
631  auto mon_matchVsLumi_DQ = Monitored::Scalar<unsigned>("L1TopoAlgorithmMissMatchVsLumi");
632 
633  for (size_t i=0;i<4;i++) {
634 
635  auto mon_trig = Monitored::Scalar<unsigned>("Phase1TopoTrigger_"+std::to_string(i));
636  auto mon_match = Monitored::Scalar<unsigned>("Phase1TopoMissMatch_"+std::to_string(i));
637  auto mon_match_DQ = Monitored::Scalar<unsigned>("L1TopoAlgorithmMissMatch_"+std::to_string(i));
638  auto mon_match_OF_DQ = Monitored::Scalar<unsigned>("L1TopoAlgorithmOverflowMissMatch_"+std::to_string(i));
639  auto mon_weight = Monitored::Scalar<float>("Phase1TopoWeight_"+std::to_string(i));
640  auto mon_OFweight = Monitored::Scalar<float>("Phase1TopoOFWeight_"+std::to_string(i));
641 
642  for (size_t j=0;j<32;j++) {
643 
644  if (ambiguityBitsSim[32*i+j] == 0) {
645  mon_trig = static_cast<unsigned>(j);
646  mon_trig_allboards = static_cast<unsigned>(32*i+j);
647  if (overflowBitsHdw[32*i+j] == 1 || overflowBitsSim[32*i+j] == 1) {
648  m_overflow_countHdwNotSim[32*i+j]+=overflowBitsHdwNotSim[32*i+j];
649  m_overflow_countSimNotHdw[32*i+j]+=overflowBitsSimNotHdw[32*i+j];
650  m_overflow_countHdwSim[32*i+j]+=overflowBitsHdwSim[32*i+j];
651  m_overflow_countHdw[32*i+j]+=overflowBitsHdw[32*i+j];
652  m_overflow_countSim[32*i+j]+=overflowBitsSim[32*i+j];
653  m_overflow_countAny[32*i+j]+=overflowBitsAny[32*i+j];
654  }
655  else {
656  m_countHdwNotSim[32*i+j]+=triggerBitsHdwNotSim[32*i+j];
657  m_countSimNotHdw[32*i+j]+=triggerBitsSimNotHdw[32*i+j];
658  m_countHdwSim[32*i+j]+=triggerBitsHdwSim[32*i+j];
659  m_countHdw[32*i+j]+=triggerBitsHdw[32*i+j];
660  m_countSim[32*i+j]+=triggerBitsSim[32*i+j];
661  m_countAny[32*i+j]+=triggerBitsAny[32*i+j];
662  m_currentHdwBit[32*i+j]=triggerBitsHdw[32*i+j];
663  m_currentSimBit[32*i+j]=triggerBitsSim[32*i+j];
664  }
665 
666  //Simplified plot for L1Calo DQ
667  if ( m_currentSimBit[32*i+j] < m_currentHdwBit[32*i+j] ){ mon_match_DQ = 0; mon_matchVsLumi_DQ = 1;}
668  if ( m_currentSimBit[32*i+j] > m_currentHdwBit[32*i+j] ){ mon_match_DQ = 1; mon_matchVsLumi_DQ = 1;}
669  if ( m_currentSimBit[32*i+j] == m_currentHdwBit[32*i+j] ){ mon_match_DQ = 2; mon_matchVsLumi_DQ = 0;}
670  if ( (m_currentSimBit[32*i+j] > 0 || m_currentHdwBit[32*i+j] > 0 ) && m_TopoAlgTriggerNotVetoed[32*i+j] ){
671  Monitored::Group(m_monTool, mon_trig, mon_match_DQ);
672  Monitored::Group(m_monTool, lbn, mon_trig_allboards, mon_matchVsLumi_DQ);
673  }
674 
675  if (m_overflow_countSim[32*i+j] <m_overflow_countHdw[32*i+j] ) mon_match_OF_DQ = 0;
676  if (m_overflow_countSim[32*i+j] >m_overflow_countHdw[32*i+j] ) mon_match_OF_DQ = 1;
677  if (m_overflow_countSim[32*i+j] ==m_overflow_countHdw[32*i+j] ) mon_match_OF_DQ = 2;
678  if ( (m_overflow_countSim[32*i+j] > 0 || m_overflow_countHdw[32*i+j] > 0 ) && m_TopoAlgTriggerNotVetoed[32*i+j] ) Monitored::Group(m_monTool, mon_trig, mon_match_OF_DQ);
679 
680  rate = m_countHdw[32*i+j]>0 ? m_countHdwNotSim[32*i+j]/m_countHdw[32*i+j] : 0;
681  if (rate != m_rateHdwNotSim[32*i+j]) {
682  mon_match = 0;
683  mon_weight = rate-m_rateHdwNotSim[32*i+j];
684  m_rateHdwNotSim[32*i+j] = rate;
685  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
686  }
687  rate_overflow = m_overflow_countHdw[32*i+j]>0 ? m_overflow_countHdwNotSim[32*i+j]/m_overflow_countHdw[32*i+j] : 0;
688  if (rate_overflow != m_overflow_rateHdwNotSim[32*i+j]) {
689  mon_match = 0;
690  mon_OFweight = rate_overflow-m_overflow_rateHdwNotSim[32*i+j];
691  m_overflow_rateHdwNotSim[32*i+j] = rate_overflow;
692  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
693  }
694  rate = m_countSim[32*i+j]>0 ? m_countSimNotHdw[32*i+j]/m_countSim[32*i+j] : 0;
695  if (rate != m_rateSimNotHdw[32*i+j]) {
696  mon_match = 1;
697  mon_weight = rate-m_rateSimNotHdw[32*i+j];
698  m_rateSimNotHdw[32*i+j] = rate;
699  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
700  }
701  rate_overflow = m_overflow_countSim[32*i+j]>0 ? m_overflow_countSimNotHdw[32*i+j]/m_overflow_countSim[32*i+j] : 0;
702  if (rate_overflow != m_overflow_rateSimNotHdw[32*i+j]) {
703  mon_match = 1;
704  mon_OFweight = rate_overflow-m_overflow_rateSimNotHdw[32*i+j];
705  m_overflow_rateSimNotHdw[32*i+j] = rate_overflow;
706  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
707  }
708  rate = m_countAny[32*i+j]>0 ? m_countHdwSim[32*i+j]/m_countAny[32*i+j] : 0;
709  if (rate != m_rateHdwAndSim[32*i+j]) {
710  mon_match = 2;
711  mon_weight = rate-m_rateHdwAndSim[32*i+j];
712  m_rateHdwAndSim[32*i+j] = rate;
713  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
714  }
715  rate_overflow = m_overflow_countAny[32*i+j]>0 ? m_overflow_countHdwSim[32*i+j]/m_overflow_countAny[32*i+j] : 0;
716  if (rate_overflow != m_overflow_rateHdwAndSim[32*i+j]) {
717  mon_match = 2;
718  mon_OFweight = rate_overflow-m_overflow_rateHdwAndSim[32*i+j];
719  m_overflow_rateHdwAndSim[32*i+j] = rate_overflow;
720  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
721  }
722  rate = m_countSim[32*i+j]>0 ? m_countHdw[32*i+j]/m_countSim[32*i+j] : 0;
723  if (rate != m_rateHdwSim[32*i+j]) {
724  mon_match = 3;
725  mon_weight = rate-m_rateHdwSim[32*i+j];
726  m_rateHdwSim[32*i+j] = rate;
727  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
728  }
729  rate_overflow = m_overflow_countSim[32*i+j]>0 ? m_overflow_countHdw[32*i+j]/m_overflow_countSim[32*i+j] : 0;
730  if (rate_overflow != m_overflow_rateHdwSim[32*i+j]) {
731  mon_match = 3;
732  mon_OFweight = rate_overflow-m_overflow_rateHdwSim[32*i+j];
733  m_overflow_rateHdwSim[32*i+j] = rate_overflow;
734  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
735  }
736  }
737  }
738  }
739  return StatusCode::SUCCESS;
740 }
741 
742 StatusCode L1TopoOnlineMonitor::doMultComp( std::vector<std::vector<unsigned>> &multWeightsSim, std::vector<std::vector<unsigned>> &multWeightsHdw, const EventContext& ctx ) const {
743  if (multWeightsSim.size() == 0 or multWeightsHdw.size() == 0) {
744  ATH_MSG_DEBUG("Multiplicities not set, skipping multiplicities comparison");
745  return StatusCode::FAILURE;
746  }
747 
748  auto lbn = Monitored::Scalar<int>("LBN",GetEventInfo(ctx)->lumiBlock());
749  auto mon_multiplicity_allboards = Monitored::Scalar<unsigned>("MultiplicityAllBoards");
750  auto mon_multVsLumi_DQ = Monitored::Scalar<unsigned>("L1TopoMultiplicityMissMatchVsLumi");
751  int AccumulatedPosition=0;
752  for (size_t i=0;i<multWeightsSim.size();i++) {
753  auto mon_multiplicity = Monitored::Scalar<unsigned>("MultiplicityTopo1Opt" + std::to_string(i));
754  auto mon_mult = Monitored::Scalar<unsigned>("MultiplicityMatchTopo1Opt" + std::to_string(i));
755  for (size_t k=0;k<multWeightsSim[i].size();k++) {
756  std::string colName = "Topo1Opt" + std::to_string(i) + "_" + std::to_string(k);
757  auto monMultSim = Monitored::Scalar<unsigned>(colName+"_Sim", multWeightsSim[i][k]);
758  auto monMultHdw = Monitored::Scalar<unsigned>(colName+"_Hdw", multWeightsHdw[i][k]);
759  Monitored::Group(m_monTool, monMultSim, monMultHdw);
760  if (monMultSim < monMultHdw) {mon_mult = 0; mon_multVsLumi_DQ = 1;}
761  if (monMultSim > monMultHdw) {mon_mult = 1; mon_multVsLumi_DQ = 1;}
762  if (monMultSim == monMultHdw){mon_mult = 2; mon_multVsLumi_DQ = 0;}
763  mon_multiplicity = static_cast<unsigned>(k);
764  mon_multiplicity_allboards = static_cast<unsigned>(k+AccumulatedPosition);
765  if (( monMultSim > 0 || monMultHdw > 0) && m_TopoMultTriggerNotVetoed[k+AccumulatedPosition]) {
766  Monitored::Group(m_monTool, mon_multiplicity, mon_mult);
767  Monitored::Group(m_monTool, lbn, mon_multiplicity_allboards, mon_multVsLumi_DQ);
768  }
769  }
770  AccumulatedPosition=AccumulatedPosition+multWeightsSim[i].size();
771  }
772  return StatusCode::SUCCESS;
773 }
774 
775 std::vector<std::vector<std::pair<unsigned,unsigned>>> L1TopoOnlineMonitor::getStartBits( const TrigConf::L1Menu& l1menu ) {
776 
777  std::vector<std::vector<std::pair<unsigned,unsigned>>> startbit_vec;
778  std::vector<std::string> connNames = l1menu.connectorNames();
779  for( const std::string connName : {"Topo1Opt0", "Topo1Opt1", "Topo1Opt2", "Topo1Opt3"}) {
780  if( find(connNames.begin(), connNames.end(), connName) == connNames.end() ) {
781  continue;
782  }
783  std::vector<std::pair<unsigned,unsigned>> startbit;
784  for(auto & t1 : l1menu.connector(connName).triggerLines()) {
785  startbit.push_back(std::make_pair(t1.startbit(),t1.nbits()));
786  }
787  startbit_vec.push_back(startbit);
788  }
789  return startbit_vec;
790 }
791 //
792 
793 std::vector<unsigned> L1TopoOnlineMonitor::getCtpIds( const TrigConf::L1Menu& l1menu ) {
794 
795  // Topo
796  std::vector<std::string> connNames = l1menu.connectorNames();
797  std::vector<std::string> labelsTopoEl(s_nTopoCTPOutputs);
798  for( const std::string connName : {"Topo2El", "Topo3El"}) {
799  if( find(connNames.begin(), connNames.end(), connName) == connNames.end() ) {
800  continue;
801  }
802  for(uint fpga : {0,1}) {
803  for(uint clock : {0,1}) {
804  for(auto & tl : l1menu.connector(connName).triggerLines(fpga,clock)) {
805  uint flatIndex = tl.flatindex() + 64 * (connName == "Topo3El");
806  labelsTopoEl[flatIndex] = tl.name();
807  }
808  }
809  }
810  }
811 
812  ATH_MSG_DEBUG("Obtaining CTPIds for Phase1 L1Topo Monitoring");
813  std::vector<unsigned> ctpIds(s_nTopoCTPOutputs,999);
814  for( const auto & item : l1menu ) {
815  std::string definition = item.definition();
816  if (definition.substr(0,5) == "TOPO_" &&
817  definition.find(' ') == std::string::npos) {
818  std::string trigger = definition.substr(0, definition.find('['));
819  auto pos = std::find(labelsTopoEl.begin(),labelsTopoEl.end(),trigger);
820  if (pos != labelsTopoEl.end()) {
821  ATH_MSG_DEBUG("Found one CTP; ,CTPId: " << item.ctpId() << " ,Name: " << item.name() << " ,Definition: " << definition);
822  unsigned index = std::distance(labelsTopoEl.begin(),pos);
823  ctpIds[index]=item.ctpId();
824  }
825  }
826  }
827 
828  return ctpIds;
829 }
830 
832  errorFlags.setDetail("hasTrivialFlag", true);
833 }
L1TopoOnlineMonitor::m_l1topoKey
SG::ReadHandleKey< xAOD::L1TopoSimResultsContainer > m_l1topoKey
Definition: L1TopoOnlineMonitor.h:129
L1TopoROD.h
L1TopoOnlineMonitor::m_MultiplicityVetoList
Gaudi::Property< std::vector< std::string > > m_MultiplicityVetoList
Definition: L1TopoOnlineMonitor.h:123
CTP_Decoder.h
L1TopoOnlineMonitor::doHwMonCTP
StatusCode doHwMonCTP(DecisionBits &decisionBits, const EventContext &ctx) const
Monitor the Hw bits from CTP.
Definition: L1TopoOnlineMonitor.cxx:382
xAOD::TrigComposite_v1::setDetail
bool setDetail(const std::string &name, const TYPE &value)
Set an TYPE detail on the object.
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
L1TopoOnlineMonitor::m_overflow_rateHdwNotSim
std::unique_ptr< float[]> m_overflow_rateHdwNotSim
Definition: L1TopoOnlineMonitor.h:81
L1TopoOnlineMonitor::DecisionBits::overflowBits
std::optional< std::bitset< s_nTopoCTPOutputs > > overflowBits
Definition: L1TopoOnlineMonitor.h:54
L1TopoOnlineMonitor::m_countSimNotHdw
std::unique_ptr< float[]> m_countSimNotHdw
Definition: L1TopoOnlineMonitor.h:76
L1TopoOnlineMonitor::DecisionBits::createBits
static std::bitset< s_nTopoCTPOutputs > & createBits(std::optional< std::bitset< s_nTopoCTPOutputs >> &opt)
Helper method to create a new bitset and get a reference to it.
Definition: L1TopoOnlineMonitor.h:60
L1TopoOnlineMonitor::m_doHwMonCTP
Gaudi::Property< bool > m_doHwMonCTP
Definition: L1TopoOnlineMonitor.h:109
L1TopoOnlineMonitor::getStartBits
std::vector< std::vector< std::pair< unsigned, unsigned > > > getStartBits(const TrigConf::L1Menu &l1menu)
Definition: L1TopoOnlineMonitor.cxx:775
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
L1Topo::L1TopoResult::getFPGASize
unsigned getFPGASize()
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:53
L1TopoOnlineMonitor::start
virtual StatusCode start() override
Definition: L1TopoOnlineMonitor.cxx:208
L1TopoOnlineMonitor::m_AlgorithmVetoList
Gaudi::Property< std::vector< std::string > > m_AlgorithmVetoList
Definition: L1TopoOnlineMonitor.h:121
L1TopoOnlineMonitor::resetFlags
void resetFlags(xAOD::TrigComposite &errorFlags) const
Definition: L1TopoOnlineMonitor.cxx:831
L1TopoOnlineMonitor::m_doHwErrorMon
Gaudi::Property< bool > m_doHwErrorMon
Definition: L1TopoOnlineMonitor.h:113
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
L1TopoSimResults.h
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
L1Topo::L1TopoResult::getTopo1Opt0
const std::bitset< s_nTopoOutputs > & getTopo1Opt0() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:47
L1TopoOnlineMonitor::m_overflow_countHdwNotSim
std::unique_ptr< float[]> m_overflow_countHdwNotSim
Definition: L1TopoOnlineMonitor.h:85
ALFA_EventTPCnv_Dict::t1
std::vector< ALFA_RawDataCollection_p1 > t1
Definition: ALFA_EventTPCnvDict.h:43
L1TopoOnlineMonitor::m_doSimMon
Gaudi::Property< bool > m_doSimMon
Definition: L1TopoOnlineMonitor.h:107
L1TopoOnlineMonitor::m_startbit
std::vector< std::vector< std::pair< unsigned, unsigned > > > m_startbit
Definition: L1TopoOnlineMonitor.h:97
L1TopoOnlineMonitor::m_currentHdwBit
std::unique_ptr< float[]> m_currentHdwBit
Definition: L1TopoOnlineMonitor.h:92
TrigConf::L1Menu
L1 menu configuration.
Definition: L1Menu.h:28
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
L1TopoOnlineMonitor::m_overflow_countHdwSim
std::unique_ptr< float[]> m_overflow_countHdwSim
Definition: L1TopoOnlineMonitor.h:87
XMLtoHeader.count
count
Definition: XMLtoHeader.py:84
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
L1TopoOnlineMonitor::m_countSim
std::unique_ptr< float[]> m_countSim
Definition: L1TopoOnlineMonitor.h:79
CTP_Decoder
Definition: CTP_Decoder.h:141
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
L1TopoOnlineMonitor::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: L1TopoOnlineMonitor.h:101
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
L1TopoOnlineMonitor::m_overflow_countHdw
std::unique_ptr< float[]> m_overflow_countHdw
Definition: L1TopoOnlineMonitor.h:88
L1TopoOnlineMonitor::initialize
virtual StatusCode initialize() override
initialize
Definition: L1TopoOnlineMonitor.cxx:45
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
L1TopoOnlineMonitor::DecisionBits::triggerBits
std::optional< std::bitset< s_nTopoCTPOutputs > > triggerBits
Definition: L1TopoOnlineMonitor.h:53
L1TopoOnlineMonitor::m_rateHdwSim
std::unique_ptr< float[]> m_rateHdwSim
Definition: L1TopoOnlineMonitor.h:74
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
L1TopoOnlineMonitor::m_rateHdwAndSim
std::unique_ptr< float[]> m_rateHdwAndSim
Definition: L1TopoOnlineMonitor.h:73
L1TopoOnlineMonitor::m_countAny
std::unique_ptr< float[]> m_countAny
Definition: L1TopoOnlineMonitor.h:80
L1TopoOnlineMonitor::m_ctpIds
std::vector< unsigned > m_ctpIds
Definition: L1TopoOnlineMonitor.h:95
lumiFormat.i
int i
Definition: lumiFormat.py:85
L1Topo::L1TopoResult::getTopo1Opt2
const std::bitset< s_nTopoOutputs > & getTopo1Opt2() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:49
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
L1TopoOnlineMonitor::m_rateSimNotHdw
std::unique_ptr< float[]> m_rateSimNotHdw
Definition: L1TopoOnlineMonitor.h:72
CTP_BC
Definition: CTP_Decoder.h:17
L1TopoOnlineMonitor::s_nTopoCTPOutputs
static constexpr size_t s_nTopoCTPOutputs
Number of CTP outputs, used for histogram ranges and loops.
Definition: L1TopoOnlineMonitor.h:49
L1TopoOnlineMonitor::m_overflow_rateSimNotHdw
std::unique_ptr< float[]> m_overflow_rateSimNotHdw
Definition: L1TopoOnlineMonitor.h:82
L1TopoOnlineMonitor::DecisionBits::triggerBitsSim
std::optional< std::bitset< s_nTopoCTPOutputs > > triggerBitsSim
Definition: L1TopoOnlineMonitor.h:55
L1TopoFPGA.h
L1TopoOnlineMonitor::doHwMon
StatusCode doHwMon(DecisionBits &decisionBits, std::vector< std::vector< unsigned >> &multWeights, const EventContext &ctx) const
Monitor the Hw bits from RAW data.
Definition: L1TopoOnlineMonitor.cxx:423
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
L1TopoOnlineMonitor::m_doMultComp
Gaudi::Property< bool > m_doMultComp
Definition: L1TopoOnlineMonitor.h:117
L1TopoOnlineMonitor::m_rateHdwNotSim
std::unique_ptr< float[]> m_rateHdwNotSim
Definition: L1TopoOnlineMonitor.h:71
L1TopoOnlineMonitor::doSimMon
StatusCode doSimMon(DecisionBits &decisionBits, std::vector< std::vector< unsigned >> &multWeights, const EventContext &ctx) const
Monitor the simulated bits.
Definition: L1TopoOnlineMonitor.cxx:288
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
L1TopoOnlineMonitor::m_countHdwNotSim
std::unique_ptr< float[]> m_countHdwNotSim
Definition: L1TopoOnlineMonitor.h:75
L1TopoOnlineMonitor::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: L1TopoOnlineMonitor.h:126
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
DataVector::back
const T * back() const
Access the last element in the collection as an rvalue.
L1TopoOnlineMonitor::doComp
StatusCode doComp(DecisionBits &decisionBits, const EventContext &ctx) const
Compare hardware and simulation.
Definition: L1TopoOnlineMonitor.cxx:581
L1Topo::L1TopoResult::getDecisions
const std::bitset< s_nTopoOutputs > & getDecisions() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:45
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
L1Topo::L1TopoResult::getOverflows
const std::bitset< s_nTopoOutputs > & getOverflows() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:46
CxxUtils::set
constexpr std::enable_if_t< is_bitmask_v< E >, E & > set(E &lhs, E rhs)
Convenience function to set bits in a class enum bitmask.
Definition: bitmask.h:232
L1Topo::L1TopoResult::getTopo1Opt1
const std::bitset< s_nTopoOutputs > & getTopo1Opt1() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:48
L1TopoOnlineMonitor::m_overflow_countSim
std::unique_ptr< float[]> m_overflow_countSim
Definition: L1TopoOnlineMonitor.h:89
L1TopoOnlineMonitor::m_overflow_countSimNotHdw
std::unique_ptr< float[]> m_overflow_countSimNotHdw
Definition: L1TopoOnlineMonitor.h:86
L1TopoOnlineMonitor::m_currentSimBit
std::unique_ptr< float[]> m_currentSimBit
Definition: L1TopoOnlineMonitor.h:93
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
L1TopoOnlineMonitor::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: L1TopoOnlineMonitor.cxx:221
CTP_BC::getTBP
const std::bitset< 512 > & getTBP() const
get bitset of TBP words
Definition: CTP_Decoder.h:92
L1Topo::L1TopoResult::getFPGA
const std::shared_ptr< L1Topo::L1TopoFPGA > & getFPGA(unsigned index) const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:44
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
item
Definition: ItemListSvc.h:43
L1TopoOnlineMonitor::m_overflow_rateHdwAndSim
std::unique_ptr< float[]> m_overflow_rateHdwAndSim
Definition: L1TopoOnlineMonitor.h:83
L1TopoOnlineMonitor::DecisionBits::ambiguityBitsSim
std::optional< std::bitset< s_nTopoCTPOutputs > > ambiguityBitsSim
Definition: L1TopoOnlineMonitor.h:57
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
L1TopoOnlineMonitor::m_forceCTPasHdw
Gaudi::Property< bool > m_forceCTPasHdw
Definition: L1TopoOnlineMonitor.h:119
TriggerTest.ctp
ctp
Retrieve trigger EDM objects.
Definition: TriggerTest.py:14
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
L1TopoOnlineMonitor::DecisionBits
Helper structure holding decision bitsets, passed between the monitoring methods.
Definition: L1TopoOnlineMonitor.h:52
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
L1TopoOnlineMonitor::m_doComp
Gaudi::Property< bool > m_doComp
Definition: L1TopoOnlineMonitor.h:115
L1TopoOnlineMonitor::DecisionBits::overflowBitsSim
std::optional< std::bitset< s_nTopoCTPOutputs > > overflowBitsSim
Definition: L1TopoOnlineMonitor.h:56
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
DeMoScan.index
string index
Definition: DeMoScan.py:362
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
L1TopoOnlineMonitor::m_TopoMultTriggerNames
std::vector< std::string > m_TopoMultTriggerNames
Definition: L1TopoOnlineMonitor.h:68
L1TopoOnlineMonitor::m_overflow_countAny
std::unique_ptr< float[]> m_overflow_countAny
Definition: L1TopoOnlineMonitor.h:90
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
L1TopoOnlineMonitor::m_TopoAlgTriggerNotVetoed
std::vector< bool > m_TopoAlgTriggerNotVetoed
Definition: L1TopoOnlineMonitor.h:67
L1TopoOnlineMonitor::m_TopoMultTriggerNotVetoed
std::vector< bool > m_TopoMultTriggerNotVetoed
Definition: L1TopoOnlineMonitor.h:69
L1TopoOnlineMonitor::m_TopoAlgTriggerNames
std::vector< std::string > m_TopoAlgTriggerNames
Definition: L1TopoOnlineMonitor.h:66
python.XMLReader.l1menu
l1menu
Definition: XMLReader.py:73
L1TopoOnlineMonitor::L1TopoOnlineMonitor
L1TopoOnlineMonitor(const std::string &name, ISvcLocator *svcLoc)
Definition: L1TopoOnlineMonitor.cxx:37
L1Topo::L1TopoResult::getStatus
bool getStatus()
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:51
L1TopoOnlineMonitor::DecisionBits::triggerBitsCtp
std::optional< std::bitset< s_nTopoCTPOutputs > > triggerBitsCtp
Definition: L1TopoOnlineMonitor.h:58
L1TopoOnlineMonitor.h
L1Topo::L1TopoResult::getROD
const std::shared_ptr< L1Topo::L1TopoROD > & getROD(unsigned index) const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:43
dqt_zlumi_alleff_HIST.tl
tl
Definition: dqt_zlumi_alleff_HIST.py:73
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
L1TopoOnlineMonitor::getCtpIds
std::vector< unsigned > getCtpIds(const TrigConf::L1Menu &l1menu)
Get CTP ids from menu.
Definition: L1TopoOnlineMonitor.cxx:793
L1TopoOnlineMonitor::m_ctpRdoKey
SG::ReadHandleKey< CTP_RDO > m_ctpRdoKey
Definition: L1TopoOnlineMonitor.h:136
L1TopoOnlineMonitor::m_l1topoRawDataKey
SG::ReadHandleKey< xAOD::L1TopoRawDataContainer > m_l1topoRawDataKey
Definition: L1TopoOnlineMonitor.h:132
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:328
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
L1TopoResult.h
L1TopoOnlineMonitor::m_countHdw
std::unique_ptr< float[]> m_countHdw
Definition: L1TopoOnlineMonitor.h:78
L1Topo::L1TopoResult::getTopo1Opt3
const std::bitset< s_nTopoOutputs > & getTopo1Opt3() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:50
L1TopoOnlineMonitor::doMultComp
StatusCode doMultComp(std::vector< std::vector< unsigned >> &multWeightsSim, std::vector< std::vector< unsigned >> &multWeightsHdw, const EventContext &ctx) const
Compare hardware and simulation for the multiplicity algorithms.
Definition: L1TopoOnlineMonitor.cxx:742
Helpers.h
L1TopoOnlineMonitor::m_doHwMon
Gaudi::Property< bool > m_doHwMon
Definition: L1TopoOnlineMonitor.h:111
L1TopoOnlineMonitor::m_countHdwSim
std::unique_ptr< float[]> m_countHdwSim
Definition: L1TopoOnlineMonitor.h:77
fitman.k
k
Definition: fitman.py:528
L1TopoOnlineMonitor::m_overflow_rateHdwSim
std::unique_ptr< float[]> m_overflow_rateHdwSim
Definition: L1TopoOnlineMonitor.h:84
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
L1TopoOnlineMonitor::m_errorFlagsKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_errorFlagsKey
Definition: L1TopoOnlineMonitor.h:104