File indexing completed on 2022-06-20 00:21:32
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010 #include "DQM/L1TMonitor/interface/L1TStage2CaloLayer1.h"
0011
0012 #include "FWCore/Framework/interface/ESHandle.h"
0013 #include "FWCore/Framework/interface/LuminosityBlock.h"
0014 #include "DataFormats/Provenance/interface/EventAuxiliary.h"
0015
0016 #include "CondFormats/RunInfo/interface/RunInfo.h"
0017 #include "CondFormats/DataRecord/interface/RunSummaryRcd.h"
0018
0019 #include "EventFilter/L1TXRawToDigi/interface/UCTDAQRawData.h"
0020 #include "EventFilter/L1TXRawToDigi/interface/UCTAMCRawData.h"
0021
0022 L1TStage2CaloLayer1::L1TStage2CaloLayer1(const edm::ParameterSet& ps)
0023 : ecalTPSourceRecd_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTPSourceRecd"))),
0024 ecalTPSourceRecdLabel_(ps.getParameter<edm::InputTag>("ecalTPSourceRecd").label()),
0025 ecalTPSourceRecdBx1_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx1"))),
0026 ecalTPSourceRecdBx1Label_(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx1").label()),
0027 ecalTPSourceRecdBx2_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx2"))),
0028 ecalTPSourceRecdBx2Label_(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx2").label()),
0029 ecalTPSourceRecdBx3_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx3"))),
0030 ecalTPSourceRecdBx3Label_(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx3").label()),
0031 ecalTPSourceRecdBx4_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx4"))),
0032 ecalTPSourceRecdBx4Label_(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx4").label()),
0033 ecalTPSourceRecdBx5_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx5"))),
0034 ecalTPSourceRecdBx5Label_(ps.getParameter<edm::InputTag>("ecalTPSourceRecdBx5").label()),
0035 hcalTPSourceRecd_(consumes<HcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("hcalTPSourceRecd"))),
0036 hcalTPSourceRecdLabel_(ps.getParameter<edm::InputTag>("hcalTPSourceRecd").label()),
0037 ecalTPSourceSent_(consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalTPSourceSent"))),
0038 ecalTPSourceSentLabel_(ps.getParameter<edm::InputTag>("ecalTPSourceSent").label()),
0039 hcalTPSourceSent_(consumes<HcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("hcalTPSourceSent"))),
0040 hcalTPSourceSentLabel_(ps.getParameter<edm::InputTag>("hcalTPSourceSent").label()),
0041 fedRawData_(consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("fedRawDataLabel"))),
0042 histFolder_(ps.getParameter<std::string>("histFolder")),
0043 tpFillThreshold_(ps.getUntrackedParameter<int>("etDistributionsFillThreshold", 0)),
0044 tpFillThreshold5Bx_(ps.getUntrackedParameter<int>("etDistributionsFillThreshold5Bx", 4)),
0045 ignoreHFfbs_(ps.getUntrackedParameter<bool>("ignoreHFfbs", false)) {}
0046
0047 L1TStage2CaloLayer1::~L1TStage2CaloLayer1() {}
0048
0049 void L1TStage2CaloLayer1::dqmAnalyze(const edm::Event& event,
0050 const edm::EventSetup& es,
0051 const CaloL1Information::monitoringDataHolder& eventMonitors) const {
0052
0053
0054 std::vector<std::pair<EcalTriggerPrimitiveDigi, EcalTriggerPrimitiveDigi>> ecalTPSentRecd_;
0055 std::vector<std::pair<HcalTriggerPrimitiveDigi, HcalTriggerPrimitiveDigi>> hcalTPSentRecd_;
0056 ecalTPSentRecd_.reserve(28 * 2 * 72);
0057 hcalTPSentRecd_.reserve(41 * 2 * 72);
0058
0059
0060
0061 edm::Handle<FEDRawDataCollection> fedRawDataCollection;
0062 event.getByToken(fedRawData_, fedRawDataCollection);
0063 bool caloLayer1OutOfRun{true};
0064 if (fedRawDataCollection.isValid()) {
0065 caloLayer1OutOfRun = false;
0066 for (int iFed = 1354; iFed < 1360; iFed += 2) {
0067 const FEDRawData& fedRawData = fedRawDataCollection->FEDData(iFed);
0068 if (fedRawData.size() == 0) {
0069 caloLayer1OutOfRun = true;
0070 continue;
0071 }
0072 const uint64_t* fedRawDataArray = (const uint64_t*)fedRawData.data();
0073 UCTDAQRawData daqData(fedRawDataArray);
0074 for (uint32_t i = 0; i < daqData.nAMCs(); i++) {
0075 UCTAMCRawData amcData(daqData.amcPayload(i));
0076 int lPhi = amcData.layer1Phi();
0077 if (daqData.BXID() != amcData.BXID()) {
0078 eventMonitors.bxidErrors_->Fill(lPhi);
0079 }
0080 if (daqData.L1ID() != amcData.L1ID()) {
0081 eventMonitors.l1idErrors_->Fill(lPhi);
0082 }
0083
0084 if ((daqData.orbitNumber() & 0xFFFF) != amcData.orbitNo()) {
0085 eventMonitors.orbitErrors_->Fill(lPhi);
0086 }
0087 }
0088 }
0089 }
0090
0091 edm::Handle<EcalTrigPrimDigiCollection> ecalTPsSent;
0092 event.getByToken(ecalTPSourceSent_, ecalTPsSent);
0093 edm::Handle<EcalTrigPrimDigiCollection> ecalTPsRecd;
0094 event.getByToken(ecalTPSourceRecd_, ecalTPsRecd);
0095
0096 ecalTPSentRecd_.clear();
0097
0098 ComparisonHelper::zip(ecalTPsSent->begin(),
0099 ecalTPsSent->end(),
0100 ecalTPsRecd->begin(),
0101 ecalTPsRecd->end(),
0102 std::inserter(ecalTPSentRecd_, ecalTPSentRecd_.begin()),
0103 EcalTrigPrimDigiCollection::key_compare());
0104
0105 int nEcalLinkErrors{0};
0106 int nEcalMismatch{0};
0107
0108 for (const auto& tpPair : ecalTPSentRecd_) {
0109 auto sentTp = tpPair.first;
0110 if (sentTp.compressedEt() < 0) {
0111
0112
0113 EcalTriggerPrimitiveSample sample(0);
0114 EcalTriggerPrimitiveDigi tpg(sentTp.id());
0115 tpg.setSize(1);
0116 tpg.setSample(0, sample);
0117 swap(sentTp, tpg);
0118 }
0119 const auto& recdTp = tpPair.second;
0120 const int ieta = sentTp.id().ieta();
0121 const int iphi = sentTp.id().iphi();
0122 const bool towerMasked = recdTp.sample(0).raw() & (1 << 13);
0123 const bool linkMasked = recdTp.sample(0).raw() & (1 << 14);
0124 const bool linkError = recdTp.sample(0).raw() & (1 << 15);
0125
0126
0127 if (towerMasked) {
0128 eventMonitors.ecalOccTowerMasked_->Fill(ieta, iphi);
0129 }
0130 if (linkMasked) {
0131 eventMonitors.ecalOccLinkMasked_->Fill(ieta, iphi);
0132 }
0133
0134 if (sentTp.compressedEt() > tpFillThreshold_) {
0135 eventMonitors.ecalTPRawEtSent_->Fill(sentTp.compressedEt());
0136 eventMonitors.ecalOccSent_->Fill(ieta, iphi);
0137 }
0138 if (sentTp.fineGrain() == 1) {
0139 eventMonitors.ecalOccSentFgVB_->Fill(ieta, iphi);
0140 }
0141
0142 if (towerMasked || caloLayer1OutOfRun) {
0143
0144 continue;
0145 }
0146
0147 if (linkError) {
0148 eventMonitors.ecalLinkError_->Fill(ieta, iphi);
0149 eventMonitors.ecalLinkErrorByLumi_->Fill(event.id().luminosityBlock());
0150 nEcalLinkErrors++;
0151
0152 continue;
0153 }
0154
0155 eventMonitors.ecalTPRawEtCorrelation_->Fill(sentTp.compressedEt(), recdTp.compressedEt());
0156
0157 if (recdTp.compressedEt() > tpFillThreshold_) {
0158 eventMonitors.ecalTPRawEtRecd_->Fill(recdTp.compressedEt());
0159 eventMonitors.ecalOccupancy_->Fill(ieta, iphi);
0160 eventMonitors.ecalOccRecdEtWgt_->Fill(ieta, iphi, recdTp.compressedEt());
0161 }
0162 if (recdTp.fineGrain() == 1) {
0163 eventMonitors.ecalOccRecdFgVB_->Fill(ieta, iphi);
0164 }
0165
0166
0167
0168 const bool EetAgreement = sentTp.compressedEt() == recdTp.compressedEt();
0169 const bool EfbAgreement = sentTp.fineGrain() == recdTp.fineGrain();
0170 if (EetAgreement && EfbAgreement) {
0171
0172 if (sentTp.compressedEt() > tpFillThreshold_) {
0173 eventMonitors.ecalOccSentAndRecd_->Fill(ieta, iphi);
0174 eventMonitors.ecalTPRawEtSentAndRecd_->Fill(sentTp.compressedEt());
0175 }
0176 } else {
0177
0178 eventMonitors.ecalDiscrepancy_->Fill(ieta, iphi);
0179 eventMonitors.ecalMismatchByLumi_->Fill(event.id().luminosityBlock());
0180 eventMonitors.ECALmismatchesPerBx_->Fill(event.bunchCrossing());
0181 nEcalMismatch++;
0182
0183 if (not EetAgreement) {
0184 eventMonitors.ecalOccEtDiscrepancy_->Fill(ieta, iphi);
0185 eventMonitors.ecalTPRawEtDiffNoMatch_->Fill(recdTp.compressedEt() - sentTp.compressedEt());
0186 updateMismatch(event, 0, streamCache(event.streamID())->streamMismatchList);
0187
0188 if (sentTp.compressedEt() == 0)
0189 eventMonitors.ecalOccRecdNotSent_->Fill(ieta, iphi);
0190 else if (recdTp.compressedEt() == 0)
0191 eventMonitors.ecalOccSentNotRecd_->Fill(ieta, iphi);
0192 else
0193 eventMonitors.ecalOccNoMatch_->Fill(ieta, iphi);
0194 }
0195 if (not EfbAgreement) {
0196
0197 eventMonitors.ecalOccFgDiscrepancy_->Fill(ieta, iphi);
0198 updateMismatch(event, 1, streamCache(event.streamID())->streamMismatchList);
0199 }
0200 }
0201 }
0202
0203 if (nEcalLinkErrors > streamCache(event.streamID())->streamNumMaxEvtLinkErrorsECAL)
0204 streamCache(event.streamID())->streamNumMaxEvtLinkErrorsECAL = nEcalLinkErrors;
0205
0206 if (nEcalMismatch > streamCache(event.streamID())->streamNumMaxEvtMismatchECAL)
0207 streamCache(event.streamID())->streamNumMaxEvtMismatchECAL = nEcalMismatch;
0208
0209 edm::Handle<EcalTrigPrimDigiCollection> ecalTPsRecdBx1;
0210 event.getByToken(ecalTPSourceRecdBx1_, ecalTPsRecdBx1);
0211 edm::Handle<EcalTrigPrimDigiCollection> ecalTPsRecdBx2;
0212 event.getByToken(ecalTPSourceRecdBx2_, ecalTPsRecdBx2);
0213 edm::Handle<EcalTrigPrimDigiCollection> ecalTPsRecdBx3;
0214 event.getByToken(ecalTPSourceRecdBx3_, ecalTPsRecdBx3);
0215 edm::Handle<EcalTrigPrimDigiCollection> ecalTPsRecdBx4;
0216 event.getByToken(ecalTPSourceRecdBx4_, ecalTPsRecdBx4);
0217 edm::Handle<EcalTrigPrimDigiCollection> ecalTPsRecdBx5;
0218 event.getByToken(ecalTPSourceRecdBx5_, ecalTPsRecdBx5);
0219
0220 for (const auto& tp : (*ecalTPsRecdBx1)) {
0221 if (tp.compressedEt() > tpFillThreshold5Bx_) {
0222 const int ieta = tp.id().ieta();
0223 const int iphi = tp.id().iphi();
0224 const bool towerMasked = tp.sample(0).raw() & (1 << 13);
0225 const bool linkError = tp.sample(0).raw() & (1 << 15);
0226 if (towerMasked || caloLayer1OutOfRun || linkError) {
0227 continue;
0228 }
0229 eventMonitors.ecalOccRecdBx1_->Fill(ieta, iphi);
0230 eventMonitors.ecalOccRecd5Bx_->Fill(1);
0231 eventMonitors.ecalOccRecd5BxEtWgt_->Fill(1, tp.compressedEt());
0232 }
0233 }
0234 for (const auto& tp : (*ecalTPsRecdBx2)) {
0235 if (tp.compressedEt() > tpFillThreshold5Bx_) {
0236 const int ieta = tp.id().ieta();
0237 const int iphi = tp.id().iphi();
0238 const bool towerMasked = tp.sample(0).raw() & (1 << 13);
0239 const bool linkError = tp.sample(0).raw() & (1 << 15);
0240 if (towerMasked || caloLayer1OutOfRun || linkError) {
0241 continue;
0242 }
0243 eventMonitors.ecalOccRecdBx2_->Fill(ieta, iphi);
0244 eventMonitors.ecalOccRecd5Bx_->Fill(2);
0245 eventMonitors.ecalOccRecd5BxEtWgt_->Fill(2, tp.compressedEt());
0246 }
0247 }
0248 for (const auto& tp : (*ecalTPsRecdBx3)) {
0249 if (tp.compressedEt() > tpFillThreshold5Bx_) {
0250 const int ieta = tp.id().ieta();
0251 const int iphi = tp.id().iphi();
0252 const bool towerMasked = tp.sample(0).raw() & (1 << 13);
0253 const bool linkError = tp.sample(0).raw() & (1 << 15);
0254 if (towerMasked || caloLayer1OutOfRun || linkError) {
0255 continue;
0256 }
0257 eventMonitors.ecalOccRecdBx3_->Fill(ieta, iphi);
0258 eventMonitors.ecalOccRecd5Bx_->Fill(3);
0259 eventMonitors.ecalOccRecd5BxEtWgt_->Fill(3, tp.compressedEt());
0260 }
0261 }
0262 for (const auto& tp : (*ecalTPsRecdBx4)) {
0263 if (tp.compressedEt() > tpFillThreshold5Bx_) {
0264 const int ieta = tp.id().ieta();
0265 const int iphi = tp.id().iphi();
0266 const bool towerMasked = tp.sample(0).raw() & (1 << 13);
0267 const bool linkError = tp.sample(0).raw() & (1 << 15);
0268 if (towerMasked || caloLayer1OutOfRun || linkError) {
0269 continue;
0270 }
0271 eventMonitors.ecalOccRecdBx4_->Fill(ieta, iphi);
0272 eventMonitors.ecalOccRecd5Bx_->Fill(4);
0273 eventMonitors.ecalOccRecd5BxEtWgt_->Fill(4, tp.compressedEt());
0274 }
0275 }
0276 for (const auto& tp : (*ecalTPsRecdBx5)) {
0277 if (tp.compressedEt() > tpFillThreshold5Bx_) {
0278 const int ieta = tp.id().ieta();
0279 const int iphi = tp.id().iphi();
0280 const bool towerMasked = tp.sample(0).raw() & (1 << 13);
0281 const bool linkError = tp.sample(0).raw() & (1 << 15);
0282 if (towerMasked || caloLayer1OutOfRun || linkError) {
0283 continue;
0284 }
0285 eventMonitors.ecalOccRecdBx5_->Fill(ieta, iphi);
0286 eventMonitors.ecalOccRecd5Bx_->Fill(5);
0287 eventMonitors.ecalOccRecd5BxEtWgt_->Fill(5, tp.compressedEt());
0288 }
0289 }
0290
0291 edm::Handle<HcalTrigPrimDigiCollection> hcalTPsSent;
0292 event.getByToken(hcalTPSourceSent_, hcalTPsSent);
0293 edm::Handle<HcalTrigPrimDigiCollection> hcalTPsRecd;
0294 event.getByToken(hcalTPSourceRecd_, hcalTPsRecd);
0295
0296 hcalTPSentRecd_.clear();
0297
0298 ComparisonHelper::zip(hcalTPsSent->begin(),
0299 hcalTPsSent->end(),
0300 hcalTPsRecd->begin(),
0301 hcalTPsRecd->end(),
0302 std::inserter(hcalTPSentRecd_, hcalTPSentRecd_.begin()),
0303 HcalTrigPrimDigiCollection::key_compare());
0304
0305 int nHcalLinkErrors{0};
0306 int nHcalMismatch{0};
0307
0308 for (const auto& tpPair : hcalTPSentRecd_) {
0309 const auto& sentTp = tpPair.first;
0310 const auto& recdTp = tpPair.second;
0311 const int ieta = sentTp.id().ieta();
0312 if (abs(ieta) > 28 && sentTp.id().version() != 1)
0313 continue;
0314 const int iphi = sentTp.id().iphi();
0315 const bool towerMasked = recdTp.sample(0).raw() & (1 << 13);
0316 const bool linkMasked = recdTp.sample(0).raw() & (1 << 14);
0317 const bool linkError = recdTp.sample(0).raw() & (1 << 15);
0318
0319 if (towerMasked) {
0320 eventMonitors.hcalOccTowerMasked_->Fill(ieta, iphi);
0321 }
0322 if (linkMasked) {
0323 eventMonitors.hcalOccLinkMasked_->Fill(ieta, iphi);
0324 }
0325
0326 if (sentTp.SOI_compressedEt() > tpFillThreshold_) {
0327 eventMonitors.hcalTPRawEtSent_->Fill(sentTp.SOI_compressedEt());
0328 eventMonitors.hcalOccSent_->Fill(ieta, iphi);
0329 }
0330 if (sentTp.SOI_fineGrain() == 1) {
0331 eventMonitors.hcalOccSentFb_->Fill(ieta, iphi);
0332 }
0333 if (sentTp.t0().fineGrain(1) == 1) {
0334 eventMonitors.hcalOccSentFb2_->Fill(ieta, iphi);
0335 }
0336
0337 if (towerMasked || caloLayer1OutOfRun) {
0338
0339 continue;
0340 }
0341
0342 if (linkError) {
0343 eventMonitors.hcalLinkError_->Fill(ieta, iphi);
0344 eventMonitors.hcalLinkErrorByLumi_->Fill(event.id().luminosityBlock());
0345 nHcalLinkErrors++;
0346
0347 continue;
0348 }
0349
0350 if (recdTp.SOI_compressedEt() > tpFillThreshold_) {
0351 eventMonitors.hcalTPRawEtRecd_->Fill(recdTp.SOI_compressedEt());
0352 eventMonitors.hcalOccupancy_->Fill(ieta, iphi);
0353 eventMonitors.hcalOccRecdEtWgt_->Fill(ieta, iphi, recdTp.SOI_compressedEt());
0354 }
0355 if (recdTp.SOI_fineGrain()) {
0356 eventMonitors.hcalOccRecdFb_->Fill(ieta, iphi);
0357 }
0358 if (recdTp.t0().fineGrain(1)) {
0359 eventMonitors.hcalOccRecdFb2_->Fill(ieta, iphi);
0360 }
0361
0362 if (abs(ieta) > 29) {
0363 eventMonitors.hcalTPRawEtCorrelationHF_->Fill(sentTp.SOI_compressedEt(), recdTp.SOI_compressedEt());
0364 } else {
0365 eventMonitors.hcalTPRawEtCorrelationHBHE_->Fill(sentTp.SOI_compressedEt(), recdTp.SOI_compressedEt());
0366 }
0367
0368 const bool HetAgreement = sentTp.SOI_compressedEt() == recdTp.SOI_compressedEt();
0369 const bool Hfb1Agreement = (abs(ieta) < 29) ? true
0370 : (recdTp.SOI_compressedEt() == 0 ||
0371 (sentTp.SOI_fineGrain() == recdTp.SOI_fineGrain()) || ignoreHFfbs_);
0372
0373 const bool Hfb2Agreement =
0374 (abs(ieta) < 29)
0375 ? true
0376 : (recdTp.SOI_compressedEt() == 0 || (sentTp.SOI_fineGrain(1) == recdTp.SOI_fineGrain(1)) || ignoreHFfbs_);
0377 if (HetAgreement && Hfb1Agreement && Hfb2Agreement) {
0378
0379 if (sentTp.SOI_compressedEt() > tpFillThreshold_) {
0380 eventMonitors.hcalOccSentAndRecd_->Fill(ieta, iphi);
0381 eventMonitors.hcalTPRawEtSentAndRecd_->Fill(sentTp.SOI_compressedEt());
0382 }
0383 } else {
0384
0385 eventMonitors.hcalDiscrepancy_->Fill(ieta, iphi);
0386 eventMonitors.hcalMismatchByLumi_->Fill(event.id().luminosityBlock());
0387 nHcalMismatch++;
0388
0389 if (not HetAgreement) {
0390 if (abs(ieta) > 29) {
0391 eventMonitors.HFmismatchesPerBx_->Fill(event.bunchCrossing());
0392 } else {
0393 eventMonitors.HBHEmismatchesPerBx_->Fill(event.bunchCrossing());
0394 }
0395 eventMonitors.hcalOccEtDiscrepancy_->Fill(ieta, iphi);
0396 eventMonitors.hcalTPRawEtDiffNoMatch_->Fill(recdTp.SOI_compressedEt() - sentTp.SOI_compressedEt());
0397 updateMismatch(event, 2, streamCache(event.streamID())->streamMismatchList);
0398
0399
0400 if (sentTp.SOI_compressedEt() == 0)
0401 eventMonitors.hcalOccRecdNotSent_->Fill(ieta, iphi);
0402 else if (recdTp.SOI_compressedEt() == 0)
0403 eventMonitors.hcalOccSentNotRecd_->Fill(ieta, iphi);
0404 else
0405 eventMonitors.hcalOccNoMatch_->Fill(ieta, iphi);
0406 }
0407 if (not Hfb1Agreement) {
0408
0409 eventMonitors.hcalOccFbDiscrepancy_->Fill(ieta, iphi);
0410 updateMismatch(event, 3, streamCache(event.streamID())->streamMismatchList);
0411 }
0412 if (not Hfb2Agreement) {
0413
0414 eventMonitors.hcalOccFb2Discrepancy_->Fill(ieta, iphi);
0415 updateMismatch(event, 3, streamCache(event.streamID())->streamMismatchList);
0416 }
0417 }
0418 }
0419
0420 if (nHcalLinkErrors > streamCache(event.streamID())->streamNumMaxEvtLinkErrorsHCAL)
0421 streamCache(event.streamID())->streamNumMaxEvtLinkErrorsHCAL = nHcalLinkErrors;
0422 if (nHcalMismatch > streamCache(event.streamID())->streamNumMaxEvtMismatchHCAL)
0423 streamCache(event.streamID())->streamNumMaxEvtMismatchHCAL = nHcalMismatch;
0424
0425
0426 if (nEcalLinkErrors >= nHcalLinkErrors && nEcalLinkErrors > streamCache(event.streamID())->streamNumMaxEvtLinkErrors)
0427 streamCache(event.streamID())->streamNumMaxEvtLinkErrors = nEcalLinkErrors;
0428 else if (nEcalLinkErrors < nHcalLinkErrors &&
0429 nHcalLinkErrors > streamCache(event.streamID())->streamNumMaxEvtLinkErrors)
0430 streamCache(event.streamID())->streamNumMaxEvtLinkErrors = nHcalLinkErrors;
0431
0432 if (nEcalMismatch >= nHcalMismatch && nEcalMismatch > streamCache(event.streamID())->streamNumMaxEvtMismatch)
0433 streamCache(event.streamID())->streamNumMaxEvtMismatch = nEcalMismatch;
0434 else if (nEcalMismatch < nHcalMismatch && nHcalMismatch > streamCache(event.streamID())->streamNumMaxEvtMismatch)
0435 streamCache(event.streamID())->streamNumMaxEvtMismatch = nHcalMismatch;
0436 }
0437
0438
0439
0440 void L1TStage2CaloLayer1::updateMismatch(
0441 const edm::Event& e,
0442 int mismatchType,
0443 std::vector<std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>>>& streamMismatches)
0444 const {
0445
0446
0447 for (auto mismatchIterator = streamMismatches.begin(); mismatchIterator != streamMismatches.end();
0448 ++mismatchIterator) {
0449 if (e.getRun().id() == std::get<0>(*mismatchIterator) &&
0450 e.getLuminosityBlock().id() == std::get<1>(*mismatchIterator) && e.id() == std::get<2>(*mismatchIterator)) {
0451
0452 std::vector<int>& mismatchTypeVector = std::get<3>(*mismatchIterator);
0453 for (auto mismatchTypeIterator = mismatchTypeVector.begin(); mismatchTypeIterator != mismatchTypeVector.end();
0454 ++mismatchTypeIterator) {
0455 if (mismatchType == *mismatchTypeIterator) {
0456
0457 return;
0458 }
0459 }
0460
0461
0462 mismatchTypeVector.push_back(mismatchType);
0463 return;
0464 }
0465 }
0466
0467
0468 std::vector<int> newMismatchTypeVector;
0469 newMismatchTypeVector.push_back(mismatchType);
0470 std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>> mismatchToInsert = {
0471 e.getRun().id(), e.getLuminosityBlock().id(), e.id(), newMismatchTypeVector};
0472 streamMismatches.push_back(mismatchToInsert);
0473
0474
0475 if (streamMismatches.size() > 20)
0476 streamMismatches.erase(streamMismatches.begin());
0477 }
0478
0479 void L1TStage2CaloLayer1::dqmBeginRun(const edm::Run&,
0480 const edm::EventSetup&,
0481 CaloL1Information::monitoringDataHolder& eventMonitors) const {}
0482
0483 void L1TStage2CaloLayer1::dqmEndRun(const edm::Run& run,
0484 const edm::EventSetup& es,
0485 const CaloL1Information::monitoringDataHolder& runMonitors,
0486 const CaloL1Information::perRunSummaryMonitoringInformation&) const {}
0487
0488 void L1TStage2CaloLayer1::bookHistograms(DQMStore::IBooker& ibooker,
0489 const edm::Run& run,
0490 const edm::EventSetup& es,
0491 CaloL1Information::monitoringDataHolder& eventMonitors) const {
0492 auto bookEt = [&ibooker](std::string name, std::string title) {
0493 return ibooker.book1D(name, title + ";Raw ET;Counts", 256, -0.5, 255.5);
0494 };
0495 auto bookEtCorrelation = [&ibooker](std::string name, std::string title) {
0496 return ibooker.book2D(name, title, 256, -0.5, 255.5, 256, -0.5, 255.5);
0497 };
0498 auto bookEtDiff = [&ibooker](std::string name, std::string title) {
0499 return ibooker.book1D(name, title + ";#Delta Raw ET;Counts", 511, -255.5, 255.5);
0500 };
0501 auto bookEcalOccupancy = [&ibooker](std::string name, std::string title) {
0502 return ibooker.book2D(name, title + ";iEta;iPhi", 57, -28.5, 28.5, 72, 0.5, 72.5);
0503 };
0504 auto bookHcalOccupancy = [&ibooker](std::string name, std::string title) {
0505 return ibooker.book2D(name, title + ";iEta;iPhi", 83, -41.5, 41.5, 72, 0.5, 72.5);
0506 };
0507
0508 ibooker.setCurrentFolder(histFolder_);
0509
0510 eventMonitors.ecalDiscrepancy_ =
0511 bookEcalOccupancy("ecalDiscrepancy", "ECAL Discrepancies between TCC and Layer1 Readout");
0512 eventMonitors.ecalLinkError_ = bookEcalOccupancy("ecalLinkError", "ECAL Link Errors");
0513 eventMonitors.ecalOccupancy_ = bookEcalOccupancy("ecalOccupancy", "ECAL TP Occupancy at Layer1");
0514 eventMonitors.ecalOccRecdEtWgt_ = bookEcalOccupancy("ecalOccRecdEtWgt", "ECal TP ET-weighted Occupancy at Layer1");
0515 eventMonitors.hcalDiscrepancy_ =
0516 bookHcalOccupancy("hcalDiscrepancy", "HCAL Discrepancies between uHTR and Layer1 Readout");
0517 eventMonitors.hcalLinkError_ = bookHcalOccupancy("hcalLinkError", "HCAL Link Errors");
0518 eventMonitors.hcalOccupancy_ = bookHcalOccupancy("hcalOccupancy", "HCAL TP Occupancy at Layer1");
0519 eventMonitors.hcalOccRecdEtWgt_ = bookHcalOccupancy("hcalOccRecdEtWgt", "HCal TP ET-weighted Occupancy at Layer1");
0520
0521 ibooker.setCurrentFolder(histFolder_ + "/ECalDetail");
0522
0523 eventMonitors.ecalOccEtDiscrepancy_ = bookEcalOccupancy("ecalOccEtDiscrepancy", "ECal Et Discrepancy Occupancy");
0524 eventMonitors.ecalOccFgDiscrepancy_ =
0525 bookEcalOccupancy("ecalOccFgDiscrepancy", "ECal FG Veto Bit Discrepancy Occupancy");
0526 eventMonitors.ecalOccLinkMasked_ = bookEcalOccupancy("ecalOccLinkMasked", "ECal Masked Links");
0527 eventMonitors.ecalOccRecdFgVB_ = bookEcalOccupancy("ecalOccRecdFgVB", "ECal FineGrain Veto Bit Occupancy at Layer1");
0528 eventMonitors.ecalOccSentAndRecd_ = bookEcalOccupancy("ecalOccSentAndRecd", "ECal TP Occupancy FULL MATCH");
0529 eventMonitors.ecalOccSentFgVB_ = bookEcalOccupancy("ecalOccSentFgVB", "ECal FineGrain Veto Bit Occupancy at TCC");
0530 eventMonitors.ecalOccSent_ = bookEcalOccupancy("ecalOccSent", "ECal TP Occupancy at TCC");
0531 eventMonitors.ecalOccTowerMasked_ = bookEcalOccupancy("ecalOccTowerMasked", "ECal Masked towers");
0532 eventMonitors.ecalTPRawEtCorrelation_ =
0533 bookEtCorrelation("ecalTPRawEtCorrelation", "Raw Et correlation TCC and Layer1;TCC Et;Layer1 Et");
0534 eventMonitors.ecalTPRawEtDiffNoMatch_ = bookEtDiff("ecalTPRawEtDiffNoMatch", "ECal Raw Et Difference Layer1 - TCC");
0535 eventMonitors.ecalTPRawEtRecd_ = bookEt("ecalTPRawEtRecd", "ECal Raw Et Layer1 Readout");
0536 eventMonitors.ecalTPRawEtSentAndRecd_ = bookEt("ecalTPRawEtMatch", "ECal Raw Et FULL MATCH");
0537 eventMonitors.ecalTPRawEtSent_ = bookEt("ecalTPRawEtSent", "ECal Raw Et TCC Readout");
0538 eventMonitors.ecalOccRecd5Bx_ = ibooker.book1D("ecalOccRecd5Bx", "Number of TPs vs BX", 5, 1, 6);
0539 eventMonitors.ecalOccRecd5BxEtWgt_ =
0540 ibooker.book1D("ecalOccRecd5BxEtWgt", "Et-weighted number of TPs vs BX", 5, 1, 6);
0541 eventMonitors.ecalOccRecdBx1_ = bookEcalOccupancy("ecalOccRecdBx1", "ECal TP Occupancy for BX1");
0542 eventMonitors.ecalOccRecdBx2_ = bookEcalOccupancy("ecalOccRecdBx2", "ECal TP Occupancy for BX2");
0543 eventMonitors.ecalOccRecdBx3_ = bookEcalOccupancy("ecalOccRecdBx3", "ECal TP Occupancy for BX3");
0544 eventMonitors.ecalOccRecdBx4_ = bookEcalOccupancy("ecalOccRecdBx4", "ECal TP Occupancy for BX4");
0545 eventMonitors.ecalOccRecdBx5_ = bookEcalOccupancy("ecalOccRecdBx5", "ECal TP Occupancy for BX5");
0546
0547 ibooker.setCurrentFolder(histFolder_ + "/ECalDetail/TCCDebug");
0548 eventMonitors.ecalOccSentNotRecd_ =
0549 bookHcalOccupancy("ecalOccSentNotRecd", "ECal TP Occupancy sent by TCC, zero at Layer1");
0550 eventMonitors.ecalOccRecdNotSent_ =
0551 bookHcalOccupancy("ecalOccRecdNotSent", "ECal TP Occupancy received by Layer1, zero at TCC");
0552 eventMonitors.ecalOccNoMatch_ =
0553 bookHcalOccupancy("ecalOccNoMatch", "ECal TP Occupancy for TCC and Layer1 nonzero, not matching");
0554
0555 ibooker.setCurrentFolder(histFolder_ + "/HCalDetail");
0556
0557 eventMonitors.hcalOccEtDiscrepancy_ = bookHcalOccupancy("hcalOccEtDiscrepancy", "HCal Et Discrepancy Occupancy");
0558 eventMonitors.hcalOccFbDiscrepancy_ =
0559 bookHcalOccupancy("hcalOccFbDiscrepancy", "HCal Feature Bit Discrepancy Occupancy");
0560 eventMonitors.hcalOccFb2Discrepancy_ =
0561 bookHcalOccupancy("hcalOccFb2Discrepancy", "HCal Second Feature Bit Discrepancy Occupancy");
0562 eventMonitors.hcalOccLinkMasked_ = bookHcalOccupancy("hcalOccLinkMasked", "HCal Masked Links");
0563 eventMonitors.hcalOccRecdFb_ = bookHcalOccupancy("hcalOccRecdFb", "HCal Feature Bit Occupancy at Layer1");
0564 eventMonitors.hcalOccRecdFb2_ = bookHcalOccupancy("hcalOccRecdFb2", "HF Second Feature Bit Occupancy at Layer1");
0565 eventMonitors.hcalOccSentAndRecd_ = bookHcalOccupancy("hcalOccSentAndRecd", "HCal TP Occupancy FULL MATCH");
0566 eventMonitors.hcalOccSentFb_ = bookHcalOccupancy("hcalOccSentFb", "HCal Feature Bit Occupancy at uHTR");
0567 eventMonitors.hcalOccSentFb2_ = bookHcalOccupancy("hcalOccSentFb2", "HF Second Feature Bit Occupancy at uHTR");
0568 eventMonitors.hcalOccSent_ = bookHcalOccupancy("hcalOccSent", "HCal TP Occupancy at uHTR");
0569 eventMonitors.hcalOccTowerMasked_ = bookHcalOccupancy("hcalOccTowerMasked", "HCal Masked towers");
0570 eventMonitors.hcalTPRawEtCorrelationHBHE_ =
0571 bookEtCorrelation("hcalTPRawEtCorrelationHBHE", "HBHE Raw Et correlation uHTR and Layer1;uHTR Et;Layer1 Et");
0572 eventMonitors.hcalTPRawEtCorrelationHF_ =
0573 bookEtCorrelation("hcalTPRawEtCorrelationHF", "HF Raw Et correlation uHTR and Layer1;uHTR Et;Layer1 Et");
0574 eventMonitors.hcalTPRawEtDiffNoMatch_ = bookEtDiff("hcalTPRawEtDiffNoMatch", "HCal Raw Et Difference Layer1 - uHTR");
0575 eventMonitors.hcalTPRawEtRecd_ = bookEt("hcalTPRawEtRecd", "HCal Raw Et Layer1 Readout");
0576 eventMonitors.hcalTPRawEtSentAndRecd_ = bookEt("hcalTPRawEtMatch", "HCal Raw Et FULL MATCH");
0577 eventMonitors.hcalTPRawEtSent_ = bookEt("hcalTPRawEtSent", "HCal Raw Et uHTR Readout");
0578
0579 ibooker.setCurrentFolder(histFolder_ + "/HCalDetail/uHTRDebug");
0580 eventMonitors.hcalOccSentNotRecd_ =
0581 bookHcalOccupancy("hcalOccSentNotRecd", "HCal TP Occupancy sent by uHTR, zero at Layer1");
0582 eventMonitors.hcalOccRecdNotSent_ =
0583 bookHcalOccupancy("hcalOccRecdNotSent", "HCal TP Occupancy received by Layer1, zero at uHTR");
0584 eventMonitors.hcalOccNoMatch_ =
0585 bookHcalOccupancy("hcalOccNoMatch", "HCal TP Occupancy for uHTR and Layer1 nonzero, not matching");
0586
0587 ibooker.setCurrentFolder(histFolder_ + "/MismatchDetail");
0588
0589 const int nMismatchTypes = 4;
0590 eventMonitors.last20Mismatches_ = ibooker.book2D("last20Mismatches",
0591 "Log of last 20 mismatches (use json tool to copy/paste)",
0592 nMismatchTypes,
0593 0,
0594 nMismatchTypes,
0595 20,
0596 0,
0597 20);
0598 eventMonitors.last20Mismatches_->setBinLabel(1, "Ecal TP Et Mismatch");
0599 eventMonitors.last20Mismatches_->setBinLabel(2, "Ecal TP Fine Grain Bit Mismatch");
0600 eventMonitors.last20Mismatches_->setBinLabel(3, "Hcal TP Et Mismatch");
0601 eventMonitors.last20Mismatches_->setBinLabel(4, "Hcal TP Feature Bit Mismatch");
0602
0603 const int nLumis = 2000;
0604 eventMonitors.ecalLinkErrorByLumi_ = ibooker.book1D(
0605 "ecalLinkErrorByLumi", "Link error counts per lumi section for ECAL;LumiSection;Counts", nLumis, .5, nLumis + 0.5);
0606 eventMonitors.ecalMismatchByLumi_ = ibooker.book1D(
0607 "ecalMismatchByLumi", "Mismatch counts per lumi section for ECAL;LumiSection;Counts", nLumis, .5, nLumis + 0.5);
0608 eventMonitors.hcalLinkErrorByLumi_ = ibooker.book1D(
0609 "hcalLinkErrorByLumi", "Link error counts per lumi section for HCAL;LumiSection;Counts", nLumis, .5, nLumis + 0.5);
0610 eventMonitors.hcalMismatchByLumi_ = ibooker.book1D(
0611 "hcalMismatchByLumi", "Mismatch counts per lumi section for HCAL;LumiSection;Counts", nLumis, .5, nLumis + 0.5);
0612
0613 eventMonitors.ECALmismatchesPerBx_ =
0614 ibooker.book1D("ECALmismatchesPerBx", "Mismatch counts per bunch crossing for ECAL", 3564, -.5, 3563.5);
0615 eventMonitors.HBHEmismatchesPerBx_ =
0616 ibooker.book1D("HBHEmismatchesPerBx", "Mismatch counts per bunch crossing for HBHE", 3564, -.5, 3563.5);
0617 eventMonitors.HFmismatchesPerBx_ =
0618 ibooker.book1D("HFmismatchesPerBx", "Mismatch counts per bunch crossing for HF", 3564, -.5, 3563.5);
0619
0620 eventMonitors.maxEvtLinkErrorsByLumiECAL_ =
0621 ibooker.book1D("maxEvtLinkErrorsByLumiECAL",
0622 "Max number of single-event ECAL link errors per lumi section;LumiSection;Counts",
0623 nLumis,
0624 .5,
0625 nLumis + 0.5);
0626 eventMonitors.maxEvtLinkErrorsByLumiHCAL_ =
0627 ibooker.book1D("maxEvtLinkErrorsByLumiHCAL",
0628 "Max number of single-event HCAL link errors per lumi section;LumiSection;Counts",
0629 nLumis,
0630 .5,
0631 nLumis + 0.5);
0632
0633 eventMonitors.maxEvtMismatchByLumiECAL_ =
0634 ibooker.book1D("maxEvtMismatchByLumiECAL",
0635 "Max number of single-event ECAL discrepancies per lumi section;LumiSection;Counts",
0636 nLumis,
0637 .5,
0638 nLumis + 0.5);
0639 eventMonitors.maxEvtMismatchByLumiHCAL_ =
0640 ibooker.book1D("maxEvtMismatchByLumiHCAL",
0641 "Max number of single-event HCAL discrepancies per lumi section;LumiSection;Counts",
0642 nLumis,
0643 .5,
0644 nLumis + 0.5);
0645
0646 ibooker.setCurrentFolder(histFolder_);
0647 eventMonitors.maxEvtLinkErrorsByLumi_ =
0648 ibooker.book1D("maxEvtLinkErrorsByLumi",
0649 "Max number of single-event link errors per lumi section;LumiSection;Counts",
0650 nLumis,
0651 .5,
0652 nLumis + 0.5);
0653 eventMonitors.maxEvtMismatchByLumi_ =
0654 ibooker.book1D("maxEvtMismatchByLumi",
0655 "Max number of single-event discrepancies per lumi section;LumiSection;Counts",
0656 nLumis,
0657 .5,
0658 nLumis + 0.5);
0659
0660 ibooker.setCurrentFolder(histFolder_ + "/AMC13ErrorCounters");
0661 eventMonitors.bxidErrors_ =
0662 ibooker.book1D("bxidErrors", "bxid mismatch between AMC13 and CTP Cards;Layer1 Phi;Counts", 18, -.5, 17.5);
0663 eventMonitors.l1idErrors_ =
0664 ibooker.book1D("l1idErrors", "l1id mismatch between AMC13 and CTP Cards;Layer1 Phi;Counts", 18, -.5, 17.5);
0665 eventMonitors.orbitErrors_ =
0666 ibooker.book1D("orbitErrors", "orbit mismatch between AMC13 and CTP Cards;Layer1 Phi;Counts", 18, -.5, 17.5);
0667 }
0668
0669 void L1TStage2CaloLayer1::streamEndLuminosityBlockSummary(
0670 edm::StreamID theStreamID,
0671 edm::LuminosityBlock const& theLumiBlock,
0672 edm::EventSetup const& theEventSetup,
0673 CaloL1Information::perLumiBlockMonitoringInformation* lumiMonitoringInformation) const {
0674 auto theStreamCache = streamCache(theStreamID);
0675
0676 lumiMonitoringInformation->lumiNumMaxEvtLinkErrorsECAL =
0677 std::max(lumiMonitoringInformation->lumiNumMaxEvtLinkErrorsECAL, theStreamCache->streamNumMaxEvtLinkErrorsECAL);
0678 lumiMonitoringInformation->lumiNumMaxEvtLinkErrorsHCAL =
0679 std::max(lumiMonitoringInformation->lumiNumMaxEvtLinkErrorsHCAL, theStreamCache->streamNumMaxEvtLinkErrorsHCAL);
0680 lumiMonitoringInformation->lumiNumMaxEvtLinkErrors =
0681 std::max(lumiMonitoringInformation->lumiNumMaxEvtLinkErrors, theStreamCache->streamNumMaxEvtLinkErrors);
0682
0683 lumiMonitoringInformation->lumiNumMaxEvtMismatchECAL =
0684 std::max(lumiMonitoringInformation->lumiNumMaxEvtMismatchECAL, theStreamCache->streamNumMaxEvtMismatchECAL);
0685 lumiMonitoringInformation->lumiNumMaxEvtMismatchHCAL =
0686 std::max(lumiMonitoringInformation->lumiNumMaxEvtMismatchHCAL, theStreamCache->streamNumMaxEvtMismatchHCAL);
0687 lumiMonitoringInformation->lumiNumMaxEvtMismatch =
0688 std::max(lumiMonitoringInformation->lumiNumMaxEvtMismatch, theStreamCache->streamNumMaxEvtMismatch);
0689
0690
0691
0692 theStreamCache->streamNumMaxEvtLinkErrorsECAL = 0;
0693 theStreamCache->streamNumMaxEvtLinkErrorsHCAL = 0;
0694 theStreamCache->streamNumMaxEvtLinkErrors = 0;
0695
0696 theStreamCache->streamNumMaxEvtMismatchECAL = 0;
0697 theStreamCache->streamNumMaxEvtMismatchHCAL = 0;
0698 theStreamCache->streamNumMaxEvtMismatch = 0;
0699 }
0700
0701 void L1TStage2CaloLayer1::globalEndLuminosityBlockSummary(
0702 edm::LuminosityBlock const& theLumiBlock,
0703 edm::EventSetup const& theEventSetup,
0704 CaloL1Information::perLumiBlockMonitoringInformation* lumiMonitoringInformation) const {
0705 auto theRunCache = runCache(theLumiBlock.getRun().index());
0706
0707 theRunCache->maxEvtLinkErrorsByLumiECAL_->Fill(theLumiBlock.luminosityBlock(),
0708 lumiMonitoringInformation->lumiNumMaxEvtLinkErrorsECAL);
0709 theRunCache->maxEvtLinkErrorsByLumiHCAL_->Fill(theLumiBlock.luminosityBlock(),
0710 lumiMonitoringInformation->lumiNumMaxEvtLinkErrorsHCAL);
0711 theRunCache->maxEvtLinkErrorsByLumi_->Fill(theLumiBlock.luminosityBlock(),
0712 lumiMonitoringInformation->lumiNumMaxEvtLinkErrors);
0713
0714 theRunCache->maxEvtMismatchByLumiECAL_->Fill(theLumiBlock.luminosityBlock(),
0715 lumiMonitoringInformation->lumiNumMaxEvtMismatchECAL);
0716 theRunCache->maxEvtMismatchByLumiHCAL_->Fill(theLumiBlock.luminosityBlock(),
0717 lumiMonitoringInformation->lumiNumMaxEvtMismatchHCAL);
0718 theRunCache->maxEvtMismatchByLumi_->Fill(theLumiBlock.luminosityBlock(),
0719 lumiMonitoringInformation->lumiNumMaxEvtMismatch);
0720
0721
0722 theRunCache->ecalLinkErrorByLumi_->setBinContent(0, theLumiBlock.luminosityBlock());
0723 theRunCache->ecalMismatchByLumi_->setBinContent(0, theLumiBlock.luminosityBlock());
0724 theRunCache->hcalLinkErrorByLumi_->setBinContent(0, theLumiBlock.luminosityBlock());
0725 theRunCache->hcalMismatchByLumi_->setBinContent(0, theLumiBlock.luminosityBlock());
0726 theRunCache->maxEvtLinkErrorsByLumiECAL_->setBinContent(0, theLumiBlock.luminosityBlock());
0727 theRunCache->maxEvtLinkErrorsByLumiHCAL_->setBinContent(0, theLumiBlock.luminosityBlock());
0728 theRunCache->maxEvtLinkErrorsByLumi_->setBinContent(0, theLumiBlock.luminosityBlock());
0729 theRunCache->maxEvtMismatchByLumiECAL_->setBinContent(0, theLumiBlock.luminosityBlock());
0730 theRunCache->maxEvtMismatchByLumiHCAL_->setBinContent(0, theLumiBlock.luminosityBlock());
0731 theRunCache->maxEvtMismatchByLumi_->setBinContent(0, theLumiBlock.luminosityBlock());
0732 }
0733
0734
0735
0736
0737 bool L1TStage2CaloLayer1::isLaterMismatch(
0738 std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>>& candidateMismatch,
0739 std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>>& comparisonMismatch) const {
0740
0741 if (std::get<0>(candidateMismatch) < std::get<0>(comparisonMismatch))
0742 return false;
0743
0744 else if (std::get<0>(candidateMismatch) > std::get<0>(comparisonMismatch))
0745 return true;
0746
0747 else {
0748 if (std::get<1>(candidateMismatch) < std::get<1>(comparisonMismatch))
0749 return false;
0750 else if (std::get<1>(candidateMismatch) > std::get<1>(comparisonMismatch))
0751 return true;
0752
0753 else {
0754 if (std::get<2>(candidateMismatch) < std::get<2>(comparisonMismatch))
0755 return false;
0756 else
0757 return true;
0758 }
0759 }
0760
0761 return false;
0762 }
0763
0764
0765
0766
0767 int L1TStage2CaloLayer1::findIndex(
0768 std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>> candidateMismatch,
0769 std::vector<std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>>> comparisonList,
0770 int lowerIndexToSearch,
0771 int upperIndexToSearch) const {
0772
0773 int searchLocation = ((upperIndexToSearch + lowerIndexToSearch) / 2);
0774 auto searchIterator = comparisonList.begin() + searchLocation;
0775
0776
0777 if (this->isLaterMismatch(candidateMismatch, *searchIterator)) {
0778
0779 if (searchIterator + 1 != comparisonList.end()) {
0780
0781 if (not this->isLaterMismatch(candidateMismatch, *(searchIterator + 1))) {
0782 return searchLocation + 1;
0783 }
0784
0785 else {
0786 return this->findIndex(candidateMismatch, comparisonList, searchLocation + 1, upperIndexToSearch);
0787 }
0788 }
0789
0790 else {
0791 return searchLocation +
0792 1;
0793 }
0794 }
0795
0796 else {
0797
0798 if (searchIterator != comparisonList.begin()) {
0799
0800 if (not this->isLaterMismatch(candidateMismatch, *(searchIterator - 1))) {
0801 return this->findIndex(candidateMismatch, comparisonList, lowerIndexToSearch, searchLocation - 1);
0802 }
0803
0804 else {
0805 return searchLocation;
0806 }
0807 }
0808
0809 else {
0810
0811
0812
0813 if (comparisonList.size() < 20) {
0814 return searchLocation;
0815 }
0816
0817 else {
0818 return -1;
0819 }
0820 }
0821 }
0822
0823 return -1;
0824 }
0825
0826
0827 void L1TStage2CaloLayer1::mergeMismatchVectors(
0828 std::vector<std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>>>& candidateMismatchList,
0829 std::vector<std::tuple<edm::RunID, edm::LuminosityBlockID, edm::EventID, std::vector<int>>>& comparisonMismatchList)
0830 const {
0831
0832 for (auto candidateIterator = candidateMismatchList.begin(); candidateIterator != candidateMismatchList.end();
0833 ++candidateIterator) {
0834 int insertionIndex = this->findIndex(*candidateIterator, comparisonMismatchList, 0, comparisonMismatchList.size());
0835 if (insertionIndex < 0) {
0836 continue;
0837 }
0838 auto insertionIterator = comparisonMismatchList.begin() + insertionIndex;
0839 comparisonMismatchList.insert(insertionIterator, *candidateIterator);
0840
0841
0842
0843 if (comparisonMismatchList.size() > 20) {
0844 comparisonMismatchList.erase(comparisonMismatchList.begin());
0845 }
0846 }
0847 }
0848
0849 void L1TStage2CaloLayer1::streamEndRunSummary(
0850 edm::StreamID theStreamID,
0851 edm::Run const& theRun,
0852 edm::EventSetup const& theEventSetup,
0853 CaloL1Information::perRunSummaryMonitoringInformation* theRunSummaryMonitoringInformation) const {
0854 auto theStreamCache = streamCache(theStreamID);
0855
0856 if (theRunSummaryMonitoringInformation->runMismatchList.empty())
0857 theRunSummaryMonitoringInformation->runMismatchList = theStreamCache->streamMismatchList;
0858 else
0859 this->mergeMismatchVectors(theStreamCache->streamMismatchList, theRunSummaryMonitoringInformation->runMismatchList);
0860
0861
0862 theStreamCache->streamMismatchList.clear();
0863 }
0864
0865 void L1TStage2CaloLayer1::globalEndRunSummary(
0866 edm::Run const& theRun,
0867 edm::EventSetup const& theEventSetup,
0868 CaloL1Information::perRunSummaryMonitoringInformation* theRunSummaryInformation) const {
0869
0870 auto theRunCache = runCache(theRun.index());
0871
0872 int ibin = 1;
0873 for (auto mismatchIterator = theRunSummaryInformation->runMismatchList.begin();
0874 mismatchIterator != theRunSummaryInformation->runMismatchList.end();
0875 ++mismatchIterator) {
0876 std::string binLabel = std::to_string(std::get<0>(*mismatchIterator).run()) + ":" +
0877 std::to_string(std::get<1>(*mismatchIterator).luminosityBlock()) + ":" +
0878 std::to_string(std::get<2>(*mismatchIterator).event());
0879 theRunCache->last20Mismatches_->setBinLabel(ibin, binLabel, 2);
0880
0881
0882 std::vector<int> mismatchTypeVector = std::get<3>(*mismatchIterator);
0883 for (auto mismatchTypeIterator = mismatchTypeVector.begin(); mismatchTypeIterator != mismatchTypeVector.end();
0884 ++mismatchTypeIterator) {
0885 theRunCache->last20Mismatches_->setBinContent(*mismatchTypeIterator + 1, ibin, 1);
0886 }
0887 ++ibin;
0888 }
0889
0890 for (int emptyBinIndex = ibin; emptyBinIndex <= 20; ++emptyBinIndex) {
0891 theRunCache->last20Mismatches_->setBinLabel(emptyBinIndex, std::to_string(emptyBinIndex), 2);
0892 }
0893 }