ATLAS Offline Software
CpmMonitorAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "CpmMonitorAlgorithm.h"
6 #include "TrigT1CaloUtils/CoordToHardware.h"
7 #include "TrigT1CaloUtils/DataError.h"
8 #include "TrigT1Interfaces/CPRoIDecoder.h"
9 
10 CpmMonitorAlgorithm::CpmMonitorAlgorithm( const std::string& name, ISvcLocator* pSvcLocator )
11  : AthMonitorAlgorithm(name,pSvcLocator),
12  m_phiScaleTT(32./M_PI)
13 {
14 }
15 
16 StatusCode CpmMonitorAlgorithm::initialize() {
17 
18  ATH_MSG_DEBUG("CpmMonitorAlgorith::initialize");
19  ATH_MSG_DEBUG("Package Name "<< m_packageName);
20  // container names
21  ATH_MSG_DEBUG("m_xAODTriggerTowerContainerName"<< m_xAODTriggerTowerContainerName);
22  ATH_MSG_DEBUG("m_cpmTowerLocation"<< m_cpmTowerLocation);
23  ATH_MSG_DEBUG("m_cpmTowerLocationOverlap"<< m_cpmTowerLocationOverlap);
24 
25  // steering parameters
26  ATH_MSG_DEBUG("m_crates"<<m_crates );
27  ATH_MSG_DEBUG("m_modules"<<m_modules );
28  ATH_MSG_DEBUG("m_maxSlices"<<m_maxSlices );
29  ATH_MSG_DEBUG("m_tobsPerCPM"<<m_tobsPerCPM );
30  ATH_MSG_DEBUG("m_isolBits"<<m_isolBits );
31  ATH_MSG_DEBUG("m_maxTobsPerCmx"<<m_maxTobsPerCmx );
32 
33  // initialise all the containers that we need
34  ATH_CHECK(m_xAODTriggerTowerContainerName.initialize());
35  ATH_CHECK(m_cpmTowerLocation.initialize());
36  ATH_CHECK(m_cpmTowerLocationOverlap.initialize());
37  ATH_CHECK( m_cpmTobRoiLocation.initialize());
38  ATH_CHECK( m_cmxCpTobLocation.initialize());
39  ATH_CHECK( m_cmxCpHitsLocation.initialize());
40 
41  ATH_CHECK(m_errorLocation.initialize());
42 
43  return AthMonitorAlgorithm::initialize();
44 }
45 
46 StatusCode CpmMonitorAlgorithm::fillHistograms( const EventContext& ctx ) const {
47 
48  ATH_MSG_DEBUG("CpmMonitorAlgorithm::fillHistograms");
49 
50  // Retrieve Trigger Towers from SG
51  SG::ReadHandle<xAOD::TriggerTowerContainer> triggerTowerTES(m_xAODTriggerTowerContainerName, ctx);
52 
53  ATH_CHECK(triggerTowerTES.isValid());
54 
55  // Retrieve Core CPM Towers from SG
56  SG::ReadHandle<xAOD::CPMTowerContainer> cpmTowerTES(m_cpmTowerLocation, ctx);
57  ATH_CHECK(cpmTowerTES.isValid());
58 
59  // Retrieve Overlap CPM Towers from SG
60  SG::ReadHandle<xAOD::CPMTowerContainer> cpmTowerOverlapTES(m_cpmTowerLocationOverlap, ctx);
61  ATH_CHECK(cpmTowerOverlapTES.isValid());
62 
63  //Retrieve CPM TOB RoIs from SG
64  SG::ReadHandle<xAOD::CPMTobRoIContainer> cpmTobRoiTES(m_cpmTobRoiLocation, ctx);
65  ATH_CHECK(cpmTobRoiTES.isValid());
66 
67  //Retrieve CMX-CP TOBs from SG
68  SG::ReadHandle<xAOD::CMXCPTobContainer> cmxCpTobTES(m_cmxCpTobLocation, ctx);
69  ATH_CHECK(cmxCpTobTES.isValid());
70 
71  //Retrieve CMX-CP Hits from SG
72  SG::ReadHandle<xAOD::CMXCPHitsContainer> cmxCpHitsTES(m_cmxCpHitsLocation, ctx);
73  ATH_CHECK(cmxCpHitsTES.isValid());
74 
75  //
76  // array of monitored items
77  std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>> variables;
78 
79  // Global plots
80  // Create a vector of towers we want to monitor
81  std::vector<MonitorTT> monTTs;
82  xAOD::TriggerTowerContainer::const_iterator ttIterator = (*triggerTowerTES).begin();
83  xAOD::TriggerTowerContainer::const_iterator ttIteratorEnd = (*triggerTowerTES).end();
84  for (; ttIterator != ttIteratorEnd; ++ttIterator) {
85  const int layer = (*ttIterator)->layer();
86  const xAOD::TriggerTower_v2* tt = *ttIterator;
87  const double eta = (*ttIterator)->eta();
88  if ( std::abs(eta) > 2.5) continue;
89 
90  if (!tt->cpET()) continue;
91  //check if the TriggerTower is in EM or HAD layer
92  if (layer == 0) { //EM
93  const int em = int(tt->cpET());
94  if (em) {
95  MonitorTT monTT;
96  monTT.ttower=(*ttIterator);
97  monTT.phi_scaled=(*ttIterator)->phi()*m_phiScaleTT;
98  monTTs.push_back(monTT);
99  }
100  }
101  if (layer == 1) { //HAD
102  const int had = int(tt->cpET());
103  if (had) {
104  MonitorTT monTT;
105  monTT.ttower=(*ttIterator);
106  monTT.phi_scaled=(*ttIterator)->phi()*m_phiScaleTT;
107  monTTs.push_back(monTT);
108  }
109  }
110  } //ttIterator
111 
112  // setup cutmasks to select the em and had TTs
113  auto mask_em_TT = Monitored::Collection("mask_em_TT", monTTs, []( const auto &tower ) {return ( tower.ttower->layer()==0); } ); variables.push_back( mask_em_TT );
114  auto mask_had_TT = Monitored::Collection("mask_had_TT", monTTs, []( const auto &tower ){return ( tower.ttower->layer()==1); } ); variables.push_back( mask_had_TT );
115 
116  // the variables to monitor
117  auto etaTT = Monitored::Collection("etaTT", monTTs, []( const auto &tower ){return tower.ttower->eta();} ); variables.push_back( etaTT );
118  auto phiTT = Monitored::Collection("phiTT", monTTs, []( const auto &tower ){return tower.phi_scaled;} ); variables.push_back( phiTT );
119 
120  // CPM Global maps
121 
122  // Vectors for error overview bits;
123  std::vector<int> errorsCPM(m_crates * m_modules);
124  std::vector<int> errorsCMX(m_crates * 2); // L/R
125  //cpmTowerTES
126  std::vector<MonitorCpmTT> monCpmTTs_em;
127  std::vector<MonitorCpmTT> monCpmTTs_had;
128  // scalars to fill bitwise histograms directly
129  Monitored::Scalar<int> GLinkParityError = Monitored::Scalar<int>("GLinkParityError", 0);
130  Monitored::Scalar<int> cpmLoc = Monitored::Scalar<int>("cpmLoc", 0);
131  bool core=true;
132  ATH_CHECK(fillCpmTowerVectors(cpmTowerTES, monCpmTTs_em, monCpmTTs_had, errorsCPM, core, cpmLoc, GLinkParityError));
133  std::vector<MonitorCpmTT> monCpmOverlapTTs_em;
134  std::vector<MonitorCpmTT> monCpmOverlapTTs_had;
135  core=false;
136  ATH_CHECK(fillCpmTowerVectors(cpmTowerOverlapTES, monCpmOverlapTTs_em, monCpmOverlapTTs_had, errorsCPM, core, cpmLoc, GLinkParityError));
137 
138  // add the CPM global variables to be monitored - exclude Overlap
139  auto etCpmTT_em = Monitored::Collection("etCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.ttower->emEnergy();} ); variables.push_back( etCpmTT_em );
140  auto etaCpmTT_em = Monitored::Collection("etaCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.ttower->eta();} ); variables.push_back( etaCpmTT_em );
141  auto phiCpmTT_em = Monitored::Collection("phiCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.ttower->phi();} ); variables.push_back( phiCpmTT_em );
142  auto phiScaledCpmTT_em = Monitored::Collection("phiScaledCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.phi_scaled;} );
143  variables.push_back( phiScaledCpmTT_em );
144  auto etCpmTT_had = Monitored::Collection("etCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.ttower->hadEnergy();} ); variables.push_back( etCpmTT_had );
145  auto etaCpmTT_had = Monitored::Collection("etaCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.ttower->eta();} ); variables.push_back( etaCpmTT_had );
146  auto phiCpmTT_had = Monitored::Collection("phiCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.ttower->phi();} ); variables.push_back( phiCpmTT_had );
147  auto phiScaledCpmTT_had = Monitored::Collection("phiScaledCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.phi_scaled;} );
148  variables.push_back( phiScaledCpmTT_had );
149 
150  // errors and slices are filled for sum of Core and Overlap
151  std::vector<MonitorCpmTT> monCpmTTs_em_tot(monCpmTTs_em.begin(),monCpmTTs_em.end());
152  monCpmTTs_em_tot.insert(monCpmTTs_em_tot.end(), monCpmOverlapTTs_em.begin(),monCpmOverlapTTs_em.end());
153  std::vector<MonitorCpmTT> monCpmTTs_had_tot(monCpmTTs_had.begin(),monCpmTTs_had.end());
154  monCpmTTs_had_tot.insert(monCpmTTs_had_tot.end(), monCpmOverlapTTs_had.begin(),monCpmOverlapTTs_had.end());
155  // the variables
156  auto etaCpmTT_em_tot = Monitored::Collection("etaCpmTT_em_tot", monCpmTTs_em_tot, []( const auto &tt ){return tt.ttower->eta();} );
157  variables.push_back( etaCpmTT_em_tot) ;
158  auto phiScaledCpmTT_em_tot = Monitored::Collection("phiScaledCpmTT_em_tot", monCpmTTs_em_tot, []( const auto &tt ){return tt.phi_scaled;} );
159  variables.push_back( phiScaledCpmTT_em_tot );
160  auto etaCpmTT_had_tot = Monitored::Collection("etaCpmTT_had_tot", monCpmTTs_had_tot, []( const auto &tt ){return tt.ttower->eta();} );
161  variables.push_back( etaCpmTT_had_tot) ;
162  auto phiScaledCpmTT_had_tot = Monitored::Collection("phiScaledCpmTT_had_tot", monCpmTTs_had_tot, []( const auto &tt ){return tt.phi_scaled;} );
163  variables.push_back( phiScaledCpmTT_had_tot );
164 
165 
166  // the masks
167  auto parityErrorCpmTT_em = Monitored::Collection("parityErrorCpmTT_em", monCpmTTs_em_tot, []( const auto &tt ){return tt.emParityError;} );
168  variables.push_back( parityErrorCpmTT_em );
169  auto linkDownErrorCpmTT_em = Monitored::Collection("linkDownErrorCpmTT_em", monCpmTTs_em_tot, []( const auto &tt ){return tt.emLinkDownError;} );
170  variables.push_back( linkDownErrorCpmTT_em );
171  auto parityErrorCpmTT_had = Monitored::Collection("parityErrorCpmTT_had", monCpmTTs_had_tot, []( const auto &tt ){return tt.hadParityError;} );
172  variables.push_back( parityErrorCpmTT_had );
173  auto linkDownErrorCpmTT_had = Monitored::Collection("linkDownErrorCpmTT_had", monCpmTTs_had_tot, []( const auto &tt ){return tt.hadLinkDownError;} );
174  variables.push_back( linkDownErrorCpmTT_had );
175 
176  // and the sum of the Core and Overlap for EM and HAD
177  std::vector<MonitorCpmTT> monCpmTTs_tot(monCpmTTs_em_tot.begin(),monCpmTTs_em_tot.end());
178  monCpmTTs_tot.insert(monCpmTTs_tot.end(), monCpmTTs_had_tot.begin(),monCpmTTs_had_tot.end());
179 
180  auto peakCpmTT_tot = Monitored::Collection("peakCpmTT_tot", monCpmTTs_tot, []( const auto &tt ){return tt.ttower->peak();} );
181  variables.push_back( peakCpmTT_tot );
182  auto sliceCpmTT_tot = Monitored::Collection("sliceCpmTT_tot", monCpmTTs_tot, []( const auto &tt ){return tt.slice;} );
183  variables.push_back( sliceCpmTT_tot );
184 
185  //=============================================
186  // CPM TOB RoIs
187  //=============================================
188 
189  std::vector<MonitorTobRoI> monTobRoIsEner;
190  std::vector<MonitorTobRoI> monTobRoIsIsol;
191 
192  const int vecSize = m_crates * m_modules * 2;
193  std::vector<int> tobCount(vecSize);
194  LVL1::CPRoIDecoder decoder;
195  xAOD::CPMTobRoIContainer::const_iterator crIterator = (*cpmTobRoiTES).begin();
196  xAOD::CPMTobRoIContainer::const_iterator crIteratorEnd = (*cpmTobRoiTES).end();
197  // fill thresholds and bits as scalars in the loop
198  auto thresholdsEm = Monitored::Scalar("bitsTobRoIsIsolEm", 0.);
199  auto thresholdWeightsEm = Monitored::Scalar<float>("bitsTobRoIsIsolEmWeight", 1.);
200  auto thresholdsTau = Monitored::Scalar("bitsTobRoIsIsolTau", 0.);
201  auto thresholdWeightsTau = Monitored::Scalar("bitsTobRoIsIsolTauWeight", 0.);
202  for (; crIterator != crIteratorEnd; ++crIterator) {
203  const int type = (*crIterator)->type(); // 0=EM, 1=Tau
204  const int energy = (*crIterator)->energy();
205  const int isolation = (*crIterator)->isolation();
206  const LVL1::CoordinateRange coord(decoder.coordinate((*crIterator)->roiWord()));
207  const double eta = coord.eta();
208  const double phi = coord.phi();
209  const double phiMod = phi * m_phiScaleTT - 0.5;
210  const double etaMod = eta - 0.05;
211  if (energy) {
212  MonitorTobRoI monTobRoI;
213  monTobRoI.tobroi=(*crIterator);
214  monTobRoI.etaMod=etaMod;
215  monTobRoI.phiMod=phiMod;
216  monTobRoIsEner.push_back(monTobRoI);
217  }
218  if (isolation) {
219  // fill isolation bits
220  std::vector<bool> isolbits=getIsolationBits(isolation, m_isolBits, 1);
221  for (int thr = 0; thr < m_isolBits; ++thr) {
222  if (isolbits[thr]){
223  if(type==0) {
224  thresholdsEm = thr;
225  thresholdWeightsEm = isolbits[thr];
226  fill(m_packageName, thresholdsEm, thresholdWeightsEm);
227  } else {
228  thresholdsTau = thr;
229  thresholdWeightsTau = isolbits[thr];
230  fill(m_packageName, thresholdsTau, thresholdWeightsTau);
231  }
232  }
233  }
234  //
235  MonitorTobRoI monTobRoI;
236  monTobRoI.tobroi=(*crIterator);
237  monTobRoI.etaMod=etaMod;
238  monTobRoI.phiMod=phiMod;
239  monTobRoIsIsol.push_back(monTobRoI);
240  }
241  const int crate = (*crIterator)->crate();
242  const int cpm = (*crIterator)->cpm();
243  ++tobCount[(crate * m_modules + cpm - 1) * 2 + type];
244  }
245  // Energy
246  auto etaTobRoIsEner = Monitored::Collection("etaTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.etaMod;} );
247  variables.push_back(etaTobRoIsEner);
248  auto phiTobRoIsEner = Monitored::Collection("phiTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.phiMod;} );
249  variables.push_back(phiTobRoIsEner);
250  auto energyTobRoIsEner = Monitored::Collection("energyTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.tobroi->energy();} );
251  variables.push_back(energyTobRoIsEner);
252  auto typeTobRoIsEner = Monitored::Collection("typeTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.tobroi->type();} );
253  variables.push_back(typeTobRoIsEner);
254 
255  // setup cutmasks to select EM or Tau
256  auto mask_tobroi_ener_em = Monitored::Collection("mask_tobroi_ener_em", monTobRoIsEner, []( const auto &roi ) {return ( roi.tobroi->type()==0); } );
257  variables.push_back( mask_tobroi_ener_em );
258  auto mask_tobroi_ener_tau = Monitored::Collection("mask_tobroi_ener_tau", monTobRoIsEner, []( const auto &roi ){return ( roi.tobroi->type()==1); } );
259  variables.push_back( mask_tobroi_ener_tau );
260 
261  // Isol
262  auto etaTobRoIsIsol = Monitored::Collection("etaTobRoIsIsol", monTobRoIsIsol, []( const auto &roi ){return roi.etaMod;} );
263  variables.push_back(etaTobRoIsIsol);
264  auto phiTobRoIsIsol = Monitored::Collection("phiTobRoIsIsol", monTobRoIsIsol, []( const auto &roi ){return roi.phiMod;} );
265  variables.push_back(phiTobRoIsIsol);
266  auto energyTobRoIsIsol = Monitored::Collection("energyTobRoIsIsol", monTobRoIsIsol, []( const auto &roi ){return roi.tobroi->isolation();} );
267  variables.push_back(energyTobRoIsIsol);
268 
269  auto mask_tobroi_isol_em = Monitored::Collection("mask_tobroi_isol_em", monTobRoIsIsol, []( const auto &roi ) {return ( roi.tobroi->type()==0); } );
270  variables.push_back( mask_tobroi_isol_em );
271  auto mask_tobroi_isol_tau = Monitored::Collection("mask_tobroi_isol_tau", monTobRoIsIsol, []( const auto &roi ){return ( roi.tobroi->type()==1); } );
272  variables.push_back( mask_tobroi_isol_tau );
273 
274 
275  // count ToBs
276  std::vector<int> tobCountEm;
277  std::vector<int> tobCountTau;
278  for (int crate = 0; crate < m_crates; ++crate) {
279  for (int cpm = 1; cpm <= m_modules; ++cpm) {
280  for (int type = 0; type < 2; ++type) {
281  int val = tobCount[(crate * m_modules + cpm - 1) * 2 + type];
282  if (val) {
283  if (val > m_tobsPerCPM) val = m_tobsPerCPM + 1;
284  if (type == 0) {
285  tobCountEm.push_back(val);
286  } else {
287  tobCountTau.push_back(val);
288  }
289  }
290  }
291  }
292  }
293  auto tobEm = Monitored::Collection("tobPerCPMEm", tobCountEm, []( const auto &tob ){return tob;} ); variables.push_back( tobEm );
294  auto tobTau = Monitored::Collection("tobPerCPMTau", tobCountTau, []( const auto &tob ){return tob;} ); variables.push_back( tobTau );
295 
296 
297  //=============================================
298  // CMX-CP TOBs
299  //=============================================
300 
301  std::vector<MonitorCmxCpTob> monCmxCpTobEnerLeft;
302  std::vector<MonitorCmxCpTob> monCmxCpTobEnerRight;
303  std::vector<MonitorCmxCpTob> monCmxCpTobError;
304  std::vector<MonitorCmxCpTob> monCmxCpTobIsolLeft;
305  std::vector<MonitorCmxCpTob> monCmxCpTobIsolRight;
306 
307  tobCount.assign(vecSize, 0);
308  std::vector<int> cmxCount(m_crates * 2);
309  xAOD::CMXCPTobContainer::const_iterator cmxCpTobIter = (*cmxCpTobTES).begin();
310  xAOD::CMXCPTobContainer::const_iterator cmxCpTobIterEnd = (*cmxCpTobTES).end();
311  //
312  auto cmxCpmTobsIsolBitsLeft = Monitored::Scalar("cmxCpmTobsIsolBitsLeft", 0.);
313  auto cmxCpmTobsIsolBitsLeftW = Monitored::Scalar<float>("cmxCpmTobsIsolBitsLeftWeight", 1.);
314  auto cmxCpmTobsIsolBitsRight= Monitored::Scalar("cmxCpmTobsIsolBitsRight", 0.);
315  auto cmxCpmTobsIsolBitsRightW = Monitored::Scalar<float>("cmxCpmTobsIsolBitsRightWeight", 1.);
316  for (; cmxCpTobIter != cmxCpTobIterEnd; ++cmxCpTobIter) {
317  const uint8_t crate = (*cmxCpTobIter)->crate();
318  const uint8_t cpm = (*cmxCpTobIter)->cpm(); // 1-14
319  const uint8_t cmx = (*cmxCpTobIter)->cmx(); // 0=Left, 1=Right (Assumed in Sim to be Left Tau, Right EM)
320  const uint8_t chip = (*cmxCpTobIter)->chip(); // 4 bits
321  const uint8_t location = (*cmxCpTobIter)->location();// 2 bits
322  const uint8_t energy = (*cmxCpTobIter)->energy();
323  const uint8_t isolation = (*cmxCpTobIter)->isolation();
324  const uint32_t error = (*cmxCpTobIter)->error();
325  const uint8_t x = crate * m_modules + cpm - 1;
326  const uint8_t y = chip * 4 + location;
327  if (energy) {
328  MonitorCmxCpTob monCmxCpTob;
329  monCmxCpTob.tob=(*cmxCpTobIter);
330  monCmxCpTob.x=x;
331  monCmxCpTob.y=y;
332  if (cmx)
333  monCmxCpTobEnerRight.push_back(monCmxCpTob);
334  else
335  monCmxCpTobEnerLeft.push_back(monCmxCpTob);
336  }
337  if (isolation) {
338  MonitorCmxCpTob monCmxCpTob;
339  monCmxCpTob.tob=(*cmxCpTobIter);
340  monCmxCpTob.x=x;
341  monCmxCpTob.y=y;
342  if (cmx)
343  monCmxCpTobIsolRight.push_back(monCmxCpTob);
344  else
345  monCmxCpTobIsolLeft.push_back(monCmxCpTob);
346 
347  int nBits=1; int offset = 0;
348  const int mask = (1 << nBits) - 1;
349  for (int thr = 0; thr < m_isolBits; ++thr) {
350  const int hit = (isolation >> (nBits*thr)) & mask;
351  if (hit) {
352  if(cmx) {
353  cmxCpmTobsIsolBitsRight=thr+offset;
354  cmxCpmTobsIsolBitsRightW=hit;
355  fill(m_packageName, cmxCpmTobsIsolBitsRight, cmxCpmTobsIsolBitsRightW);
356  } else {
357  cmxCpmTobsIsolBitsLeft=thr+offset;
358  cmxCpmTobsIsolBitsLeftW=hit;
359  fill(m_packageName, cmxCpmTobsIsolBitsLeft, cmxCpmTobsIsolBitsLeftW);
360  }
361  }
362  } // isol bits
363  } // isolation
364  if (error) {
365  MonitorCmxCpTob monCmxCpTob;
366  monCmxCpTob.tob=(*cmxCpTobIter);
367  monCmxCpTob.x=x;
368  monCmxCpTob.parityError=false;
369 
370  const LVL1::DataError err(error);
371  if (err.get(LVL1::DataError::Overflow)) {
372  tobCount[x * 2 + cmx] = m_tobsPerCPM + 1;
373  }
374  const int ybase = cmx * 5;
375  monCmxCpTob.ybase=ybase;
376  bool parity = false;
377  if (err.get(LVL1::DataError::ParityMerge)) {
378  parity = true;
379  monCmxCpTob.parityError=true;
380  monCmxCpTob.ybaseError=ybase;
381  }
382  if (err.get(LVL1::DataError::ParityPhase0)) {
383  parity = true;
384  monCmxCpTob.parityError=true;
385  monCmxCpTob.ybaseError=ybase+1;
386  }
387  if (err.get(LVL1::DataError::ParityPhase1)) {
388  parity = true;
389  monCmxCpTob.parityError=true;
390  monCmxCpTob.ybaseError=ybase+2;
391  }
392  if (err.get(LVL1::DataError::ParityPhase2)) {
393  parity = true;
394  monCmxCpTob.parityError=true;
395  monCmxCpTob.ybaseError=ybase+3;
396  }
397  if (err.get(LVL1::DataError::ParityPhase3)) {
398  parity = true;
399  monCmxCpTob.parityError=true;
400  monCmxCpTob.ybaseError=ybase+4;
401  }
402  if (parity) errorsCMX[crate * 2 + cmx] |= (1 << TOBParity);
403 
404  // and now push error structs
405  monCmxCpTobError.push_back(monCmxCpTob);
406  } // end of error
407  //
408  if (energy || isolation || error) {
409  ++tobCount[x * 2 + cmx];
410  ++cmxCount[crate * 2 + cmx];
411  }
412 
413  //
414  auto cmxCpmTobsLeft = Monitored::Scalar("cmxCpmTobsLeft", 0.);
415  auto cmxCpmTobsRight = Monitored::Scalar("cmxCpmTobsRight", 0.);
416  auto cmxTobsCmxLeft = Monitored::Scalar("cmxTobsCmxLeft", 0.);
417  auto cmxTobsCmxRight = Monitored::Scalar("cmxTobsCmxRight", 0.);
418  for (int crate = 0; crate < m_crates; ++crate) {
419  for (int cpm = 1; cpm <= m_modules; ++cpm) {
420  for (int cmx = 0; cmx < 2; ++cmx) {
421  int val = tobCount[(crate * m_modules + cpm - 1) * 2 + cmx];
422  if (val) {
423  if (val > m_tobsPerCPM) val = m_tobsPerCPM + 1;
424  if (cmx == 0) {
425  cmxCpmTobsLeft=val;
426  fill(m_packageName, cmxCpmTobsLeft);
427  } else {
428  cmxCpmTobsRight=val;
429  fill(m_packageName, cmxCpmTobsRight);
430  }
431  }
432  }
433  }
434  for (int cmx = 0; cmx < 2; ++cmx) {
435  int val = cmxCount[crate * 2 + cmx];
436  if (val) {
437  if (val >= m_maxTobsPerCmx) val = m_maxTobsPerCmx - 1;
438  if (cmx == 0) {
439  cmxTobsCmxLeft=val;
440  fill(m_packageName, cmxTobsCmxLeft);
441  } else {
442  cmxTobsCmxRight=val;
443  fill(m_packageName, cmxTobsCmxRight);
444  }
445  }
446  }
447  }
448  } // CMX loop end
449 
450  // now fill CMX-CP TOB monitor items
451  // Energy
452  auto cmxCpmTobsEnerLeft = Monitored::Collection("cmxCpmTobsEnerLeft", monCmxCpTobEnerLeft, []( const auto &tob ){return tob.tob->energy();} );
453  variables.push_back(cmxCpmTobsEnerLeft);
454  auto cmxCpmTobsEnerRight = Monitored::Collection("cmxCpmTobsEnerRight", monCmxCpTobEnerRight, []( const auto &tob ){return tob.tob->energy();} );
455  variables.push_back(cmxCpmTobsEnerRight);
456 
457  auto cmxCpmTobsEnerXLeft = Monitored::Collection("cmxCpmTobsEnerXLeft", monCmxCpTobEnerLeft, []( const auto &tob ){return tob.x;} );
458  variables.push_back(cmxCpmTobsEnerXLeft);
459  auto cmxCpmTobsEnerYLeft = Monitored::Collection("cmxCpmTobsEnerYLeft", monCmxCpTobEnerLeft, []( const auto &tob ){return tob.y;} );
460  variables.push_back(cmxCpmTobsEnerYLeft);
461  auto cmxCpmTobsEnerXRight = Monitored::Collection("cmxCpmTobsEnerXRight", monCmxCpTobEnerRight, []( const auto &tob ){return tob.x;} );
462  variables.push_back(cmxCpmTobsEnerXRight);
463  auto cmxCpmTobsEnerYRight = Monitored::Collection("cmxCpmTobsEnerYRight", monCmxCpTobEnerRight, []( const auto &tob ){return tob.y;} );
464  variables.push_back(cmxCpmTobsEnerYRight);
465 
466  // isolation
467  auto cmxCpmTobsIsolLeft = Monitored::Collection("cmxCpmTobsIsolLeft", monCmxCpTobIsolLeft, []( const auto &tob ){return tob.tob->isolation();} );
468  variables.push_back(cmxCpmTobsIsolLeft);
469  auto cmxCpmTobsIsolRight = Monitored::Collection("cmxCpmTobsIsolRight", monCmxCpTobIsolRight, []( const auto &tob ){return tob.tob->isolation();} );
470  variables.push_back(cmxCpmTobsIsolRight);
471 
472  auto cmxCpmTobsIsolXLeft = Monitored::Collection("cmxCpmTobsIsolXLeft", monCmxCpTobIsolLeft, []( const auto &tob ){return tob.x;} );
473  variables.push_back(cmxCpmTobsIsolXLeft);
474  auto cmxCpmTobsIsolYLeft = Monitored::Collection("cmxCpmTobsIsolYLeft", monCmxCpTobIsolLeft, []( const auto &tob ){return tob.y;} );
475  variables.push_back(cmxCpmTobsIsolYLeft);
476  auto cmxCpmTobsIsolXRight = Monitored::Collection("cmxCpmTobsIsolXRight", monCmxCpTobIsolRight, []( const auto &tob ){return tob.x;} );
477  variables.push_back(cmxCpmTobsIsolXRight);
478  auto cmxCpmTobsIsolYRight = Monitored::Collection("cmxCpmTobsIsolYRight", monCmxCpTobIsolRight, []( const auto &tob ){return tob.y;} );
479  variables.push_back(cmxCpmTobsIsolYRight);
480 
481  // errors
482  auto cmxCpmTobsErrorX = Monitored::Collection("cmxCpmTobsErrorX", monCmxCpTobError, []( const auto &tob ){return tob.x;} );
483  variables.push_back(cmxCpmTobsErrorX);
484  auto cmxCpmTobsErrorCmx = Monitored::Collection("cmxCpmTobsErrorCmx", monCmxCpTobError, []( const auto &tob ){return tob.tob->cmx();} );
485  variables.push_back(cmxCpmTobsErrorCmx);
486  auto cmxCpmTobsErrorYbase = Monitored::Collection("cmxCpmTobsErrorYbase", monCmxCpTobError, []( const auto &tob ){return tob.ybaseError;} );
487  variables.push_back(cmxCpmTobsErrorYbase);
488  // parity error mask
489  auto cmxCpmTobsErrorParity = Monitored::Collection("cmxCpmTobsErrorParity", monCmxCpTobError, []( const auto &tob ){return tob.parityError;} );
490  variables.push_back(cmxCpmTobsErrorParity);
491 
492  //
493  //=============================================
494  // CMX-CP Hits
495  //=============================================
496 
497  std::vector<MonitorCmxCpHits> monCmxCpHits;
498  std::vector<MonitorCmxCpHits> monCmxCpHitsLeft;
499  std::vector<MonitorCmxCpHits> monCmxCpHitsRight;
500 
501  // scalars to fill bitwise histograms directly
502  Monitored::Scalar<int> cmxCpMapX = Monitored::Scalar<int>("cmxCpMapX", 0);
503  Monitored::Scalar<int> cmxCpMapY = Monitored::Scalar<int>("cmxCpMapY", 0);
504  Monitored::Scalar<int> cmxCpMapHit = Monitored::Scalar<int>("cmxCpMapHit", 0);
505  Monitored::Scalar<int> cmxCpCountsX = Monitored::Scalar<int>("cmxCpCountsX", 0);
506  Monitored::Scalar<int> cmxCpCountsY = Monitored::Scalar<int>("cmxCpCountsY", 0);
507  Monitored::Scalar<int> cmxCpCountsHit = Monitored::Scalar<int>("cmxCpCountsHit", 0);
508  //
509  Monitored::Scalar<int> cmxTopoTobsCpmRight = Monitored::Scalar<int>("cmxTopoTobsCpmRight", 0);
510  Monitored::Scalar<int> cmxTopoTobsCpmLeft = Monitored::Scalar<int>("cmxTopoTobsCpmLeft", 0);
511  //
512  Monitored::Scalar<int> cmxCpThresBinLeftX = Monitored::Scalar<int>("cmxCpThresBinLeftX", 0);
513  Monitored::Scalar<int> cmxCpThresBinLeftY = Monitored::Scalar<int>("cmxCpThresBinLeftY", 0);
514  Monitored::Scalar<int> cmxCpThresBinLeftHit = Monitored::Scalar<int>("cmxCpThresBinLeftHit", 0);
515  Monitored::Scalar<int> cmxCpThresBinRightX = Monitored::Scalar<int>("cmxCpThresBinRightX", 0);
516  Monitored::Scalar<int> cmxCpThresBinRightY = Monitored::Scalar<int>("cmxCpThresBinRightY", 0);
517  Monitored::Scalar<int> cmxCpThresBinRightHit = Monitored::Scalar<int>("cmxCpThresBinRightHit", 0);
518 
519  cmxCount.assign(m_crates * 2, 0);
520  xAOD::CMXCPHitsContainer::const_iterator cmIterator = (*cmxCpHitsTES).begin();
521  xAOD::CMXCPHitsContainer::const_iterator cmIteratorEnd = (*cmxCpHitsTES).end();
522  for (; cmIterator != cmIteratorEnd; ++cmIterator) {
523  const uint32_t hits0 = (*cmIterator)->hits0();
524  const uint32_t hits1 = (*cmIterator)->hits1();
525  const uint8_t crate = (*cmIterator)->crate();
526  const uint8_t cmx = (*cmIterator)->cmx();
527  const uint8_t source = (*cmIterator)->sourceComponent();
528  const uint8_t slices = ((*cmIterator)->hitsVec0()).size();
529  const uint8_t crateCmx = crate * 2 + cmx;
530 
531  //
532  MonitorCmxCpHits monCmxCpHit;
533  monCmxCpHit.hit=(*cmIterator);
534  monCmxCpHit.crateCmx=crateCmx;
535  monCmxCpHit.srcTopoCheckSum=false;
536  monCmxCpHit.crateSlices=crate * m_maxSlices + slices - 1;
537  if (source == xAOD::CMXCPHits::TOPO_CHECKSUM) {
538  monCmxCpHit.srcTopoCheckSum=true;
539  } else if (source == xAOD::CMXCPHits::TOPO_OCCUPANCY_MAP) {
540  if (hits0) {
541  const int nBits = 1;
542  const int offset = 1;
543  const int mask = (1 << nBits) - 1;
544  for (int thr = 0; thr < m_modules; ++thr) {
545  const int hit = (hits0 >> (nBits*thr)) & mask;
546  if (hit) {
547  cmxCpMapX=thr+offset;
548  cmxCpMapY=crateCmx;
549  cmxCpMapHit=hit;
550  fill(m_packageName,cmxCpMapX,cmxCpMapY,cmxCpMapHit);
551  }
552  }
553  }
554  } else if (source == xAOD::CMXCPHits::TOPO_OCCUPANCY_COUNTS) {
555 
556  if (hits0) {
557  const int nBits = 3;
558  const int offset = 1;
559  const int mask = (1 << nBits) - 1;
560  for (int thr = 0; thr < (m_modules/2); ++thr) {
561  const int hit = (hits0 >> (nBits*thr)) & mask;
562  if (hit) {
563  cmxCpCountsX=thr+offset;
564  cmxCpCountsY=crateCmx;
565  cmxCpCountsHit=hit;
566  fill(m_packageName,cmxCpCountsX,cmxCpCountsY,cmxCpCountsHit);
567  }
568  }
569  }
570  for (int mod = 0; mod < m_modules / 2; ++mod) {
571  const int val = (hits0 >> (mod * 3)) & 0x7;
572  if (val) {
573  if (cmx) {
574  cmxTopoTobsCpmRight=val;
575  fill(m_packageName,cmxTopoTobsCpmRight);
576  } else {
577  cmxTopoTobsCpmLeft=val;
578  fill(m_packageName,cmxTopoTobsCpmLeft);
579  }
580  }
581  cmxCount[crate * 2 + cmx] += val;
582  } // hits0
583 
584  if (hits1) {
585  const int nBits = 3;
586  const int offset = m_modules / 2 + 1;
587  const int mask = (1 << nBits) - 1;
588  for (int thr = 0; thr < (m_modules/2); ++thr) {
589  const int hit = (hits1 >> (nBits*thr)) & mask;
590  if (hit) {
591  cmxCpCountsX=thr+offset;
592  cmxCpCountsY=crateCmx;
593  cmxCpCountsHit=hit;
594  fill(m_packageName,cmxCpCountsX,cmxCpCountsY,cmxCpCountsHit);
595  }
596  }
597  for (int mod = 0; mod < m_modules / 2; ++mod) {
598  const int val = (hits1 >> (mod * 3)) & 0x7;
599  if (val) {
600  if (cmx) {
601  cmxTopoTobsCpmRight=val;
602  fill(m_packageName,cmxTopoTobsCpmRight);
603  } else {
604  cmxTopoTobsCpmLeft=val;
605  fill(m_packageName,cmxTopoTobsCpmLeft);
606  }
607  }
608  cmxCount[crate * 2 + cmx] += val;
609  }
610  } // hits1
611  } else {
612  int bin = 0;
613  if (source == xAOD::CMXCPHits::LOCAL) bin = crate;
614  else if (source == xAOD::CMXCPHits::REMOTE_0) bin = m_crates;
615  else if (source == xAOD::CMXCPHits::REMOTE_1) bin = m_crates + 1;
616  else if (source == xAOD::CMXCPHits::REMOTE_2) bin = m_crates + 2;
617  else if (source == xAOD::CMXCPHits::TOTAL) bin = m_crates + 3;
618  const int nThresh = m_thresholds / 2;
619  if (hits0) {
620  const int nBits = m_threshBits;
621  const int offset = 0;
622  const int mask = (1 << nBits) - 1;
623 
624  for (int thr = 0; thr < nThresh; ++thr) {
625  const int hit = (hits0 >> (nBits*thr)) & mask;
626  if (hit) {
627  if (cmx) {
628  cmxCpThresBinRightX=bin;
629  cmxCpThresBinRightY=thr+offset;
630  cmxCpThresBinRightHit=hit;
631  fill(m_packageName,cmxCpThresBinRightX,cmxCpThresBinRightY,cmxCpThresBinRightHit);
632  } else {
633  cmxCpThresBinLeftX=bin;
634  cmxCpThresBinLeftY=thr+offset;
635  cmxCpThresBinLeftHit=hit;
636  fill(m_packageName,cmxCpThresBinLeftX,cmxCpThresBinLeftY,cmxCpThresBinLeftHit);
637  }
638  }
639  }
640  } // hits0
641 
642  if (hits1) {
643  //
644  const int nBits = 3;
645  const int offset = nThresh;
646  const int mask = (1 << nBits) - 1;
647  for (int thr = 0; thr < nThresh; ++thr) {
648  const int hit = (hits1 >> (nBits*thr)) & mask;
649  if (hit) {
650  if (cmx) {
651  cmxCpThresBinRightX=bin;
652  cmxCpThresBinRightY=thr+offset;
653  cmxCpThresBinRightHit=hit;
654  fill(m_packageName,cmxCpThresBinRightX,cmxCpThresBinRightY,cmxCpThresBinRightHit);
655  } else {
656  cmxCpThresBinLeftX=bin;
657  cmxCpThresBinLeftY=thr+offset;
658  cmxCpThresBinLeftHit=hit;
659  fill(m_packageName,cmxCpThresBinLeftX,cmxCpThresBinLeftY,cmxCpThresBinLeftHit);
660  }
661  }
662  }
663  } // hits1
664 
665  }
666 
667  monCmxCpHits.push_back(monCmxCpHit);
668  if (cmx)
669  monCmxCpHitsRight.push_back(monCmxCpHit);
670  else
671  monCmxCpHitsLeft.push_back(monCmxCpHit);
672 
673  } //CmxCpHitsCollection iterator
674  //
675  auto cmxCpmHitsPeak = Monitored::Collection("cmxCpHitsPeak", monCmxCpHits, []( const auto &hit ){return hit.hit->peak();} );
676  variables.push_back(cmxCpmHitsPeak);
677  auto cmxCpmHitsCrateSlices = Monitored::Collection("cmxCpHitsCrateSlices", monCmxCpHits, []( const auto &hit ){return hit.crateSlices;} );
678  variables.push_back(cmxCpmHitsCrateSlices);
679  auto cmxCpmHitsCrateCmx = Monitored::Collection("cmxCpHitsCrateCmx", monCmxCpHits, []( const auto &hit ){return hit.crateCmx;} );
680  variables.push_back(cmxCpmHitsCrateCmx);
681  // for masks
682  auto cmxCpmHitsHits0 = Monitored::Collection("cmxCpHitsHits0", monCmxCpHits, []( const auto &hit ){return hit.hit->hits0();} );
683  variables.push_back(cmxCpmHitsHits0);
684  auto cmxCpmHitsHits1 = Monitored::Collection("cmxCpHitsHits1", monCmxCpHits, []( const auto &hit ){return hit.hit->hits1();} );
685  variables.push_back(cmxCpmHitsHits1);
686  // mask for checksum plus hits0
687  auto cmxCpmHits0TopoCheckSum = Monitored::Collection("cmxCpHits0TopoCheckSum", monCmxCpHits, []( const auto &hit ){return (hit.hit->hits0() && hit.srcTopoCheckSum);} );
688  variables.push_back(cmxCpmHits0TopoCheckSum);
689 
690  // CMX-CP Topo Tobs
691  Monitored::Scalar<int> cmxCpTopoTobsCmxLeft = Monitored::Scalar<int>("cmxCpTopoTobsCmxLeft", 0);
692  Monitored::Scalar<int> cmxCpTopoTobsCmxRight = Monitored::Scalar<int>("cmxCpTopoTobsCmxRight", 0);
693  for (int crate = 0; crate < m_crates; ++crate) {
694  for (int cmx = 0; cmx < 2; ++cmx) {
695  int val = cmxCount[crate * 2 + cmx];
696  if (val) {
697  if (val >= m_maxTobsPerCmx) val = m_maxTobsPerCmx - 1;
698  if (cmx == 0) {
699  cmxCpTopoTobsCmxLeft=val;
700  fill(m_packageName,cmxCpTopoTobsCmxLeft);
701  } else {
702  cmxCpTopoTobsCmxRight=val;
703  fill(m_packageName,cmxCpTopoTobsCmxRight);
704  }
705  }
706  }
707  }
708 
709  // Update error summary plot
710  Monitored::Scalar<int> cpmErrorX = Monitored::Scalar<int>("cpmErrorX", 0);
711  Monitored::Scalar<int> cpmErrorY = Monitored::Scalar<int>("cpmErrorY", 0);
712  Monitored::Scalar<int> cpmErrorSummary = Monitored::Scalar<int>("cpmErrorSummary", 0);
713  Monitored::Scalar<int> cpmErrorSummary_Events = Monitored::Scalar<int>("cpmErrorSummary_Events", 0);
714  std::vector<int> crateErr(4);
715  for (int err = 0; err < NumberOfSummaryBins; ++err) {
716  int error = 0;
717  for (int loc = 0; loc < m_crates * m_modules; ++loc) {
718  if ((errorsCPM[loc] >> err) & 0x1) {
719  cpmErrorX=loc;
720  cpmErrorY=err;
721  fill(m_packageName,cpmErrorX,cpmErrorY);
722  error = 1;
723  crateErr[loc / m_modules] |= (1 << err);
724  }
725  if (loc < m_crates * 2) {
726  if ((errorsCMX[loc] >> err) & 0x1) {
727  cpmErrorX=loc+(m_crates*m_modules);
728  cpmErrorY=err;
729  fill(m_packageName,cpmErrorX,cpmErrorY);
730  error = 1;
731  crateErr[loc / 2] |= (1 << err);
732  }
733  }
734  }
735  if (error) {
736  cpmErrorSummary=err;
737  fill(m_packageName,cpmErrorSummary);
738  // event numbers
739  cpmErrorSummary_Events=err;
740  auto evtstr = Monitored::Scalar<std::string>("evtstr", std::to_string(ctx.eventID().event_number()));
741  fill(m_packageName,evtstr,cpmErrorSummary_Events);
742  }
743  } // NSummaryBins
744 
745 
746  // Save error vector for global summary
747 
748  auto save = std::make_unique<std::vector<int>>(crateErr);
749  auto* result = SG::makeHandle(m_errorLocation, ctx).put(std::move(save));
750  if (!result) {
751  ATH_MSG_ERROR("Error recording CPM error vector in TES");
752  return StatusCode::FAILURE;
753  }
754 
755  fill(m_packageName,variables);
756  variables.clear();
757  return StatusCode::SUCCESS;
758 }
759 
760 
761 std::vector<bool> CpmMonitorAlgorithm::getIsolationBits(int val, int nThresh, int nBits) const
762 {
763  // return vector of threshold bits
764  //
765  std::vector<bool> nthres(nThresh, false);
766 
767  if (val) {
768  const int mask = (1 << nBits) - 1;
769  for (int thr = 0; thr < nThresh; ++thr) {
770  const int hit = (val >> (nBits*thr)) & mask;
771  nthres[thr] = bool(hit);
772  }
773  } else {
774  ATH_MSG_WARNING("getIsolationBits: no input word supplied" );
775  }
776  return nthres;
777 
778 }
779 
780 StatusCode CpmMonitorAlgorithm::fillCpmTowerVectors(SG::ReadHandle<xAOD::CPMTowerContainer> &cpmTower,
781  std::vector<MonitorCpmTT> &monCpmTTs_em, std::vector<MonitorCpmTT> &monCpmTTs_had,
782  std::vector<int> &errorsCPM,
783  bool core,
784  Monitored::Scalar<int> &cpmLoc,
785  Monitored::Scalar<int> &GLinkParityError
786  ) const
787 {
788  //
789  xAOD::CPMTowerContainer::const_iterator ctIterator = (*cpmTower).begin();
790  xAOD::CPMTowerContainer::const_iterator ctIteratorEnd = (*cpmTower).end();
791  for (; ctIterator != ctIteratorEnd; ++ctIterator) {
792  const xAOD::CPMTower* ct = *ctIterator;
793  const uint8_t em = ct->emEnergy();
794  const uint8_t had = ct->hadEnergy();
795  const double eta = ct->eta();
796  const double phi = ct->phi();
797  const LVL1::Coordinate coord(phi, eta);
798  LVL1::CoordToHardware converter;
799  const int crate = (core) ? converter.cpCrate(coord)
800  : converter.cpCrateOverlap(coord);
801  const int cpm = (core) ? converter.cpModule(coord)
802  : converter.cpModuleOverlap(coord);
803  const unsigned int loc = crate * m_modules + cpm - 1;
804  const int slices = (ct->emEnergyVec()).size();
805  const int slice = crate * m_maxSlices + slices - 1;
806  if (loc >= errorsCPM.size()) {
807  ATH_MSG_ERROR("Crate/module index out of range: " << loc << " >= "
808  << errorsCPM.size() << " crate " << crate
809  << " core " << core
810  << " eta " << eta << " phi " << phi <<
811  " cpm " << cpm << " slices " << slices <<
812  " max slices " << m_maxSlices << " m_modules " << m_modules <<
813  " slice " << slice);
814  }
815 
816  // Errors
817  bool emParityError=false;
818  bool emLinkDownError=false;
819  uint32_t error = ct->emError();
820  if (error && loc < errorsCPM.size()) {
821  const LVL1::DataError emError(error);
822  if (emError.get(LVL1::DataError::Parity)) {
823  emParityError=true;
824  errorsCPM[loc] |= (1 << EMParity);
825  }
826  if (emError.get(LVL1::DataError::LinkDown)) {
827  emLinkDownError=true;
828  errorsCPM[loc] |= (1 << EMLink);
829  }
830  const int status = (error >> LVL1::DataError::GLinkParity) & 0xff;
831  if (status) {
832  cpmLoc=loc;
833  for (int bit = 0; bit < 8; ++bit) {
834  if ((status >> bit) & 0x1) {
835  GLinkParityError=bit;
836  fill(m_packageName, GLinkParityError, cpmLoc);
837  }
838  }
839  errorsCPM[loc] |= (1 << CPMStatus);
840  }
841  }
842 
843  bool hadParityError=false;
844  bool hadLinkDownError=false;
845  error = ct->hadError();
846  if (error && loc < errorsCPM.size()) {
847  const LVL1::DataError hadError(error);
848  if (hadError.get(LVL1::DataError::Parity)) {
849  hadParityError=true;
850  errorsCPM[loc] |= (1 << HadParity);
851  }
852  if (hadError.get(LVL1::DataError::LinkDown)) {
853  hadLinkDownError=true;
854  errorsCPM[loc] |= (1 << HadLink);
855  }
856  }
857  // fill tower vector for plots
858  MonitorCpmTT monTT;
859  monTT.ttower=ct;
860  monTT.phi_scaled=ct->phi()*m_phiScaleTT;
861  monTT.slice=slice;
862  monTT.emParityError=emParityError;
863  monTT.emLinkDownError=emLinkDownError;
864  monTT.hadParityError=hadParityError;
865  monTT.hadLinkDownError=hadLinkDownError;
866  if (em) {
867  monCpmTTs_em.push_back(monTT);
868  }
869  if (had) {
870  monCpmTTs_had.push_back(monTT);
871  }
872 
873  } // iterator
874 
875 
876  return StatusCode::SUCCESS;
877 }
878 
879 
CpmMonitorAlgorithm::MonitorCmxCpTob::ybase
int ybase
Definition: CpmMonitorAlgorithm.h:55
CpmMonitorAlgorithm::m_thresholds
Gaudi::Property< int > m_thresholds
Definition: CpmMonitorAlgorithm.h:84
LVL1::CoordToHardware::cpModuleOverlap
unsigned int cpModuleOverlap(const Coordinate &coord)
return ID of CP module for overlap coord
Definition: CoordToHardware.cxx:213
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
LVL1::DataError::LinkDown
@ LinkDown
Definition: DataError.h:31
CpmMonitorAlgorithm::CPMStatus
@ CPMStatus
Definition: CpmMonitorAlgorithm.h:91
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
LVL1::DataError
Error data.
Definition: DataError.h:27
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::CMXCPHits_v1::REMOTE_2
@ REMOTE_2
Definition: CMXCPHits_v1.h:29
checkCoolLatestUpdate.variables
variables
Definition: checkCoolLatestUpdate.py:13
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
CpmMonitorAlgorithm::HadParity
@ HadParity
Definition: CpmMonitorAlgorithm.h:91
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
python.LArCondContChannels.decoder
decoder
def channelSelection(self, channelList, groupType): if groupType == self.SingleGroup: pass elif group...
Definition: LArCondContChannels.py:618
CpmMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: CpmMonitorAlgorithm.cxx:46
CpmMonitorAlgorithm::m_packageName
StringProperty m_packageName
Definition: CpmMonitorAlgorithm.h:76
CpmMonitorAlgorithm::NumberOfSummaryBins
@ NumberOfSummaryBins
Definition: CpmMonitorAlgorithm.h:92
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
CpmMonitorAlgorithm::m_crates
Gaudi::Property< int > m_crates
Definition: CpmMonitorAlgorithm.h:78
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
LVL1::DataError::ParityPhase0
@ ParityPhase0
Definition: DataError.h:37
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
CpmMonitorAlgorithm::fillCpmTowerVectors
StatusCode fillCpmTowerVectors(SG::ReadHandle< xAOD::CPMTowerContainer > &cpmTower, std::vector< MonitorCpmTT > &monCpmTTs_em, std::vector< MonitorCpmTT > &monCpmTTs_had, std::vector< int > &errorsCPM, bool core, Monitored::Scalar< int > &cpmLoc, Monitored::Scalar< int > &GLinkParityError) const
Definition: CpmMonitorAlgorithm.cxx:780
CpmMonitorAlgorithm::m_maxSlices
Gaudi::Property< int > m_maxSlices
Definition: CpmMonitorAlgorithm.h:80
CPRoIDecoder.h
CpmMonitorAlgorithm::MonitorCmxCpHits::crateCmx
uint8_t crateCmx
Definition: CpmMonitorAlgorithm.h:65
CpmMonitorAlgorithm::getIsolationBits
std::vector< bool > getIsolationBits(int val, int nThresh, int nBits) const
Definition: CpmMonitorAlgorithm.cxx:761
M_PI
#define M_PI
Definition: ActiveFraction.h:11
bin
Definition: BinsDiffFromStripMedian.h:43
CpmMonitorAlgorithm::EMLink
@ EMLink
Definition: CpmMonitorAlgorithm.h:91
LVL1::DataError::ParityPhase1
@ ParityPhase1
Definition: DataError.h:37
CpmMonitorAlgorithm::m_cmxCpHitsLocation
SG::ReadHandleKey< xAOD::CMXCPHitsContainer > m_cmxCpHitsLocation
Definition: CpmMonitorAlgorithm.h:101
LVL1::DataError::GLinkParity
@ GLinkParity
Definition: DataError.h:40
CoordToHardware.h
CpmMonitorAlgorithm.h
x
#define x
CpmMonitorAlgorithm::MonitorTT
Definition: CpmMonitorAlgorithm.h:25
CpmMonitorAlgorithm::MonitorCmxCpTob::tob
const xAOD::CMXCPTob_v1 * tob
Definition: CpmMonitorAlgorithm.h:51
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
xAOD::CMXCPHits_v1::TOPO_OCCUPANCY_MAP
@ TOPO_OCCUPANCY_MAP
Definition: CMXCPHits_v1.h:30
CpmMonitorAlgorithm::m_cpmTowerLocationOverlap
SG::ReadHandleKey< xAOD::CPMTowerContainer > m_cpmTowerLocationOverlap
Definition: CpmMonitorAlgorithm.h:98
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
checkTP.save
def save(self, fileName="./columbo.out")
Definition: checkTP.py:178
LVL1::CoordinateRange
CoordinateRange class declaration.
Definition: CoordinateRange.h:36
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
LVL1::DataError::Overflow
@ Overflow
Definition: DataError.h:31
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:193
LVL1::Coordinate
Coordinate class declaration.
Definition: TrigT1/TrigT1Interfaces/TrigT1Interfaces/Coordinate.h:50
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
xAOD::CMXCPHits_v1::TOTAL
@ TOTAL
Definition: CMXCPHits_v1.h:29
CpmMonitorAlgorithm::MonitorTobRoI::tobroi
const xAOD::CPMTobRoI_v1 * tobroi
Definition: CpmMonitorAlgorithm.h:43
CpmMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: CpmMonitorAlgorithm.cxx:16
CpmMonitorAlgorithm::MonitorCpmTT::emLinkDownError
bool emLinkDownError
Definition: CpmMonitorAlgorithm.h:37
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
python.sizes.location
string location
Definition: sizes.py:11
CpmMonitorAlgorithm::MonitorCpmTT::hadParityError
bool hadParityError
Definition: CpmMonitorAlgorithm.h:38
CpmMonitorAlgorithm::MonitorCmxCpTob::y
uint8_t y
Definition: CpmMonitorAlgorithm.h:54
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
CpmMonitorAlgorithm::MonitorCpmTT::hadLinkDownError
bool hadLinkDownError
Definition: CpmMonitorAlgorithm.h:39
CpmMonitorAlgorithm::MonitorCpmTT::ttower
const xAOD::CPMTower_v2 * ttower
Definition: CpmMonitorAlgorithm.h:31
xAOD::TriggerTower_v2
Description of TriggerTower_v2.
Definition: TriggerTower_v2.h:49
CpmMonitorAlgorithm::MonitorTobRoI
Definition: CpmMonitorAlgorithm.h:42
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CpmMonitorAlgorithm::m_tobsPerCPM
Gaudi::Property< int > m_tobsPerCPM
Definition: CpmMonitorAlgorithm.h:81
LVL1::CoordToHardware::cpModule
unsigned int cpModule(const Coordinate &coord)
return ID of CP module.
Definition: CoordToHardware.cxx:52
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
CpmMonitorAlgorithm::MonitorCmxCpHits::hit
const xAOD::CMXCPHits_v1 * hit
Definition: CpmMonitorAlgorithm.h:62
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::DataError::Parity
@ Parity
Definition: DataError.h:31
CpmMonitorAlgorithm::MonitorCmxCpHits
Definition: CpmMonitorAlgorithm.h:61
CpmMonitorAlgorithm::m_maxTobsPerCmx
Gaudi::Property< int > m_maxTobsPerCmx
Definition: CpmMonitorAlgorithm.h:85
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
calibdata.ct
ct
Definition: calibdata.py:418
DataError.h
CpmMonitorAlgorithm::MonitorTT::ttower
const xAOD::TriggerTower_v2 * ttower
Definition: CpmMonitorAlgorithm.h:26
xAOD::CMXCPHits_v1::LOCAL
@ LOCAL
Definition: CMXCPHits_v1.h:29
CpmMonitorAlgorithm::MonitorCmxCpHits::crateSlices
uint8_t crateSlices
Definition: CpmMonitorAlgorithm.h:64
LVL1::CoordToHardware
returns the trigger hardware components associated with a given Coordinate
Definition: CoordToHardware.h:42
CpmMonitorAlgorithm::m_isolBits
Gaudi::Property< int > m_isolBits
Definition: CpmMonitorAlgorithm.h:82
CpmMonitorAlgorithm::MonitorTobRoI::etaMod
double etaMod
Definition: CpmMonitorAlgorithm.h:45
LVL1::DataError::ParityMerge
@ ParityMerge
Definition: DataError.h:37
CpmMonitorAlgorithm::m_cpmTobRoiLocation
SG::ReadHandleKey< xAOD::CPMTobRoIContainer > m_cpmTobRoiLocation
Definition: CpmMonitorAlgorithm.h:99
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
CpmMonitorAlgorithm::m_xAODTriggerTowerContainerName
SG::ReadHandleKey< xAOD::TriggerTowerContainer > m_xAODTriggerTowerContainerName
Definition: CpmMonitorAlgorithm.h:96
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
LVL1::CoordToHardware::cpCrate
unsigned int cpCrate(const Coordinate &coord)
returns crate ID covering that coord.
Definition: CoordToHardware.cxx:39
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
CpmMonitorAlgorithm::MonitorTobRoI::phiMod
double phiMod
Definition: CpmMonitorAlgorithm.h:46
CpmMonitorAlgorithm::MonitorCmxCpTob::ybaseError
int ybaseError
Definition: CpmMonitorAlgorithm.h:58
xAOD::CMXCPHits_v1::REMOTE_0
@ REMOTE_0
Definition: CMXCPHits_v1.h:29
CpmMonitorAlgorithm::MonitorCpmTT
Definition: CpmMonitorAlgorithm.h:30
xAOD::CMXCPHits_v1::REMOTE_1
@ REMOTE_1
Definition: CMXCPHits_v1.h:29
JetVoronoiDiagramHelpers::coord
double coord
Definition: JetVoronoiDiagramHelpers.h:45
CpmMonitorAlgorithm::MonitorCmxCpHits::srcTopoCheckSum
bool srcTopoCheckSum
Definition: CpmMonitorAlgorithm.h:67
xAOD::CMXCPHits_v1::TOPO_OCCUPANCY_COUNTS
@ TOPO_OCCUPANCY_COUNTS
Definition: CMXCPHits_v1.h:30
LVL1::CoordToHardware::cpCrateOverlap
unsigned int cpCrateOverlap(const Coordinate &coord)
returns crate ID covering that overlap coord.
Definition: CoordToHardware.cxx:205
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
CpmMonitorAlgorithm::MonitorTT::phi_scaled
double phi_scaled
Definition: CpmMonitorAlgorithm.h:27
LVL1::CPRoIDecoder
A level 1 calorimeter trigger conversion service: returns the Coordinate represented by a RoI word.
Definition: CPRoIDecoder.h:37
y
#define y
CpmMonitorAlgorithm::MonitorCmxCpTob::parityError
bool parityError
Definition: CpmMonitorAlgorithm.h:57
CpmMonitorAlgorithm::m_threshBits
Gaudi::Property< int > m_threshBits
Definition: CpmMonitorAlgorithm.h:83
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
CpmMonitorAlgorithm::MonitorCpmTT::emParityError
bool emParityError
Definition: CpmMonitorAlgorithm.h:36
CpmMonitorAlgorithm::m_errorLocation
SG::WriteHandleKey< std::vector< int > > m_errorLocation
Definition: CpmMonitorAlgorithm.h:88
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
CpmMonitorAlgorithm::MonitorCmxCpTob
Definition: CpmMonitorAlgorithm.h:49
CpmMonitorAlgorithm::m_phiScaleTT
double m_phiScaleTT
Definition: CpmMonitorAlgorithm.h:74
LVL1::DataError::ParityPhase3
@ ParityPhase3
Definition: DataError.h:38
CpmMonitorAlgorithm::m_cmxCpTobLocation
SG::ReadHandleKey< xAOD::CMXCPTobContainer > m_cmxCpTobLocation
Definition: CpmMonitorAlgorithm.h:100
merge.status
status
Definition: merge.py:17
CpmMonitorAlgorithm::TOBParity
@ TOBParity
Definition: CpmMonitorAlgorithm.h:92
CpmMonitorAlgorithm::MonitorCpmTT::slice
int slice
Definition: CpmMonitorAlgorithm.h:34
CpmMonitorAlgorithm::m_cpmTowerLocation
SG::ReadHandleKey< xAOD::CPMTowerContainer > m_cpmTowerLocation
Definition: CpmMonitorAlgorithm.h:97
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
LVL1::DataError::get
int get(ErrorBit bit) const
Return an error bit or data.
Definition: DataError.cxx:48
fillSCTHists.etaMod
etaMod
Definition: fillSCTHists.py:23
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
error
Definition: IImpactPoint3dEstimator.h:70
TileDCSDataPlotter.tt
tt
Definition: TileDCSDataPlotter.py:874
CpmMonitorAlgorithm::MonitorCmxCpTob::x
uint8_t x
Definition: CpmMonitorAlgorithm.h:53
CpmMonitorAlgorithm::MonitorCpmTT::phi_scaled
double phi_scaled
Definition: CpmMonitorAlgorithm.h:33
CpmMonitorAlgorithm::m_modules
Gaudi::Property< int > m_modules
Definition: CpmMonitorAlgorithm.h:79
LVL1::DataError::ParityPhase2
@ ParityPhase2
Definition: DataError.h:38
CpmMonitorAlgorithm::EMParity
@ EMParity
Definition: CpmMonitorAlgorithm.h:91
keylayer_zslicemap.slices
slices
Definition: keylayer_zslicemap.py:112
xAOD::CMXCPHits_v1::TOPO_CHECKSUM
@ TOPO_CHECKSUM
Definition: CMXCPHits_v1.h:30
xAOD::CPMTower_v2
Description of CPMTower_v2.
Definition: CPMTower_v2.h:26
CpmMonitorAlgorithm::CpmMonitorAlgorithm
CpmMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: CpmMonitorAlgorithm.cxx:10
CpmMonitorAlgorithm::HadLink
@ HadLink
Definition: CpmMonitorAlgorithm.h:91
Generated on Thu Jul 4 2024 21:13:01 for ATLAS Offline Software by   doxygen 1.8.18