File indexing completed on 2024-10-25 05:06:28
0001 #include "FWCore/Utilities/interface/Exception.h"
0002 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0003
0004 #include "DataFormats/FEDRawData/interface/FEDNumbering.h"
0005 #include "DataFormats/DetId/interface/DetId.h"
0006 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
0007
0008 #include "EventFilter/SiStripRawToDigi/interface/PipeAddrToTimeLookupTable.h"
0009
0010 #include "DQM/SiStripMonitorHardware/interface/HistogramBase.hh"
0011 #include "DQM/SiStripMonitorHardware/interface/FEDErrors.hh"
0012 #include "DQM/SiStripCommon/interface/TkHistoMap.h"
0013
0014 FEDErrors::FEDErrors() {
0015
0016 initialiseEvent();
0017 }
0018
0019 FEDErrors::~FEDErrors() {}
0020
0021 void FEDErrors::initialiseLumiBlock() {}
0022
0023 void FEDErrors::initialiseEvent() {
0024 fedID_ = 0;
0025 failUnpackerFEDCheck_ = false;
0026
0027 connected_.clear();
0028 detid_.clear();
0029 nChInModule_.clear();
0030
0031 subDetId_.clear();
0032
0033 lFedCounter_.nFEDErrors = 0;
0034 lFedCounter_.nDAQProblems = 0;
0035 lFedCounter_.nFEDsWithFEProblems = 0;
0036 lFedCounter_.nCorruptBuffers = 0;
0037 lFedCounter_.nBadChannels = 0;
0038 lFedCounter_.nBadActiveChannels = 0;
0039 lFedCounter_.nFEDsWithFEOverflows = 0;
0040 lFedCounter_.nFEDsWithFEBadMajorityAddresses = 0;
0041 lFedCounter_.nFEDsWithMissingFEs = 0;
0042 lFedCounter_.nTotalBadChannels = 0;
0043 lFedCounter_.nTotalBadActiveChannels = 0;
0044
0045 lChCounter_.nNotConnected = 0;
0046 lChCounter_.nUnlocked = 0;
0047 lChCounter_.nOutOfSync = 0;
0048 lChCounter_.nAPVStatusBit = 0;
0049 lChCounter_.nAPVError = 0;
0050 lChCounter_.nAPVAddressError = 0;
0051
0052 feCounter_.nFEOverflows = 0;
0053 feCounter_.nFEBadMajorityAddresses = 0;
0054 feCounter_.nFEMissing = 0;
0055
0056 fedErrors_.HasCabledChannels = false;
0057 fedErrors_.DataPresent = false;
0058 fedErrors_.DataMissing = false;
0059 fedErrors_.InvalidBuffers = false;
0060 fedErrors_.BadFEDCRCs = false;
0061 fedErrors_.BadDAQCRCs = false;
0062 fedErrors_.BadIDs = false;
0063 fedErrors_.BadDAQPacket = false;
0064 fedErrors_.CorruptBuffer = false;
0065 fedErrors_.FEsOverflow = false;
0066 fedErrors_.FEsMissing = false;
0067 fedErrors_.FEsBadMajorityAddress = false;
0068 fedErrors_.BadChannelStatusBit = false;
0069 fedErrors_.BadActiveChannelStatusBit = false;
0070
0071 feErrors_.clear();
0072
0073 chErrorsDetailed_.clear();
0074
0075 apvErrors_.clear();
0076
0077 chErrors_.clear();
0078
0079 eventProp_.deltaBX = 0;
0080 }
0081
0082 void FEDErrors::initialiseFED(const unsigned int aFedID,
0083 const SiStripFedCabling* aCabling,
0084 const TrackerTopology* tTopo,
0085 const bool initVars) {
0086 fedID_ = aFedID;
0087 failUnpackerFEDCheck_ = false;
0088
0089
0090
0091
0092
0093 if (initVars) {
0094 subDetId_.resize(sistrip::FEUNITS_PER_FED, 0);
0095
0096 connected_.resize(sistrip::FEDCH_PER_FED, false);
0097 detid_.resize(sistrip::FEDCH_PER_FED, 0);
0098 nChInModule_.resize(sistrip::FEDCH_PER_FED, 0);
0099
0100 for (unsigned int iCh = 0; iCh < sistrip::FEDCH_PER_FED; iCh++) {
0101 const FedChannelConnection& lConnection = aCabling->fedConnection(fedID_, iCh);
0102 connected_[iCh] = lConnection.isConnected();
0103 detid_[iCh] = lConnection.detId();
0104 nChInModule_[iCh] = lConnection.nApvPairs();
0105
0106 unsigned short lFeNumber = static_cast<unsigned int>(iCh / sistrip::FEDCH_PER_FEUNIT);
0107 unsigned int lDetid = detid_[iCh];
0108
0109 if (lDetid && lDetid != sistrip::invalid32_ && connected_[iCh]) {
0110 unsigned int lSubid = 6;
0111
0112 switch (DetId(lDetid).subdetId()) {
0113 case 3:
0114 lSubid = 2;
0115 break;
0116
0117 case 4: {
0118 if (tTopo->tidSide(lDetid) == 2)
0119 lSubid = 4;
0120 else
0121 lSubid = 3;
0122 break;
0123 }
0124
0125 case 5:
0126 lSubid = 5;
0127 break;
0128
0129 case 6: {
0130 if (tTopo->tecSide(lDetid) == 2)
0131 lSubid = 1;
0132 else
0133 lSubid = 0;
0134 break;
0135 }
0136
0137 default:
0138 lSubid = 6;
0139 break;
0140 }
0141 subDetId_[lFeNumber] = lSubid;
0142
0143 }
0144 }
0145
0146 feCounter_.nFEOverflows = 0;
0147 feCounter_.nFEBadMajorityAddresses = 0;
0148 feCounter_.nFEMissing = 0;
0149
0150 fedErrors_.HasCabledChannels = false;
0151 fedErrors_.DataPresent = false;
0152 fedErrors_.DataMissing = false;
0153 fedErrors_.InvalidBuffers = false;
0154 fedErrors_.BadFEDCRCs = false;
0155 fedErrors_.BadDAQCRCs = false;
0156 fedErrors_.BadIDs = false;
0157 fedErrors_.BadDAQPacket = false;
0158 fedErrors_.CorruptBuffer = false;
0159 fedErrors_.FEsOverflow = false;
0160 fedErrors_.FEsMissing = false;
0161 fedErrors_.FEsBadMajorityAddress = false;
0162 fedErrors_.BadChannelStatusBit = false;
0163 fedErrors_.BadActiveChannelStatusBit = false;
0164
0165 feErrors_.clear();
0166
0167 chErrorsDetailed_.clear();
0168
0169 apvErrors_.clear();
0170
0171 chErrors_.clear();
0172 }
0173 }
0174
0175 bool FEDErrors::checkDataPresent(const FEDRawData& aFedData) {
0176 if (!aFedData.size() || !aFedData.data()) {
0177 for (unsigned int iCh = 0; iCh < sistrip::FEDCH_PER_FED; iCh++) {
0178 if (connected_[iCh]) {
0179 fedErrors_.HasCabledChannels = true;
0180 fedErrors_.DataMissing = true;
0181 return false;
0182 }
0183 }
0184 fedErrors_.DataMissing = true;
0185 fedErrors_.HasCabledChannels = false;
0186 return false;
0187 } else {
0188 fedErrors_.DataPresent = true;
0189 for (unsigned int iCh = 0; iCh < sistrip::FEDCH_PER_FED; iCh++) {
0190 if (connected_[iCh]) {
0191 fedErrors_.HasCabledChannels = true;
0192 break;
0193 }
0194 }
0195 return true;
0196 }
0197 }
0198
0199 bool FEDErrors::failUnpackerFEDCheck() { return failUnpackerFEDCheck_; }
0200
0201 bool FEDErrors::fillFatalFEDErrors(const FEDRawData& aFedData, const unsigned int aPrintDebug) {
0202 const auto st_buffer = sistrip::preconstructCheckFEDBufferBase(aFedData);
0203 if (sistrip::FEDBufferStatusCode::SUCCESS != st_buffer) {
0204 fedErrors_.InvalidBuffers = true;
0205 failUnpackerFEDCheck_ = true;
0206
0207 return false;
0208 }
0209 const sistrip::FEDBufferBase buffer{aFedData};
0210
0211
0212
0213 if (!buffer.checkNoSlinkCRCError()) {
0214 fedErrors_.BadFEDCRCs = true;
0215 return false;
0216 } else if (!buffer.checkCRC()) {
0217 failUnpackerFEDCheck_ = true;
0218 fedErrors_.BadDAQCRCs = true;
0219 return false;
0220 }
0221
0222
0223 if (!buffer.checkSourceIDs() || !buffer.checkNoUnexpectedSourceID()) {
0224 fedErrors_.BadIDs = true;
0225 return false;
0226 }
0227
0228
0229 else if (!buffer.doDAQHeaderAndTrailerChecks()) {
0230 failUnpackerFEDCheck_ = true;
0231 fedErrors_.BadDAQPacket = true;
0232 return false;
0233 }
0234
0235
0236
0237 if (!(buffer.checkBufferFormat() && buffer.checkHeaderType() && buffer.checkReadoutMode())) {
0238 failUnpackerFEDCheck_ = true;
0239 fedErrors_.InvalidBuffers = true;
0240
0241 if (!printDebug() || aPrintDebug < 3)
0242 return false;
0243 }
0244
0245
0246 if (!buffer.checkNoFEOverflows()) {
0247 failUnpackerFEDCheck_ = true;
0248 fedErrors_.FEsOverflow = true;
0249
0250 if (!printDebug() || aPrintDebug < 3)
0251 return false;
0252 }
0253
0254 return true;
0255 }
0256
0257 bool FEDErrors::fillCorruptBuffer(const sistrip::FEDBuffer& aBuffer) {
0258
0259 if (!(aBuffer.checkChannelLengthsMatchBufferLength() && aBuffer.checkChannelPacketCodes() &&
0260 aBuffer.checkFEUnitLengths())) {
0261 fedErrors_.CorruptBuffer = true;
0262
0263 return false;
0264 }
0265
0266 return true;
0267 }
0268
0269 float FEDErrors::fillNonFatalFEDErrors(const sistrip::FEDBuffer* aBuffer, const SiStripFedCabling* aCabling) {
0270 unsigned int lBadChans = 0;
0271 unsigned int lTotChans = 0;
0272 for (unsigned int iCh = 0; iCh < sistrip::FEDCH_PER_FED; iCh++) {
0273 bool lIsConnected = false;
0274 if (aCabling) {
0275 const FedChannelConnection& lConnection = aCabling->fedConnection(fedID_, iCh);
0276 lIsConnected = lConnection.isConnected();
0277 } else
0278 lIsConnected = connected_[iCh];
0279
0280 if (!lIsConnected)
0281 continue;
0282 lTotChans++;
0283 if (!aBuffer->channelGood(iCh, true))
0284 lBadChans++;
0285 }
0286
0287 return static_cast<float>(lBadChans * 1.0 / lTotChans);
0288 }
0289
0290 bool FEDErrors::fillFEDErrors(const FEDRawData& aFedData,
0291 bool& aFullDebug,
0292 const unsigned int aPrintDebug,
0293 unsigned int& aCounterMonitoring,
0294 unsigned int& aCounterUnpacker,
0295 const bool aDoMeds,
0296 MonitorElement* aMedianHist0,
0297 MonitorElement* aMedianHist1,
0298 const bool aDoFEMaj,
0299 std::vector<std::vector<std::pair<unsigned int, unsigned int> > >& aFeMajFrac) {
0300
0301
0302
0303 if (!fillFatalFEDErrors(aFedData, aPrintDebug))
0304 return false;
0305
0306
0307 const auto st_buffer = sistrip::preconstructCheckFEDBuffer(aFedData, true);
0308 if (sistrip::FEDBufferStatusCode::SUCCESS != st_buffer) {
0309 throw cms::Exception("FEDBuffer") << st_buffer << " (check debug output for more details)";
0310 }
0311 sistrip::FEDBuffer buffer{aFedData, true};
0312 buffer.findChannels();
0313
0314
0315 if (!buffer.checkChannelLengths())
0316 failUnpackerFEDCheck_ = true;
0317
0318
0319 if (!this->anyFEDErrors()) {
0320 bool lCorruptCheck = fillCorruptBuffer(buffer);
0321 if (aPrintDebug > 1 && !lCorruptCheck) {
0322 edm::LogWarning("SiStripMonitorHardware")
0323 << "CorruptBuffer check failed for FED " << fedID_ << std::endl
0324 << " -- buffer->checkChannelLengthsMatchBufferLength() = " << buffer.checkChannelLengthsMatchBufferLength()
0325 << std::endl
0326 << " -- buffer->checkChannelPacketCodes() = " << buffer.checkChannelPacketCodes() << std::endl
0327 << " -- buffer->checkFEUnitLengths() = " << buffer.checkFEUnitLengths() << std::endl;
0328 }
0329
0330
0331
0332
0333
0334 fillFEErrors(buffer, aDoFEMaj, aFeMajFrac);
0335
0336
0337 fillChannelErrors(
0338 buffer, aFullDebug, aPrintDebug, aCounterMonitoring, aCounterUnpacker, aDoMeds, aMedianHist0, aMedianHist1);
0339 }
0340
0341 if (printDebug() && aPrintDebug > 2) {
0342 const sistrip::FEDBufferBase& debugBuffer = buffer;
0343
0344 std::vector<FEDErrors::APVLevelErrors>& lChVec = getAPVLevelErrors();
0345 std::ostringstream debugStream;
0346 if (!lChVec.empty()) {
0347 std::sort(lChVec.begin(), lChVec.end());
0348 debugStream << "[FEDErrors] Cabled channels which had errors: ";
0349
0350 for (unsigned int iBadCh(0); iBadCh < lChVec.size(); iBadCh++) {
0351 print(lChVec[iBadCh], debugStream);
0352 }
0353 debugStream << std::endl;
0354 debugStream << "[FEDErrors] Active (have been locked in at least one event) cabled channels which had errors: ";
0355 for (unsigned int iBadCh(0); iBadCh < lChVec.size(); iBadCh++) {
0356 if ((lChVec[iBadCh]).IsActive)
0357 print(lChVec[iBadCh], debugStream);
0358 }
0359 }
0360 debugStream << debugBuffer << std::endl;
0361 debugBuffer.dump(debugStream);
0362 debugStream << std::endl;
0363 edm::LogInfo("SiStripMonitorHardware") << "[FEDErrors] Errors found in FED " << fedID_;
0364 edm::LogVerbatim("SiStripMonitorHardware") << debugStream.str();
0365 }
0366
0367 return !(anyFEDErrors());
0368 }
0369
0370 bool FEDErrors::fillFEErrors(const sistrip::FEDBuffer& aBuffer,
0371 const bool aDoFEMaj,
0372 std::vector<std::vector<std::pair<unsigned int, unsigned int> > >& aFeMajFrac) {
0373 bool foundOverflow = false;
0374 bool foundBadMajority = false;
0375 bool foundMissing = false;
0376 for (unsigned int iFE = 0; iFE < sistrip::FEUNITS_PER_FED; iFE++) {
0377 FEDErrors::FELevelErrors lFeErr;
0378 lFeErr.FeID = iFE;
0379 lFeErr.SubDetID = subDetId_[iFE];
0380 lFeErr.Overflow = false;
0381 lFeErr.Missing = false;
0382 lFeErr.BadMajorityAddress = false;
0383 lFeErr.TimeDifference = 0;
0384 lFeErr.Apve = 0;
0385 lFeErr.FeMaj = 0;
0386
0387 bool hasCabledChannels = false;
0388 for (unsigned int feUnitCh = 0; feUnitCh < sistrip::FEDCH_PER_FEUNIT; feUnitCh++) {
0389 if (connected_[iFE * sistrip::FEDCH_PER_FEUNIT + feUnitCh]) {
0390 hasCabledChannels = true;
0391 break;
0392 }
0393 }
0394
0395 if (!hasCabledChannels)
0396 continue;
0397
0398 if (aBuffer.feOverflow(iFE)) {
0399 lFeErr.Overflow = true;
0400 foundOverflow = true;
0401 addBadFE(lFeErr);
0402
0403 continue;
0404 }
0405 if (!aBuffer.feEnabled(iFE))
0406 continue;
0407
0408
0409 if (!aBuffer.fePresent(iFE)) {
0410
0411 lFeErr.Missing = true;
0412 foundMissing = true;
0413 addBadFE(lFeErr);
0414
0415 continue;
0416 }
0417
0418
0419
0420
0421
0422 if (aBuffer.majorityAddressErrorForFEUnit(iFE)) {
0423 lFeErr.BadMajorityAddress = true;
0424 foundBadMajority = true;
0425
0426 }
0427
0428
0429 const sistrip::FEDFEHeader* header = aBuffer.feHeader();
0430 const sistrip::FEDFullDebugHeader* debugHeader = dynamic_cast<const sistrip::FEDFullDebugHeader*>(header);
0431
0432
0433
0434
0435
0436
0437
0438
0439
0440
0441
0442
0443
0444
0445
0446
0447
0448
0449
0450
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460 lFeErr.Apve = aBuffer.apveAddress();
0461
0462 if (debugHeader) {
0463 lFeErr.FeMaj = debugHeader->feUnitMajorityAddress(iFE);
0464
0465 if (aDoFEMaj) {
0466 if (lFeErr.SubDetID == 2 || lFeErr.SubDetID == 3 || lFeErr.SubDetID == 4)
0467 aFeMajFrac[0].push_back(std::pair<unsigned int, unsigned int>(fedID_, lFeErr.FeMaj));
0468 else if (lFeErr.SubDetID == 5)
0469 aFeMajFrac[1].push_back(std::pair<unsigned int, unsigned int>(fedID_, lFeErr.FeMaj));
0470 else if (lFeErr.SubDetID == 0)
0471 aFeMajFrac[2].push_back(std::pair<unsigned int, unsigned int>(fedID_, lFeErr.FeMaj));
0472 else if (lFeErr.SubDetID == 1)
0473 aFeMajFrac[3].push_back(std::pair<unsigned int, unsigned int>(fedID_, lFeErr.FeMaj));
0474 }
0475
0476 if (aBuffer.apveAddress()) {
0477 lFeErr.TimeDifference =
0478 static_cast<unsigned int>(
0479 sistrip::FEDAddressConversion::timeLocation(debugHeader->feUnitMajorityAddress(iFE))) -
0480 static_cast<unsigned int>(sistrip::FEDAddressConversion::timeLocation(aBuffer.apveAddress()));
0481
0482
0483 }
0484 }
0485
0486 if (foundBadMajority || lFeErr.TimeDifference != 0) {
0487 addBadFE(lFeErr);
0488
0489
0490
0491
0492
0493
0494
0495
0496
0497
0498
0499
0500
0501
0502 }
0503 }
0504
0505 return !(foundOverflow || foundMissing || foundBadMajority);
0506 }
0507
0508 bool FEDErrors::fillChannelErrors(const sistrip::FEDBuffer& aBuffer,
0509 bool& aFullDebug,
0510 const unsigned int aPrintDebug,
0511 unsigned int& aCounterMonitoring,
0512 unsigned int& aCounterUnpacker,
0513 const bool aDoMeds,
0514 MonitorElement* aMedianHist0,
0515 MonitorElement* aMedianHist1) {
0516 bool foundError = false;
0517
0518 const sistrip::FEDFEHeader* header = aBuffer.feHeader();
0519 const sistrip::FEDFullDebugHeader* debugHeader = dynamic_cast<const sistrip::FEDFullDebugHeader*>(header);
0520
0521 aFullDebug = debugHeader;
0522
0523 bool lMedValid = aBuffer.readoutMode() == sistrip::READOUT_MODE_ZERO_SUPPRESSED;
0524
0525
0526
0527 bool lPassedMonitoringFEDcheck = !fedErrors_.CorruptBuffer;
0528
0529 for (unsigned int iCh = 0; iCh < sistrip::FEDCH_PER_FED; iCh++) {
0530
0531 bool lFailUnpackerChannelCheck = (!aBuffer.channelGood(iCh, true) && connected_[iCh]) || failUnpackerFEDCheck_;
0532 bool lFailMonitoringChannelCheck = !lPassedMonitoringFEDcheck && connected_[iCh];
0533
0534 FEDErrors::ChannelLevelErrors lChErr;
0535 lChErr.ChannelID = iCh;
0536 lChErr.Connected = connected_[iCh];
0537 lChErr.IsActive = false;
0538 lChErr.Unlocked = false;
0539 lChErr.OutOfSync = false;
0540
0541 if (!connected_[iCh]) {
0542
0543 addBadChannel(lChErr);
0544 foundError = true;
0545 } else {
0546 if (!aBuffer.feGood(static_cast<unsigned int>(iCh / sistrip::FEDCH_PER_FEUNIT))) {
0547 lFailMonitoringChannelCheck = true;
0548 foundError = true;
0549 } else {
0550
0551 bool apvBad[2] = {false, false};
0552 sistrip::FEDChannelStatus lStatus = sistrip::CHANNEL_STATUS_NO_PROBLEMS;
0553
0554
0555
0556
0557
0558
0559
0560
0561 if (debugHeader) {
0562 lStatus = debugHeader->getChannelStatus(iCh);
0563 apvBad[0] = !(lStatus & sistrip::CHANNEL_STATUS_LOCKED) || !(lStatus & sistrip::CHANNEL_STATUS_IN_SYNC) ||
0564 !(lStatus & sistrip::CHANNEL_STATUS_APV0_ADDRESS_GOOD) ||
0565 !(lStatus & sistrip::CHANNEL_STATUS_APV0_NO_ERROR_BIT);
0566 apvBad[1] = !(lStatus & sistrip::CHANNEL_STATUS_LOCKED) || !(lStatus & sistrip::CHANNEL_STATUS_IN_SYNC) ||
0567 !(lStatus & sistrip::CHANNEL_STATUS_APV1_ADDRESS_GOOD) ||
0568 !(lStatus & sistrip::CHANNEL_STATUS_APV1_NO_ERROR_BIT);
0569
0570 if (lStatus & sistrip::CHANNEL_STATUS_LOCKED) {
0571 lChErr.IsActive = true;
0572 if (lStatus == sistrip::CHANNEL_STATUS_NO_PROBLEMS)
0573 continue;
0574
0575 if (!(lStatus & sistrip::CHANNEL_STATUS_IN_SYNC)) {
0576 lChErr.OutOfSync = true;
0577 }
0578 } else {
0579 lChErr.Unlocked = true;
0580 }
0581 } else {
0582
0583 [[clang::suppress]] apvBad[0] = !header->checkStatusBits(iCh, 0);
0584 [[clang::suppress]] apvBad[1] = !header->checkStatusBits(iCh, 1);
0585 if (!apvBad[0] && !apvBad[1]) {
0586 lChErr.IsActive = true;
0587 continue;
0588 }
0589 }
0590
0591 if (lChErr.Unlocked || lChErr.OutOfSync)
0592 addBadChannel(lChErr);
0593
0594
0595
0596
0597 bool lFirst = true;
0598
0599 for (unsigned int iAPV = 0; iAPV < 2; iAPV++) {
0600
0601 FEDErrors::APVLevelErrors lAPVErr;
0602 lAPVErr.APVID = 2 * iCh + iAPV;
0603 lAPVErr.ChannelID = iCh;
0604 lAPVErr.Connected = connected_[iCh];
0605 lAPVErr.IsActive = lChErr.IsActive;
0606 lAPVErr.APVStatusBit = false;
0607 lAPVErr.APVError = false;
0608 lAPVErr.APVAddressError = false;
0609
0610
0611 if (apvBad[iAPV]) {
0612 lFailMonitoringChannelCheck = true;
0613 lAPVErr.APVStatusBit = true;
0614 foundError = true;
0615 }
0616
0617 if (debugHeader && !lChErr.Unlocked && !lChErr.OutOfSync) {
0618
0619 if ((iAPV == 0 && !(lStatus & sistrip::CHANNEL_STATUS_APV0_NO_ERROR_BIT)) ||
0620 (iAPV == 1 && !(lStatus & sistrip::CHANNEL_STATUS_APV1_NO_ERROR_BIT))) {
0621 lAPVErr.APVError = true;
0622 }
0623
0624 if ((iAPV == 0 && !(lStatus & sistrip::CHANNEL_STATUS_APV0_ADDRESS_GOOD)) ||
0625 (iAPV == 1 && !(lStatus & sistrip::CHANNEL_STATUS_APV1_ADDRESS_GOOD))) {
0626 lAPVErr.APVAddressError = true;
0627 }
0628 }
0629
0630 if (lAPVErr.APVStatusBit || lAPVErr.APVError || lAPVErr.APVAddressError)
0631 addBadAPV(lAPVErr, lFirst);
0632 }
0633
0634 }
0635 }
0636
0637 if (lFailUnpackerChannelCheck != lFailMonitoringChannelCheck && connected_[iCh]) {
0638 if (aPrintDebug > 1) {
0639 std::ostringstream debugStream;
0640 debugStream << "[FEDErrors] ------ WARNING: FED " << fedID_ << ", channel " << iCh
0641 << ", isConnected = " << connected_[iCh] << std::endl
0642 << "[FEDErrors] --------- Monitoring Channel check ";
0643 if (lFailMonitoringChannelCheck)
0644 debugStream << "failed." << std::endl;
0645 else
0646 debugStream << "passed." << std::endl;
0647 debugStream << "[FEDErrors] --------- Unpacker Channel check ";
0648 if (lFailUnpackerChannelCheck)
0649 debugStream << "failed." << std::endl;
0650 else
0651 debugStream << "passed." << std::endl;
0652 debugStream << "[FEDErrors] --------- fegood = "
0653 << aBuffer.feGood(static_cast<unsigned int>(iCh / sistrip::FEDCH_PER_FEUNIT)) << std::endl
0654 << "[FEDErrors] --------- unpacker FED check = " << failUnpackerFEDCheck_ << std::endl;
0655 edm::LogError("SiStripMonitorHardware") << debugStream.str();
0656 }
0657
0658 if (lFailMonitoringChannelCheck)
0659 aCounterMonitoring++;
0660 if (lFailUnpackerChannelCheck)
0661 aCounterUnpacker++;
0662 }
0663
0664 if (lMedValid && !foundError && lPassedMonitoringFEDcheck && aDoMeds) {
0665
0666 const sistrip::FEDChannel& lChannel = aBuffer.channel(iCh);
0667
0668 HistogramBase::fillHistogram(aMedianHist0, lChannel.cmMedian(0));
0669 HistogramBase::fillHistogram(aMedianHist1, lChannel.cmMedian(1));
0670 }
0671
0672 }
0673
0674 return !foundError;
0675 }
0676
0677 void FEDErrors::fillBadChannelList(const bool doTkHistoMap,
0678 TkHistoMap* aTkMapPointer,
0679 MonitorElement* aFedIdVsApvId,
0680 unsigned int& aNBadChannels,
0681 unsigned int& aNBadActiveChannels,
0682 unsigned int& aNBadChannels_perFEDID,
0683 std::vector<unsigned int>& nTotal,
0684 std::vector<unsigned int>& nErrors) {
0685 uint32_t lPrevId = 0;
0686 uint16_t nBad = 0;
0687 uint16_t lPrevTot = 0;
0688 bool hasBeenProcessed = false;
0689 bool lFailFED = failMonitoringFEDCheck();
0690
0691 for (unsigned int iCh = 0; iCh < sistrip::FEDCH_PER_FED; iCh++) {
0692
0693 if (!connected_[iCh])
0694 continue;
0695 if (!detid_[iCh] || detid_[iCh] == sistrip::invalid32_)
0696 continue;
0697
0698 if (lPrevId == 0) {
0699 lPrevId = detid_[iCh];
0700 lPrevTot = nChInModule_[iCh];
0701 }
0702
0703 unsigned int feNumber = static_cast<unsigned int>(iCh / sistrip::FEDCH_PER_FEUNIT);
0704
0705 bool isBadFE = false;
0706 bool isMissingFE = false;
0707
0708 for (unsigned int badfe(0); badfe < feErrors_.size(); badfe++) {
0709 if ((feErrors_[badfe]).FeID == feNumber) {
0710 isBadFE = true;
0711 if ((feErrors_[badfe]).Missing)
0712 isMissingFE = true;
0713 break;
0714 }
0715 }
0716
0717 bool isBadChan = false;
0718 bool isActiveChan = false;
0719
0720
0721
0722
0723
0724
0725
0726
0727
0728
0729 bool isBadApv1 = false;
0730 bool isBadApv2 = false;
0731 for (unsigned int badApv(0); badApv < apvErrors_.size(); badApv++) {
0732 if ((apvErrors_[badApv]).ChannelID == iCh) {
0733 isBadChan = true;
0734 if (apvErrors_[badApv].IsActive)
0735 isActiveChan = true;
0736 }
0737 if (apvErrors_[badApv].APVID == 2 * iCh)
0738 isBadApv1 = true;
0739 if (apvErrors_[badApv].APVID == 2 * iCh + 1) {
0740 isBadApv2 = true;
0741 break;
0742 }
0743 }
0744
0745 if (detid_[iCh] == lPrevId) {
0746 if (hasBeenProcessed)
0747 hasBeenProcessed = false;
0748 }
0749
0750 if (detid_[iCh] != lPrevId) {
0751 processDet(lPrevId, lPrevTot, doTkHistoMap, nBad, aTkMapPointer);
0752 lPrevId = detid_[iCh];
0753 lPrevTot = nChInModule_[iCh];
0754 hasBeenProcessed = true;
0755 }
0756
0757 bool lHasErr = lFailFED || isBadFE || isBadChan;
0758 incrementLumiErrors(lHasErr, subDetId_[feNumber], nTotal, nErrors);
0759
0760 if (lHasErr) {
0761 nBad++;
0762 aNBadChannels++;
0763 aNBadChannels_perFEDID = aNBadChannels_perFEDID + 1;
0764
0765 if ((isBadChan && isActiveChan) || lFailFED || (isBadFE && !isMissingFE))
0766 aNBadActiveChannels++;
0767 if (isBadApv1 || lFailFED || isBadFE)
0768 HistogramBase::fillHistogram(aFedIdVsApvId, 2 * iCh, fedID_);
0769 if (isBadApv2 || lFailFED || isBadFE)
0770 HistogramBase::fillHistogram(aFedIdVsApvId, 2 * iCh + 1, fedID_);
0771 }
0772
0773 }
0774
0775 if (!hasBeenProcessed) {
0776 processDet(lPrevId, lPrevTot, doTkHistoMap, nBad, aTkMapPointer);
0777 }
0778 }
0779
0780 void FEDErrors::fillEventProperties(long long dbx) { eventProp_.deltaBX = dbx; }
0781
0782 void FEDErrors::incrementLumiErrors(const bool hasError,
0783 const unsigned int aSubDet,
0784 std::vector<unsigned int>& nTotal,
0785 std::vector<unsigned int>& nErrors) {
0786 if (nTotal.empty())
0787 return;
0788 if (aSubDet >= nTotal.size()) {
0789 edm::LogError("SiStripMonitorHardware") << " -- FED " << fedID_ << ", invalid subdetid : " << aSubDet
0790 << ", size of lumiErr : " << nTotal.size() << std::endl;
0791 } else {
0792 if (hasError)
0793 nErrors[aSubDet]++;
0794 nTotal[aSubDet]++;
0795 }
0796 }
0797
0798 void FEDErrors::processDet(const uint32_t aPrevId,
0799 const uint16_t aPrevTot,
0800 const bool doTkHistoMap,
0801 uint16_t& nBad,
0802 TkHistoMap* aTkMapPointer) {
0803 if (aPrevTot < nBad) {
0804 edm::LogError("SiStripMonitorHardware") << " -- Number of bad channels in det " << aPrevId << " = " << nBad
0805 << ", total number of pairs for this det = " << aPrevTot << std::endl;
0806 }
0807
0808
0809 uint32_t lDetid = aPrevId;
0810 if (aPrevTot != 0 && doTkHistoMap && aTkMapPointer)
0811 HistogramBase::fillTkHistoMap(aTkMapPointer, lDetid, static_cast<float>(nBad) / aPrevTot);
0812
0813 nBad = 0;
0814 }
0815
0816 const bool FEDErrors::failMonitoringFEDCheck() { return (anyFEDErrors() || fedErrors_.CorruptBuffer); }
0817
0818 const bool FEDErrors::anyDAQProblems() {
0819 return (fedErrors_.DataMissing || fedErrors_.InvalidBuffers || fedErrors_.BadFEDCRCs || fedErrors_.BadDAQCRCs ||
0820 fedErrors_.BadIDs || fedErrors_.BadDAQPacket);
0821 }
0822
0823 const bool FEDErrors::anyFEDErrors() {
0824 return (fedErrors_.InvalidBuffers || fedErrors_.BadFEDCRCs || fedErrors_.BadDAQCRCs || fedErrors_.BadIDs ||
0825 fedErrors_.BadDAQPacket || fedErrors_.FEsOverflow);
0826 }
0827
0828 const bool FEDErrors::anyFEProblems() {
0829 return (fedErrors_.FEsOverflow || fedErrors_.FEsMissing || fedErrors_.FEsBadMajorityAddress);
0830 }
0831
0832 const bool FEDErrors::printDebug() {
0833 return (anyFEDErrors() || anyFEProblems() || fedErrors_.CorruptBuffer || fedErrors_.BadChannelStatusBit);
0834 }
0835
0836 const unsigned int FEDErrors::fedID() { return fedID_; }
0837
0838 FEDErrors::FEDCounters& FEDErrors::getFEDErrorsCounters() { return lFedCounter_; }
0839
0840 FEDErrors::ChannelCounters& FEDErrors::getChannelErrorsCounters() { return lChCounter_; }
0841
0842 FEDErrors::FECounters& FEDErrors::getFEErrorsCounters() { return feCounter_; }
0843
0844 FEDErrors::FEDLevelErrors& FEDErrors::getFEDLevelErrors() { return fedErrors_; }
0845
0846 FEDErrors::EventProperties& FEDErrors::getEventProperties() { return eventProp_; }
0847
0848 std::vector<FEDErrors::FELevelErrors>& FEDErrors::getFELevelErrors() { return feErrors_; }
0849
0850 std::vector<FEDErrors::ChannelLevelErrors>& FEDErrors::getChannelLevelErrors() { return chErrorsDetailed_; }
0851
0852 std::vector<FEDErrors::APVLevelErrors>& FEDErrors::getAPVLevelErrors() { return apvErrors_; }
0853
0854 std::vector<std::pair<unsigned int, bool> >& FEDErrors::getBadChannels() { return chErrors_; }
0855
0856 void FEDErrors::addBadFE(const FEDErrors::FELevelErrors& aFE) {
0857 if (aFE.Overflow) {
0858 fedErrors_.FEsOverflow = true;
0859 (feCounter_.nFEOverflows)++;
0860 } else if (aFE.Missing) {
0861 fedErrors_.FEsMissing = true;
0862 (feCounter_.nFEMissing)++;
0863 feErrors_.push_back(aFE);
0864 } else if (aFE.BadMajorityAddress) {
0865 fedErrors_.FEsBadMajorityAddress = true;
0866 (feCounter_.nFEBadMajorityAddresses)++;
0867 feErrors_.push_back(aFE);
0868 } else if (aFE.TimeDifference != 0) {
0869 feErrors_.push_back(aFE);
0870 }
0871 }
0872
0873 void FEDErrors::addBadChannel(const FEDErrors::ChannelLevelErrors& aChannel) {
0874 if (aChannel.Connected)
0875 chErrorsDetailed_.push_back(aChannel);
0876 incrementChannelCounters(aChannel);
0877 }
0878
0879 void FEDErrors::addBadAPV(const FEDErrors::APVLevelErrors& aAPV, bool& aFirst) {
0880 apvErrors_.push_back(aAPV);
0881 incrementAPVCounters(aAPV);
0882 if (aAPV.APVStatusBit && aFirst) {
0883 fedErrors_.BadChannelStatusBit = true;
0884 lFedCounter_.nBadChannels++;
0885 chErrors_.push_back(std::pair<unsigned int, bool>(aAPV.ChannelID, aAPV.IsActive));
0886 if (aAPV.IsActive) {
0887
0888 fedErrors_.BadActiveChannelStatusBit = true;
0889 lFedCounter_.nBadActiveChannels++;
0890
0891 }
0892 aFirst = false;
0893 }
0894 }
0895
0896 void FEDErrors::incrementFEDCounters() {
0897 if (fedErrors_.InvalidBuffers || fedErrors_.BadFEDCRCs || fedErrors_.BadDAQCRCs || fedErrors_.BadIDs ||
0898 fedErrors_.BadDAQPacket) {
0899 lFedCounter_.nDAQProblems++;
0900 lFedCounter_.nFEDErrors++;
0901 }
0902
0903
0904 if (fedErrors_.FEsOverflow) {
0905 lFedCounter_.nFEDsWithFEOverflows++;
0906 } else if (fedErrors_.FEsMissing) {
0907 lFedCounter_.nFEDsWithMissingFEs++;
0908 } else if (fedErrors_.FEsBadMajorityAddress) {
0909 lFedCounter_.nFEDsWithFEBadMajorityAddresses++;
0910 }
0911
0912 if (fedErrors_.FEsOverflow || fedErrors_.FEsBadMajorityAddress || fedErrors_.FEsMissing) {
0913 lFedCounter_.nFEDsWithFEProblems++;
0914 lFedCounter_.nFEDErrors++;
0915 } else if (fedErrors_.CorruptBuffer) {
0916 lFedCounter_.nCorruptBuffers++;
0917 lFedCounter_.nFEDErrors++;
0918 }
0919 }
0920
0921 void FEDErrors::incrementChannelCounters(const FEDErrors::ChannelLevelErrors& aChannel) {
0922 if (aChannel.Unlocked && aChannel.Connected)
0923 lChCounter_.nUnlocked++;
0924 if (aChannel.OutOfSync && aChannel.Connected)
0925 lChCounter_.nOutOfSync++;
0926 if (!aChannel.Connected)
0927 lChCounter_.nNotConnected++;
0928 }
0929
0930 void FEDErrors::incrementAPVCounters(const FEDErrors::APVLevelErrors& aAPV) {
0931 if (aAPV.Connected && aAPV.IsActive) {
0932 if (aAPV.APVStatusBit)
0933 lChCounter_.nAPVStatusBit++;
0934 if (aAPV.APVAddressError)
0935 lChCounter_.nAPVAddressError++;
0936 if (aAPV.APVError)
0937 lChCounter_.nAPVError++;
0938 }
0939 }
0940
0941 bool FEDErrors::ChannelLevelErrors::operator<(const FEDErrors::ChannelLevelErrors& aErr) const {
0942 if (this->ChannelID < aErr.ChannelID)
0943 return true;
0944 return false;
0945 }
0946
0947 bool FEDErrors::APVLevelErrors::operator<(const FEDErrors::APVLevelErrors& aErr) const {
0948 if (this->ChannelID < aErr.ChannelID)
0949 return true;
0950 return false;
0951 }
0952
0953 void FEDErrors::print(const FEDErrors::FEDCounters& aFEDCounter, std::ostream& aOs) {
0954 aOs << std::endl;
0955 aOs << "[FEDErrors]============================================" << std::endl
0956 << "[FEDErrors]==== Printing FEDCounters information : ====" << std::endl
0957 << "[FEDErrors]============================================" << std::endl
0958 << "[FEDErrors]======== nFEDErrors = " << aFEDCounter.nFEDErrors << std::endl
0959 << "[FEDErrors]======== nDAQProblems = " << aFEDCounter.nDAQProblems << std::endl
0960 << "[FEDErrors]======== nFEDsWithFEProblems = " << aFEDCounter.nFEDsWithFEProblems << std::endl
0961 << "[FEDErrors]======== nCorruptBuffers = " << aFEDCounter.nCorruptBuffers << std::endl
0962 << "[FEDErrors]======== nBadChannels = " << aFEDCounter.nBadChannels << std::endl
0963 << "[FEDErrors]======== nBadActiveChannels = " << aFEDCounter.nBadActiveChannels << std::endl
0964 << "[FEDErrors]======== nFEDsWithFEOverflows = " << aFEDCounter.nFEDsWithFEOverflows << std::endl
0965 << "[FEDErrors]======== nFEDsWithFEBadMajorityAddresses = " << aFEDCounter.nFEDsWithFEBadMajorityAddresses
0966 << std::endl
0967 << "[FEDErrors]======== nFEDsWithMissingFEs = " << aFEDCounter.nFEDsWithMissingFEs << std::endl
0968 << "[FEDErrors]======== nTotalBadChannels = " << aFEDCounter.nTotalBadChannels << std::endl
0969 << "[FEDErrors]======== nTotalBadActiveChannels = " << aFEDCounter.nTotalBadActiveChannels << std::endl
0970 << "[FEDErrors]============================================" << std::endl;
0971 }
0972
0973 void FEDErrors::print(const FEDErrors::FECounters& aFECounter, std::ostream& aOs) {
0974 aOs << std::endl;
0975 aOs << "[FEDErrors]============================================" << std::endl
0976 << "[FEDErrors]==== Printing FECounters information : ====" << std::endl
0977 << "[FEDErrors]============================================" << std::endl
0978 << "[FEDErrors]======== nFEOverflows = " << aFECounter.nFEOverflows << std::endl
0979 << "[FEDErrors]======== nFEBadMajorityAddresses = " << aFECounter.nFEBadMajorityAddresses << std::endl
0980 << "[FEDErrors]======== nFEMissing = " << aFECounter.nFEMissing << std::endl
0981 << "[FEDErrors]============================================" << std::endl;
0982 }
0983
0984 void FEDErrors::print(const FEDErrors::FEDLevelErrors& aFEDErr, std::ostream& aOs) {
0985 aOs << std::endl;
0986 aOs << "[FEDErrors]============================================" << std::endl
0987 << "[FEDErrors]==== Printing FED errors information : ====" << std::endl
0988 << "[FEDErrors]============================================" << std::endl
0989 << "[FEDErrors]======== HasCabledChannels = " << aFEDErr.HasCabledChannels << std::endl
0990 << "[FEDErrors]======== DataPresent = " << aFEDErr.DataPresent << std::endl
0991 << "[FEDErrors]======== DataMissing = " << aFEDErr.DataMissing << std::endl
0992 << "[FEDErrors]======== InvalidBuffers = " << aFEDErr.InvalidBuffers << std::endl
0993 << "[FEDErrors]======== BadFEDCRCs = " << aFEDErr.BadFEDCRCs << std::endl
0994 << "[FEDErrors]======== BadDAQCRCs = " << aFEDErr.BadDAQCRCs << std::endl
0995 << "[FEDErrors]======== BadIDs = " << aFEDErr.BadIDs << std::endl
0996 << "[FEDErrors]======== BadDAQPacket = " << aFEDErr.BadDAQPacket << std::endl
0997 << "[FEDErrors]======== CorruptBuffer = " << aFEDErr.CorruptBuffer << std::endl
0998 << "[FEDErrors]======== FEOverflows = " << aFEDErr.FEsOverflow << std::endl
0999 << "[FEDErrors]======== FEMissing = " << aFEDErr.FEsMissing << std::endl
1000 << "[FEDErrors]======== BadMajorityAddresses = " << aFEDErr.FEsBadMajorityAddress << std::endl
1001 << "[FEDErrors]============================================" << std::endl;
1002 }
1003
1004 void FEDErrors::print(const FEDErrors::FELevelErrors& aErr, std::ostream& aOs) {
1005 aOs << std::endl;
1006 aOs << "[FEDErrors]============================================" << std::endl
1007 << "[FEDErrors]==== Printing FE errors information : ====" << std::endl
1008 << "[FEDErrors]============================================" << std::endl
1009 << "[FEDErrors]======== FE #" << aErr.FeID << std::endl
1010 << "[FEDErrors]======== subdet " << aErr.SubDetID << std::endl
1011 << "[FEDErrors]======== FEOverflow = " << aErr.Overflow << std::endl
1012 << "[FEDErrors]======== FEMissing = " << aErr.Missing << std::endl
1013 << "[FEDErrors]======== BadMajorityAddresses = " << aErr.BadMajorityAddress << std::endl
1014 << "[FEDErrors]======== TimeDifference = " << aErr.TimeDifference << std::endl
1015 << "[FEDErrors]============================================" << std::endl;
1016 }
1017
1018 void FEDErrors::print(const FEDErrors::ChannelLevelErrors& aErr, std::ostream& aOs) {
1019 aOs << std::endl;
1020 aOs << "[FEDErrors]=================================================" << std::endl
1021 << "[FEDErrors]==== Printing channel errors information : ====" << std::endl
1022 << "[FEDErrors]=================================================" << std::endl
1023 << "[FEDErrors]============ Channel #" << aErr.ChannelID << std::endl
1024 << "[FEDErrors]============ connected = " << aErr.Connected << std::endl
1025 << "[FEDErrors]============ isActive = " << aErr.IsActive << std::endl
1026 << "[FEDErrors]============ Unlocked = " << aErr.Unlocked << std::endl
1027 << "[FEDErrors]============ OutOfSync = " << aErr.OutOfSync << std::endl
1028 << "[FEDErrors]=================================================" << std::endl;
1029 }
1030
1031 void FEDErrors::print(const FEDErrors::APVLevelErrors& aErr, std::ostream& aOs) {
1032 aOs << std::endl;
1033 aOs << "[FEDErrors]=================================================" << std::endl
1034 << "[FEDErrors]==== Printing APV errors information : ====" << std::endl
1035 << "[FEDErrors]=================================================" << std::endl
1036 << "[FEDErrors]============ APV #" << aErr.APVID << std::endl
1037 << "[FEDErrors]============ Channel #" << aErr.ChannelID << std::endl
1038 << "[FEDErrors]============ connected = " << aErr.Connected << std::endl
1039 << "[FEDErrors]============ isActive = " << aErr.IsActive << std::endl
1040 << "[FEDErrors]============ APVStatusBit = " << aErr.APVStatusBit << std::endl
1041 << "[FEDErrors]============ APVError = " << aErr.APVError << std::endl
1042 << "[FEDErrors]============ APVAddressError = " << aErr.APVAddressError << std::endl
1043 << "[FEDErrors]=================================================" << std::endl;
1044 }