User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.
46 {
47
49
50
52
54
55
58
59
62
63
66
67
70
71
74
75
76
77 std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>> variables;
78
79
80
81 std::vector<MonitorTT> monTTs;
84 for (; ttIterator != ttIteratorEnd; ++ttIterator) {
85 const int layer = (*ttIterator)->layer();
87 const double eta = (*ttIterator)->eta();
88 if ( std::abs(
eta) > 2.5)
continue;
89
90 if (!tt->cpET()) continue;
91
92 if (layer == 0) {
93 const int em = int(tt->cpET());
94 if (em) {
96 monTT.
ttower=(*ttIterator);
97 monTT.
phi_scaled=(*ttIterator)->phi()*m_phiScaleTT;
98 monTTs.push_back(monTT);
99 }
100 }
101 if (layer == 1) {
102 const int had =
int(
tt->cpET());
103 if (had) {
105 monTT.
ttower=(*ttIterator);
107 monTTs.push_back(monTT);
108 }
109 }
110 }
111
112
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
119
120
121
122
123 std::vector<int> errorsCPM(m_crates * m_modules);
124 std::vector<int> errorsCMX(m_crates * 2);
125
126 std::vector<MonitorCpmTT> monCpmTTs_em;
127 std::vector<MonitorCpmTT> monCpmTTs_had;
128
129 Monitored::Scalar<int> GLinkParityError = Monitored::Scalar<int>("GLinkParityError", 0);
130 Monitored::Scalar<int> cpmLoc = Monitored::Scalar<int>("cpmLoc", 0);
131 bool core=true;
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
139 auto etCpmTT_em =
Monitored::Collection(
"etCpmTT_em", monCpmTTs_em, [](
const auto &tt ){
return tt.ttower->emEnergy();} );
variables.push_back( etCpmTT_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
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
156 auto etaCpmTT_em_tot =
Monitored::Collection(
"etaCpmTT_em_tot", monCpmTTs_em_tot, [](
const auto &tt ){
return tt.ttower->eta();} );
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();} );
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
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
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();} );
182 auto sliceCpmTT_tot =
Monitored::Collection(
"sliceCpmTT_tot", monCpmTTs_tot, [](
const auto &tt ){
return tt.slice;} );
184
185
186
187
188
189 std::vector<MonitorTobRoI> monTobRoIsEner;
190 std::vector<MonitorTobRoI> monTobRoIsIsol;
191
193 std::vector<int> tobCount(vecSize);
197
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();
204 const int energy = (*crIterator)->energy();
205 const int isolation = (*crIterator)->isolation();
206 const LVL1::CoordinateRange
coord(
decoder.coordinate((*crIterator)->roiWord()));
211 if (energy) {
213 monTobRoI.
tobroi=(*crIterator);
215 monTobRoI.phiMod=phiMod;
216 monTobRoIsEner.push_back(monTobRoI);
217 }
218 if (isolation) {
219
222 if (isolbits[thr]){
223 if(type==0) {
225 thresholdWeightsEm = isolbits[
thr];
226 fill(m_packageName, thresholdsEm, thresholdWeightsEm);
227 } else {
229 thresholdWeightsTau = isolbits[
thr];
230 fill(m_packageName, thresholdsTau, thresholdWeightsTau);
231 }
232 }
233 }
234
236 monTobRoI.
tobroi=(*crIterator);
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
246 auto etaTobRoIsEner =
Monitored::Collection(
"etaTobRoIsEner", monTobRoIsEner, [](
const auto &roi ){
return roi.etaMod;} );
248 auto phiTobRoIsEner =
Monitored::Collection(
"phiTobRoIsEner", monTobRoIsEner, [](
const auto &roi ){
return roi.phiMod;} );
250 auto energyTobRoIsEner =
Monitored::Collection(
"energyTobRoIsEner", monTobRoIsEner, [](
const auto &roi ){
return roi.tobroi->energy();} );
252 auto typeTobRoIsEner =
Monitored::Collection(
"typeTobRoIsEner", monTobRoIsEner, [](
const auto &roi ){
return roi.tobroi->type();} );
254
255
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
262 auto etaTobRoIsIsol =
Monitored::Collection(
"etaTobRoIsIsol", monTobRoIsIsol, [](
const auto &roi ){
return roi.etaMod;} );
264 auto phiTobRoIsIsol =
Monitored::Collection(
"phiTobRoIsIsol", monTobRoIsIsol, [](
const auto &roi ){
return roi.phiMod;} );
266 auto energyTobRoIsIsol =
Monitored::Collection(
"energyTobRoIsIsol", monTobRoIsIsol, [](
const auto &roi ){
return roi.tobroi->isolation();} );
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
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) {
284 if (type == 0) {
285 tobCountEm.push_back(val);
286 } else {
287 tobCountTau.push_back(val);
288 }
289 }
290 }
291 }
292 }
295
296
297
298
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);
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();
319 const uint8_t cmx = (*cmxCpTobIter)->cmx();
320 const uint8_t chip = (*cmxCpTobIter)->chip();
321 const uint8_t location = (*cmxCpTobIter)->location();
323 const uint8_t isolation = (*cmxCpTobIter)->isolation();
325 const uint8_t x = crate * m_modules + cpm - 1;
326 const uint8_t y = chip * 4 + location;
327 if (energy) {
329 monCmxCpTob.
tob=(*cmxCpTobIter);
332 if (cmx)
333 monCmxCpTobEnerRight.push_back(monCmxCpTob);
334 else
335 monCmxCpTobEnerLeft.push_back(monCmxCpTob);
336 }
337 if (isolation) {
339 monCmxCpTob.
tob=(*cmxCpTobIter);
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) {
354 cmxCpmTobsIsolBitsRightW=hit;
355 fill(m_packageName, cmxCpmTobsIsolBitsRight, cmxCpmTobsIsolBitsRightW);
356 } else {
358 cmxCpmTobsIsolBitsLeftW=hit;
359 fill(m_packageName, cmxCpmTobsIsolBitsLeft, cmxCpmTobsIsolBitsLeftW);
360 }
361 }
362 }
363 }
364 if (error) {
366 monCmxCpTob.
tob=(*cmxCpTobIter);
368 monCmxCpTob.parityError=false;
369
370 const LVL1::DataError
err(error);
373 }
374 const int ybase = cmx * 5;
375 monCmxCpTob.ybase=ybase;
376 bool parity = false;
378 parity = true;
379 monCmxCpTob.parityError=true;
380 monCmxCpTob.ybaseError=ybase;
381 }
383 parity = true;
384 monCmxCpTob.parityError=true;
385 monCmxCpTob.ybaseError=ybase+1;
386 }
388 parity = true;
389 monCmxCpTob.parityError=true;
390 monCmxCpTob.ybaseError=ybase+2;
391 }
393 parity = true;
394 monCmxCpTob.parityError=true;
395 monCmxCpTob.ybaseError=ybase+3;
396 }
398 parity = true;
399 monCmxCpTob.parityError=true;
400 monCmxCpTob.ybaseError=ybase+4;
401 }
402 if (parity) errorsCMX[crate * 2 + cmx] |= (1 <<
TOBParity);
403
404
405 monCmxCpTobError.push_back(monCmxCpTob);
406 }
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) {
424 if (cmx == 0) {
426 fill(m_packageName, cmxCpmTobsLeft);
427 } else {
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) {
438 if (cmx == 0) {
440 fill(m_packageName, cmxTobsCmxLeft);
441 } else {
443 fill(m_packageName, cmxTobsCmxRight);
444 }
445 }
446 }
447 }
448 }
449
450
451
452 auto cmxCpmTobsEnerLeft =
Monitored::Collection(
"cmxCpmTobsEnerLeft", monCmxCpTobEnerLeft, [](
const auto &tob ){
return tob.tob->energy();} );
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
467 auto cmxCpmTobsIsolLeft =
Monitored::Collection(
"cmxCpmTobsIsolLeft", monCmxCpTobIsolLeft, [](
const auto &tob ){
return tob.tob->isolation();} );
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
482 auto cmxCpmTobsErrorX =
Monitored::Collection(
"cmxCpmTobsErrorX", monCmxCpTobError, [](
const auto &tob ){
return tob.x;} );
484 auto cmxCpmTobsErrorCmx =
Monitored::Collection(
"cmxCpmTobsErrorCmx", monCmxCpTobError, [](
const auto &tob ){
return tob.tob->cmx();} );
486 auto cmxCpmTobsErrorYbase =
Monitored::Collection(
"cmxCpmTobsErrorYbase", monCmxCpTobError, [](
const auto &tob ){
return tob.ybaseError;} );
487 variables.push_back(cmxCpmTobsErrorYbase);
488
489 auto cmxCpmTobsErrorParity =
Monitored::Collection(
"cmxCpmTobsErrorParity", monCmxCpTobError, [](
const auto &tob ){
return tob.parityError;} );
490 variables.push_back(cmxCpmTobsErrorParity);
491
492
493
494
495
496
497 std::vector<MonitorCmxCpHits> monCmxCpHits;
498 std::vector<MonitorCmxCpHits> monCmxCpHitsLeft;
499 std::vector<MonitorCmxCpHits> monCmxCpHitsRight;
500
501
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);
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();
529 const uint8_t crateCmx = crate * 2 + cmx;
530
531
533 monCmxCpHit.
hit=(*cmIterator);
534 monCmxCpHit.crateCmx=crateCmx;
535 monCmxCpHit.srcTopoCheckSum=false;
538 monCmxCpHit.srcTopoCheckSum=true;
540 if (hits0) {
541 const int nBits = 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) {
548 cmxCpMapY=crateCmx;
549 cmxCpMapHit=hit;
550 fill(m_packageName,cmxCpMapX,cmxCpMapY,cmxCpMapHit);
551 }
552 }
553 }
555
556 if (hits0) {
557 const int nBits = 3;
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) {
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 }
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) {
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 }
611 } else {
619 if (hits0) {
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;
630 cmxCpThresBinRightHit=hit;
631 fill(m_packageName,cmxCpThresBinRightX,cmxCpThresBinRightY,cmxCpThresBinRightHit);
632 } else {
633 cmxCpThresBinLeftX=
bin;
635 cmxCpThresBinLeftHit=hit;
636 fill(m_packageName,cmxCpThresBinLeftX,cmxCpThresBinLeftY,cmxCpThresBinLeftHit);
637 }
638 }
639 }
640 }
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;
653 cmxCpThresBinRightHit=hit;
654 fill(m_packageName,cmxCpThresBinRightX,cmxCpThresBinRightY,cmxCpThresBinRightHit);
655 } else {
656 cmxCpThresBinLeftX=
bin;
658 cmxCpThresBinLeftHit=hit;
659 fill(m_packageName,cmxCpThresBinLeftX,cmxCpThresBinLeftY,cmxCpThresBinLeftHit);
660 }
661 }
662 }
663 }
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 }
674
675 auto cmxCpmHitsPeak =
Monitored::Collection(
"cmxCpHitsPeak", monCmxCpHits, [](
const auto &hit ){
return hit.hit->peak();} );
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;} );
681
682 auto cmxCpmHitsHits0 =
Monitored::Collection(
"cmxCpHitsHits0", monCmxCpHits, [](
const auto &hit ){
return hit.hit->hits0();} );
684 auto cmxCpmHitsHits1 =
Monitored::Collection(
"cmxCpHitsHits1", monCmxCpHits, [](
const auto &hit ){
return hit.hit->hits1();} );
686
687 auto cmxCpmHits0TopoCheckSum =
Monitored::Collection(
"cmxCpHits0TopoCheckSum", monCmxCpHits, [](
const auto &hit ){
return (hit.hit->hits0() && hit.srcTopoCheckSum);} );
688 variables.push_back(cmxCpmHits0TopoCheckSum);
689
690
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) {
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
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);
717 for (int loc = 0; loc < m_crates * m_modules; ++loc) {
718 if ((errorsCPM[loc] >> err) & 0x1) {
719 cpmErrorX=loc;
721 fill(m_packageName,cpmErrorX,cpmErrorY);
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);
729 fill(m_packageName,cpmErrorX,cpmErrorY);
731 crateErr[loc / 2] |= (1 <<
err);
732 }
733 }
734 }
735 if (error) {
737 fill(m_packageName,cpmErrorSummary);
738
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 }
744
745
746
747
748 auto save = std::make_unique<std::vector<int>>(crateErr);
750 if (!result) {
752 return StatusCode::FAILURE;
753 }
754
755 fill(m_packageName,variables);
757 return StatusCode::SUCCESS;
758}
#define ATH_CHECK
Evaluate an expression and check for errors.
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
Gaudi::Property< int > m_maxSlices
Gaudi::Property< int > m_modules
Gaudi::Property< int > m_threshBits
Gaudi::Property< int > m_crates
Gaudi::Property< int > m_maxTobsPerCmx
Gaudi::Property< int > m_thresholds
std::vector< bool > getIsolationBits(int val, int nThresh, int nBits) const
Gaudi::Property< int > m_tobsPerCPM
Gaudi::Property< int > m_isolBits
Description of TriggerTower_v2.
virtual double phi() const final
The azimuthal angle ( ) of the particle.
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
const xAOD::CMXCPHits_v1 * hit
const xAOD::CMXCPTob_v1 * tob
const xAOD::TriggerTower_v2 * ttower
const xAOD::CPMTobRoI_v1 * tobroi
1.14.0