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.
40{
41
43
44
46
47
48 int j_num_slice = -1;
49 int e_num_slice = -1;
50
51
52 std::vector<int> overview(2);
53
55
56
57
58
59
60
62 if (!CMXJetTob.isValid())
63 {
64 ATH_MSG_ERROR(
"No CMX JetTob found in TES at " << m_CMXJetTobLocation);
65 return StatusCode::FAILURE;
66 }
67
69
74
77
80
81 std::vector<int> tobCount(m_crates * m_modules);
82 std::vector<int> cmxCount(m_crates);
83
84
87 for (; it_CMXJetTob != it_CMXJetTob_end; ++it_CMXJetTob)
88 {
89 const int crate = (*it_CMXJetTob)->crate();
90 const int jem = (*it_CMXJetTob)->jem();
91 const int frame = (*it_CMXJetTob)->frame();
92 const int location = (*it_CMXJetTob)->location();
93 const int energyLg = (*it_CMXJetTob)->energyLarge();
94 const int energySm = (*it_CMXJetTob)->energySmall();
95 const int error = (*it_CMXJetTob)->error();
96 const int x = crate * m_modules + jem;
97 const int y = frame * 4 + location;
98
99 if (energyLg) {
100 jetTobEnergyLg = energyLg;
101 fill(m_packageName, jetTobEnergyLg);
104 fill(m_packageName, jetTobHitmap_x, jetTobHitmap_y);
105 }
106 if (energySm) {
107 jetTobEnergySm = energySm;
108 fill(m_packageName, jetTobEnergySm);
109 }
110 if (error) {
111 const LVL1::DataError
err(error);
113 if (parity) {
114 threshParityTobJem = jem;
115 threshParityTobCrate = crate;
116 fill(m_packageName, threshParityTobJem, threshParityTobCrate);
118 fill(m_packageName, cmxErrorSummary);
120 }
121 }
122 if (energyLg || energySm || error) {
124 ++cmxCount[crate];
125 }
126 }
127
128
129 for (
int crate = 0; crate <
m_crates; ++crate) {
130 for (
int jem = 0; jem <
m_modules; ++jem) {
131 int val = tobCount[crate * m_modules + jem];
132 if (val) {
133 if (val > m_tobsPerJem)
136 fill(m_packageName, tobsPerJem);
137 }
138 }
139 int val = cmxCount[crate];
140 if (val) {
141 if (val >= m_maxTobsPerCmx)
144 fill(m_packageName, tobsPerCmx);
145 }
146 }
147
148
149
150
151
152
153 SG::ReadHandle<xAOD::CMXJetHitsContainer>
CMXJetHits(m_CMXJetHitsLocation, ctx);
155 ATH_MSG_ERROR(
"No CMX JetHits found in TES at " << m_CMXJetHitsLocation);
156 return StatusCode::FAILURE;
157 }
158
159 ATH_MSG_DEBUG(
"-------------- CMX Jet Hits ---------------");
160
161 auto threshTotalMainVals = Monitored::Scalar<int>("threshTotalMainVals", 0.);
162 auto threshTotalMainHits = Monitored::Scalar<int>("threshTotalMainHits", 0.);
163
164 auto threshRoiOverflow = Monitored::Scalar<int>("threshRoiOverflow", 0.);
165 auto topoDataChecksum = Monitored::Scalar<int>("topoDataChecksum", 0.);
166 auto topoTobsPerJem = Monitored::Scalar<int>("topoTobsPerJem", 0.);
167 auto topoTobsPerCmx = Monitored::Scalar<int>("topoTobsPerCmx", 0.);
168
169 auto topoJemOccMap_mod = Monitored::Scalar<int>("topoJemOccMap_mod", 0.);
170 auto topoJemOccMap_cra = Monitored::Scalar<int>("topoJemOccMap_cra", 0.);
171 auto topoJemOccMap_hit = Monitored::Scalar<int>("topoJemOccMap_hit", 0.);
172
173 auto topoJemOccCount_mod = Monitored::Scalar<int>("topoJemOccCount_mod", 0.);
174 auto topoJemOccCount_cra = Monitored::Scalar<int>("topoJemOccCount_cra", 0.);
175 auto topoJemOccCount_hit = Monitored::Scalar<int>("topoJemOccCount_hit", 0.);
176
177 auto cmxThreshStatusErr_bit = Monitored::Scalar<int>("cmxThreshStatusErr_bit", 0.);
178 auto cmxThreshStatusErr_crate = Monitored::Scalar<int>("cmxThreshStatusErr_crate", 0.);
179
180 auto cmxThreshParityErr = Monitored::Scalar<int>("cmxThreshParityErr", 0.);
181
182 cmxCount.assign(m_crates, 0);
183
184
187 for (; it_CMXJetHits != it_CMXJetHitsEnd; ++it_CMXJetHits) {
188 const int crate = (*it_CMXJetHits)->crate();
189 const int source = (*it_CMXJetHits)->sourceComponent();
190 const unsigned int hits0 = (*it_CMXJetHits)->hits0();
191 const unsigned int hits1 = (*it_CMXJetHits)->hits1();
192 const DataError err0((*it_CMXJetHits)->error0());
193 const DataError err1((*it_CMXJetHits)->error1());
194
195
196
197
198
200 fillThresholds(threshTotalMainVals, threshTotalMainHits, hits0, 5, 3);
201 fillThresholds(threshTotalMainVals, threshTotalMainHits, hits1, 5, 3, 5);
202 }
203
204 if (crate == m_crates - 1 && err0.get(DataError::Overflow)) {
206 ? 0
208 ? 1
210 : 3;
212 threshRoiOverflow =
x;
213 fill(m_packageName, threshRoiOverflow);
214 }
215 }
216
217
218
219
220
222 if (hits0) {
223 topoDataChecksum = crate;
224 fill(m_packageName, topoDataChecksum);
225 }
226 }
228 if (hits0)
229 {
231 hits0, crate, m_modules, 1);
232 }
233 }
235 if (hits0)
236 {
238 hits0, crate, m_modules / 2, 3);
239 for (
int mod = 0;
mod < m_modules / 2; ++
mod) {
240 const int val = (hits0 >> (
mod * 3)) & 0x7;
241 if (val) {
242 topoTobsPerJem =
val;
243 fill(m_packageName, topoTobsPerJem);
244 cmxCount[crate] +=
val;
245 }
246 }
247 }
248 if (hits1) {
250 hits1, crate, m_modules / 2, 3, m_modules / 2);
251 for (
int mod = 0;
mod < m_modules / 2; ++
mod) {
252 const int val = (hits1 >> (
mod * 3)) & 0x7;
253 if (val) {
254 topoTobsPerJem =
val;
255 fill(m_packageName, topoTobsPerJem);
256 cmxCount[crate] +=
val;
257 }
258 }
259 }
260 }
261
262
263
264
265
266 if (j_num_slice < 0) j_num_slice = (*it_CMXJetHits)->peak();
267
268
269
271 if (status) {
272 for (int bit = 0; bit < 8; ++bit) {
273 if ((status >> bit) & 0x1) {
274 cmxThreshStatusErr_bit = bit;
275 cmxThreshStatusErr_crate = crate;
276 fill(m_packageName, cmxThreshStatusErr_bit, cmxThreshStatusErr_crate);
277 }
278 }
280 fill(m_packageName, cmxErrorSummary);
282 }
283
286 {
287
288 const int p0 = err0.get(DataError::Parity);
289 const int p1 = err1.get(DataError::Parity);
290 if (p0 || p1) {
291 if (p0) {
293 cmxThreshParityErr = xpos;
294 fill(m_packageName, cmxThreshParityErr);
295 }
296 if (p1) {
298 cmxThreshParityErr = xpos;
299 fill(m_packageName, cmxThreshParityErr);
300 }
302 fill(m_packageName, cmxErrorSummary);
304 }
305 }
306 }
307
308 for (int crate = 0; crate < m_crates; ++crate) {
309 int val = cmxCount[crate];
310 if (val) {
311 if (val >= m_maxTobsPerCmx)
313 topoTobsPerCmx =
val;
314 fill(m_packageName, topoTobsPerCmx);
315 }
316 }
317
318
319
320
321
322
323 SG::ReadHandle<xAOD::CMXEtSumsContainer>
CMXEtSums(m_CMXEtSumsLocation, ctx);
325 ATH_MSG_ERROR(
"No CMXEtSums found in TES at " << m_CMXEtSumsLocation);
326 return StatusCode::FAILURE;
327 }
328
330
331 auto eSubSumsEx = Monitored::Scalar<int>("eSubSumsEx", 0.);
332 auto eSubSumsEy = Monitored::Scalar<int>("eSubSumsEy", 0.);
333 auto eSubSumsEt = Monitored::Scalar<int>("eSubSumsEt", 0.);
334
335 auto cmxTotalEx = Monitored::Scalar<int>("cmxTotalEx", 0.);
336 auto cmxTotalEy = Monitored::Scalar<int>("cmxTotalEy", 0.);
337 auto cmxTotalEt = Monitored::Scalar<int>("cmxTotalEt", 0.);
338 auto cmxTotalExRes = Monitored::Scalar<int>("cmxTotalExRes", 0.);
339 auto cmxTotalEyRes = Monitored::Scalar<int>("cmxTotalEyRes", 0.);
340 auto cmxTotalEtRes = Monitored::Scalar<int>("cmxTotalEtRes", 0.);
341
342 auto cmxMissingEt_vals = Monitored::Scalar<int>("cmxMissingEt_vals", 0.);
343 auto cmxMissingEt_hits = Monitored::Scalar<int>("cmxMissingEt_hits", 0.);
344 auto cmxMissingEtSig_vals = Monitored::Scalar<int>("cmxMissingEtSig_vals", 0.);
345 auto cmxMissingEtSig_hits = Monitored::Scalar<int>("cmxMissingEtSig_hits", 0.);
346 auto cmxMissingEtHitsRes_vals = Monitored::Scalar<int>("cmxMissingEtHitsRes_vals", 0.);
347 auto cmxMissingEtHitsRes_hits = Monitored::Scalar<int>("cmxMissingEtHitsRes_hits", 0.);
348
349 auto cmxSumEt_vals = Monitored::Scalar<int>("cmxSumEt_vals", 0.);
350 auto cmxSumEt_hits = Monitored::Scalar<int>("cmxSumEt_hits", 0.);
351 auto cmxSumEtHitsWt_vals = Monitored::Scalar<int>("cmxSumEtHitsWt_vals", 0.);
352 auto cmxSumEtHitsWt_hits = Monitored::Scalar<int>("cmxSumEtHitsWt_hits", 0.);
353
354 auto cmxTriggeredSlice = Monitored::Scalar<int>("cmxTriggeredSlice", 0.);
355
356 auto cmxEnergyStatus_bit = Monitored::Scalar<int>("cmxEnergyStatus_bit", 0.);
357 auto cmxEnergyStatus_cra = Monitored::Scalar<int>("cmxEnergyStatus_cra", 0.);
358
359 auto cmxEnergyParityModx = Monitored::Scalar<int>("cmxEnergyParityModx", 0.);
360 auto cmxEnergyParityMody = Monitored::Scalar<int>("cmxEnergyParityMody", 0.);
361
362 auto cmxParityRem = Monitored::Scalar<int>("cmxParityRem", 0.);
363
364 auto cmxEnergyOverflowx = Monitored::Scalar<int>("cmxEnergyOverflowx", 0.);
365 auto cmxEnergyOverflowy = Monitored::Scalar<int>("cmxEnergyOverflowy", 0.);
366 auto cmxEnergyOverflowz = Monitored::Scalar<int>("cmxEnergyOverflowz", 0.);
367
368 auto cmxEnergyOverflowResx = Monitored::Scalar<int>("cmxEnergyOverflowResx", 0.);
369 auto cmxEnergyOverflowResy = Monitored::Scalar<int>("cmxEnergyOverflowResy", 0.);
370 auto cmxEnergyOverflowResz = Monitored::Scalar<int>("cmxEnergyOverflowResz", 0.);
371
372
375 for (; it_CMXEtSums != it_CMXEtSums_end; ++it_CMXEtSums) {
376 const int crate = (*it_CMXEtSums)->crate();
377 const int source = (*it_CMXEtSums)->sourceComponent();
378 const unsigned int rawEx = (*it_CMXEtSums)->ex();
379 const unsigned int rawEy = (*it_CMXEtSums)->ey();
380 const unsigned int rawEt = (*it_CMXEtSums)->et();
381 const int exError = (*it_CMXEtSums)->exError();
382 const int eyError = (*it_CMXEtSums)->eyError();
383 const int etError = (*it_CMXEtSums)->etError();
384
385
386
387
388
389 if (source < m_modules) {
390 const int ex = rawEx;
391 const int ey = rawEy;
393
394 if (ex) {
395 eSubSumsEx = ex;
396 fill(m_packageName, eSubSumsEx);
397 }
398 if (ey) {
399 eSubSumsEy = ey;
400 fill(m_packageName, eSubSumsEy);
401 }
404 fill(m_packageName, eSubSumsEt);
405 }
406 }
407
408
409
410
411
414
415 LVL1::CrateEnergy cen(crate, rawEt, rawEx, rawEy, etError & 0x1, exError & 0x1, eyError & 0x1);
416 const int ex = cen.ex();
417 const int ey = cen.ey();
419
421 if (ex && !cen.exOverflow()) {
422 cmxTotalEx = ex;
423 fill(m_packageName, cmxTotalEx);
424 }
425 if (ey && !cen.eyOverflow()) {
426 cmxTotalEy = ey;
427 fill(m_packageName, cmxTotalEy);
428 }
429 if (
et && !cen.etOverflow()) {
431 fill(m_packageName, cmxTotalEt);
432 }
433 }
434 else {
435 if (ex && !cen.exOverflow()) {
436 cmxTotalExRes = ex;
437 fill(m_packageName, cmxTotalExRes);
438 }
439 if (ey && !cen.eyOverflow()) {
440 cmxTotalEyRes = ey;
441 fill(m_packageName, cmxTotalEyRes);
442 }
443 if (
et && !cen.etOverflow()) {
445 fill(m_packageName, cmxTotalEtRes);
446 }
447 }
448 }
449
456 }
459 }
462 }
463 }
469 }
471 }
472
473 if (e_num_slice < 0) {
474 e_num_slice = (*it_CMXEtSums)->peak();
475 if (j_num_slice >= 0) {
476 cmxTriggeredSlice = std::abs(e_num_slice - j_num_slice);
477 fill(m_packageName, cmxTriggeredSlice);
478 }
479 }
480
481
482
483
484
485
486 const DataError exerr(exError);
487 const DataError eyerr(eyError);
488 const DataError eterr(etError);
490 if (status) {
491 for (int bit = 0; bit < 8; ++bit) {
492 if ((status >> bit) & 0x1) {
493 cmxEnergyStatus_bit = bit;
494 cmxEnergyStatus_cra = crate;
495 fill(m_packageName, cmxEnergyStatus_bit, cmxEnergyStatus_cra);
496 }
497 }
499 fill(m_packageName, cmxErrorSummary);
501 }
502
505
506 const int p0 = exerr.get(DataError::Parity);
507 const int p1 = eyerr.get(DataError::Parity);
508 const int p2 = eterr.get(DataError::Parity);
509 if (p0 || p1 || p2) {
510
511 if (source < m_modules) {
512 const int xpos = crate * m_modules +
source;
513 cmxEnergyParityModx = xpos;
514 if (p0) cmxEnergyParityMody = 0.;
515 if (p1) cmxEnergyParityMody = 1.;
516 if (p2) cmxEnergyParityMody = 2.;
517 fill(m_packageName, cmxEnergyParityModx, cmxEnergyParityMody);
518 }
519
521 if (p0) cmxParityRem = 0.;
522 if (p1) cmxParityRem = 1.;
523 }
524 else {
525 if (p0) cmxParityRem = 2.;
526 if (p1) cmxParityRem = 3.;
527 }
528 fill(m_packageName, cmxParityRem);
530 fill(m_packageName, cmxErrorSummary);
532 }
533 }
534
535
536 if (crate == 1) {
542 : 2.;
543 cmxEnergyOverflowy = ypos;
544
545 cmxEnergyOverflowx = 0.;
546 cmxEnergyOverflowz = exerr.get(DataError::Overflow);
547 fill(m_packageName, cmxEnergyOverflowx, cmxEnergyOverflowy, cmxEnergyOverflowz);
548
549 cmxEnergyOverflowx = 1.;
550 cmxEnergyOverflowz = eyerr.get(DataError::Overflow);
551 fill(m_packageName, cmxEnergyOverflowx, cmxEnergyOverflowy, cmxEnergyOverflowz);
552
553 cmxEnergyOverflowx = 2.;
554 cmxEnergyOverflowz = eterr.get(DataError::Overflow);
555 fill(m_packageName, cmxEnergyOverflowx, cmxEnergyOverflowy, cmxEnergyOverflowz);
556 }
562 : 2.;
563 cmxEnergyOverflowResy = ypos;
564
565 cmxEnergyOverflowResx = 0.;
566 cmxEnergyOverflowResz = exerr.get(DataError::Overflow);
567 fill(m_packageName, cmxEnergyOverflowResx, cmxEnergyOverflowResy, cmxEnergyOverflowResz);
568
569 cmxEnergyOverflowResx = 1.;
570 cmxEnergyOverflowResz = eyerr.get(DataError::Overflow);
571 fill(m_packageName, cmxEnergyOverflowResx, cmxEnergyOverflowResy, cmxEnergyOverflowResz);
572
573 cmxEnergyOverflowResx = 2.;
574 cmxEnergyOverflowResz = eterr.get(DataError::Overflow);
575 fill(m_packageName, cmxEnergyOverflowResx, cmxEnergyOverflowResy, cmxEnergyOverflowResz);
576 }
577 }
578 }
579
580
581
582
583
584
585 SG::ReadHandle<xAOD::CMXRoIContainer> CRCon(m_CMXRoILocation, ctx);
586 if (!CRCon.isValid()) {
587 ATH_MSG_ERROR(
"No CMX RoI found in TES at " << m_CMXRoILocation);
588 return StatusCode::FAILURE;
589 }
590
592
594
595 auto roiSumEtHits_var = Monitored::Scalar<int>("roiSumEtHits_var", 0.);
596 auto roiSumEtHits_hit = Monitored::Scalar<int>("roiSumEtHits_hit", 0.);
597
598 auto roiMissingEtHits_var = Monitored::Scalar<int>("roiMissingEtHits_var", 0.);
599 auto roiMissingEtHits_hit = Monitored::Scalar<int>("roiMissingEtHits_hit", 0.);
600
601 auto roiMissingEtSigHits_var = Monitored::Scalar<int>("roiMissingEtSigHits_var");
602 auto roiMissingEtSigHits_hit = Monitored::Scalar<int>("roiMissingEtSigHits_hit");
603
604 auto roiSumEtHitsMask_var = Monitored::Scalar<int>("roiSumEtHitsMask_var");
605 auto roiSumEtHitsMask_hit = Monitored::Scalar<int>("roiSumEtHitsMask_hit");
606
607 auto roiMissingEtHitsMask_var = Monitored::Scalar<int>("roiMissingEtHitsMask_var");
608 auto roiMissingEtHitsMask_hit = Monitored::Scalar<int>("roiMissingEtHitsMask_hit");
609
610 auto cmxRoiEx = Monitored::Scalar<int>("cmxRoiEx", 0.);
611 auto cmxRoiEy = Monitored::Scalar<int>("cmxRoiEy", 0.);
612 auto cmxRoiEt = Monitored::Scalar<int>("cmxRoiEt", 0.);
613
614 auto cmxRoiExMask = Monitored::Scalar<int>("cmxRoiExMask", 0.);
615 auto cmxRoiEyMask = Monitored::Scalar<int>("cmxRoiEyMask", 0.);
616 auto cmxRoiEtMask = Monitored::Scalar<int>("cmxRoiEtMask", 0.);
617
618
619
620
621
622 const int rawEx = CR->
ex();
623 const int rawEy = CR->
ey();
624 const int et = CR->
et();
625 const int exError = CR->
exError();
626 const int eyError = CR->
eyError();
627 const int etError = CR->
etError();
639
640 fillThresholds(roiSumEtHits_var, roiSumEtHits_hit, sumEtHits, 8, 1);
641 fillThresholds(roiMissingEtHits_var, roiMissingEtHits_hit, missingEtHits, 8, 1);
642 fillThresholds(roiMissingEtSigHits_var, roiMissingEtSigHits_hit, missingEtSigHits, 8, 1);
643 fillThresholds(roiSumEtHitsMask_var, roiSumEtHitsMask_hit, sumEtHitsM, 8, 1);
644 fillThresholds(roiMissingEtHitsMask_var, roiMissingEtHitsMask_hit, missingEtHitsM, 8, 1);
645
646
647 LVL1::CrateEnergy cen(1,
et, rawEx, rawEy, etError & 0x1, exError & 0x1, eyError & 0x1);
648 const int ex = cen.ex();
649 const int ey = cen.ey();
650
651 if (ex && !cen.exOverflow()) {
652 cmxRoiEx = ex;
653 fill(m_packageName, cmxRoiEx);
654 }
655 if (ey && !cen.eyOverflow()) {
656 cmxRoiEy = ey;
657 fill(m_packageName, cmxRoiEy);
658 }
659 if (
et && !cen.etOverflow()) {
661 fill(m_packageName, cmxRoiEt);
662 }
663
664 LVL1::CrateEnergy cen2(1, etM, rawExM, rawEyM, etErrorM & 0x1, exErrorM & 0x1, eyErrorM & 0x1);
665 const int exM = cen2.ex();
666 const int eyM = cen2.ey();
667
668 if (exM && !cen2.exOverflow()) {
669 cmxRoiExMask = exM;
670 fill(m_packageName, cmxRoiExMask);
671 }
672 if (eyM && !cen2.eyOverflow()) {
673 cmxRoiEyMask = eyM;
674 fill(m_packageName, cmxRoiEyMask);
675 }
676 if (etM && !cen2.etOverflow()) {
677 cmxRoiEtMask = etM;
678 fill(m_packageName, cmxRoiEtMask);
679 }
680
681 return StatusCode::SUCCESS;
682}
float et(const xAOD::jFexSRJetRoI *j)
static const uint32_t nHits
DataModel_detail::const_iterator< DataVector > const_iterator
Gaudi::Property< int > m_tobsPerJem
Gaudi::Property< int > m_modules
void fillThresholdsVsY(Monitored::Scalar< int > &monVarX, Monitored::Scalar< int > &monVarY, Monitored::Scalar< int > &hitVar, int val, int y, int nThresh, int nBits, int offset=0) const
void fillThresholds(Monitored::Scalar< int > &monVar, Monitored::Scalar< int > &hitVar, int val, int nThresh, int nBits, int offset=0) const
Gaudi::Property< int > m_maxTobsPerCmx
Gaudi::Property< int > m_crates
Declare a monitored scalar variable.
@ MISSING_ET_SIG_STANDARD
int etError(SumType type=NORMAL) const
Return Et error flags (bit 0 Overflow)
int exError(SumType type=NORMAL) const
Return Ex error flags (bit 0 Overflow)
unsigned int ey(SumType type=NORMAL) const
Return Ey.
unsigned int sumEtHits(SumType type=NORMAL) const
Return Sum-ET hits.
int eyError(SumType type=NORMAL) const
Return Ey error flags (bit 0 Overflow)
unsigned int et(SumType type=NORMAL) const
Return Et.
unsigned int missingEtSigHits() const
Return Missing-ET-Sig hits.
unsigned int ex(SumType type=NORMAL) const
Return Ex.
unsigned int missingEtHits(SumType type=NORMAL) const
Return Missing-ET hits.
CMXJetHits_v1 CMXJetHits
Define the latest version of the CMXJetHits class.
CMXRoI_v1 CMXRoI
Define the latest version of the CMXRoI class.
CMXEtSums_v1 CMXEtSums
Define the latest version of the CMXEtSums class.
void fill(H5::Group &out_file, size_t iterations)
1.14.0