32 return StatusCode::SUCCESS;
44 std::vector<VecAccumulator2DMap> error_maps_per_state;
45 error_maps_per_state.reserve(kNumErrorStatesFEI3 + kNumErrorStatesFEI4);
46 std::vector<VecAccumulator2DMap> fe_error_maps_per_state;
47 fe_error_maps_per_state.reserve(kNumErrorStatesPerFE);
48 for (
const auto& state : error_names_stateFEI3) {
49 error_maps_per_state.emplace_back(*
this, state + std::string(
"Map"));
52 fe_error_maps_per_state.emplace_back(*
this, state + std::string(
"FEMap"));
55 for (
const auto& state : error_names_stateFEI4) {
56 error_maps_per_state.emplace_back(*
this, state + std::string(
"Map"));
58 if (error_maps_per_state.size()!=(kNumErrorStatesFEI3 + kNumErrorStatesFEI4) ||
59 fe_error_maps_per_state.size()!=kNumErrorStatesPerFE) {
60 ATH_MSG_ERROR(
"PixelMonitoring: Mismatch in the definition of the number of error states.");
61 return StatusCode::RECOVERABLE;
63 std::vector<VecAccumulator2DMap> error_maps_per_cat_rodmod;
67 error_maps_per_cat_rodmod.emplace_back(*
this, error_names_cat_rodmod[cat]);
69 std::vector<VecAccumulator2DMap> error_maps_per_cat;
71 error_maps_per_cat.emplace_back(*
this, error_names_cat[cat]);
75 std::vector<int> flagged_ibl_error_bits;
76 std::vector<unsigned int> weights_of_flagged_ibl_error_bits;
147 for (
int modHash = 12; modHash < maxHash - 12; modHash++) {
152 int iblsublayer(pixlayer);
171 unsigned int num_femcc_errwords = 0;
185 trunc_rob_errors_maps.
add(pixlayer, waferID, 1.0);
188 masked_rob_errors_maps.
add(pixlayer, waferID, 1.0);
194 num_errors[pixlayer] += stateFEI3.count();
195 for (
unsigned int state = 0; state < stateFEI3.size(); ++state) {
196 if (stateFEI3[state]) {
197 num_errors_per_state[state][pixlayer]++;
198 error_maps_per_state[state].add(pixlayer, waferID, 1.0);
206 for (
int iFE = 0; iFE < nFE; iFE++) {
208 int offsetFE = (1 + iFE) * maxHash + modHash;
222 std::bitset<kNumErrorStatesFEI3> stateFEI3 =
getErrorStateFE(fe_errorword, is_fei4);
223 num_errors[pixlayer] += stateFEI3.count();
224 if (stateFEI3.any()) num_femcc_errwords++;
225 int perFEI3state(-1);
226 for (
unsigned int state = 0; state < stateFEI3.size(); ++state) {
228 if (stateFEI3[state]) {
229 num_errors_per_state[state][pixlayer]++;
230 if (perFEI3state>=0 && perFEI3state<kNumErrorStatesPerFE) {
231 fe_error_maps_per_state[perFEI3state].add(pixlayer, waferID, iFE, 1.0);
233 error_maps_per_state[state].add(pixlayer, waferID, 1.0);
238 std::bitset<kNumErrorStatesFEI3> stateFEI4 =
getErrorStateFE(fe_errorword, is_fei4);
239 num_errors[iblsublayer] += stateFEI4.count();
240 Identifier pixelIDperFEI4 =
m_pixelReadout->getPixelIdfromHash(modHash, iFE, 1, 1);
241 for (
unsigned int state = 0; state < stateFEI4.size(); ++state) {
242 if (stateFEI4[state]) {
243 num_errors_per_state[state][iblsublayer]++;
244 error_maps_per_state[state + kNumErrorStatesFEI3].add(pixlayer, pixelIDperFEI4, 1.0);
249 if (!is_fei4) femcc_errwords_maps.
add(pixlayer, waferID, num_femcc_errwords);
254 const int serviceRecordFieldOffset = 17 * maxHash;
256 int moduleOffset = (modHash - 156) * 2;
257 for (
int serviceCode = 0; serviceCode < 32; serviceCode++) {
259 if ((serviceCode >= 9 && serviceCode <= 14) || (serviceCode >= 17 && serviceCode <= 23)) {
263 int serviceCodeOffset = serviceCode * 280 * 2;
264 for (
int iFE = 0; iFE < nFE; iFE++) {
265 Identifier pixelIDperFEI4 =
m_pixelReadout->getPixelIdfromHash(modHash, iFE, 1, 1);
267 int serviceCodeCounterIndex = serviceRecordFieldOffset + serviceCodeOffset + moduleOffset + iFE;
272 serviceCodeCounterIndex,
277 if (serviceCodeCounter > 0) {
278 float payload = serviceCodeCounter;
279 flagged_ibl_error_bits.push_back(serviceCode);
280 weights_of_flagged_ibl_error_bits.push_back(
payload);
282 int state = serviceCode + state_offset;
283 num_errors[iblsublayer] +=
payload;
284 num_errors_per_state[state][iblsublayer] +=
payload;
285 error_maps_per_state[state + kNumErrorStatesFEI3].add(pixlayer, pixelIDperFEI4,
payload);
295 for (
int iFE = 0; iFE < nFE; iFE++) {
297 Identifier pixID = waferID;
301 if (pixID.is_valid()) {
303 if (nerrors_cat_rodmod[
i][iFE]) {
305 if (pixlayer ==
PixLayers::kIBL) num_errormodules_per_cat_rodmod[
i][iblsublayer]++;
306 else num_errormodules_per_cat_rodmod[
i][pixlayer]++;
308 all_errors_maps.
add(pixlayer, pixID, nerrors_cat_rodmod[
i][iFE]);
310 error_maps_per_cat_rodmod[
i].add(pixlayer, pixID, 1.0);
311 if (
i == 0) modsync_errors_maps.
add(pixlayer, pixID, 1.0);
312 if (
i == 1) rodsync_errors_maps.
add(pixlayer, pixID, 1.0);
318 if (has_err_cat[
i][iFE]) {
319 if (pixlayer ==
PixLayers::kIBL) num_errormodules_per_cat[
i][iblsublayer]++;
320 else num_errormodules_per_cat[
i][pixlayer]++;
322 error_maps_per_cat[
i].add(pixlayer, pixID, 1.0);
332 else nActive_layer[pixlayer]++;
335 ATH_MSG_ERROR(
"PixelMonitoring: got invalid pixID " << pixID);
343 if (nActive_layer[
i] > 0) {
344 for (
int state = 0; state < numErrorStatesLayer[
i]; state++) {
345 num_errors_per_state[state][
i] /= nActive_layer[
i];
348 num_errormodules_per_cat_rodmod[cat][
i] /= nActive_layer[
i];
351 num_errormodules_per_cat[cat][
i] /= nActive_layer[
i];
356 for (
unsigned int state = 0; state < kNumErrorStatesFEI3 + kNumErrorStatesFEI4; state++) {
357 if (state < kNumErrorStatesFEI3) {
358 if (
isPerFEI3State(error_names_stateFEI3[state]) && perFEI3state<kNumErrorStatesPerFE)
366 "PerLumi"),
lb, num_errors_per_state[state - kNumErrorStatesFEI3],
395 fill2DProfLumiLayers(
"ErrorCatRODModPerLumi",
lb, num_errormodules_per_cat_rodmod, numErrorCatRODModsLayer);
398 for (
unsigned int cat = 0; cat < error_names_cat_rodmod_norm.size(); ++cat) {
405 return StatusCode::SUCCESS;
420 std::bitset<kNumErrorStatesFEI3>
result(0);
432 std::bitset<kNumErrorStatesFEI3>
result(0);
471 if (PixelByteStreamErrors::hasError(errorword,
496 if (
sc == 0) nerrors_cat_rodmod[0][ife] +=
payload;
497 if (
sc == 16) nerrors_cat_rodmod[2][ife] +=
payload;
498 if (
sc == 1 ||
sc == 2 ||
499 sc == 3 ||
sc == 24 ||
500 sc == 28 ||
sc == 29 ||
502 nerrors_cat_rodmod[5][ife] +=
payload;
506 return (state.find(
"SEU") != std::string::npos ||
507 state.find(
"EOC") != std::string::npos ||
508 state.find(
"Warning") != std::string::npos);