Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 13:10:49

0001 /**
0002  * \class L1TEMTFEventInfoClient
0003  *
0004  *
0005  * Description: see header file.
0006  *
0007  *
0008  * \author: Vasile Mihai Ghete   - HEPHY Vienna
0009  *
0010  *
0011  */
0012 
0013 // this class header
0014 #include "DQM/L1TMonitorClient/interface/L1TEMTFEventInfoClient.h"
0015 
0016 // constructor
0017 L1TEMTFEventInfoClient::L1TEMTFEventInfoClient(const edm::ParameterSet& parSet)
0018     : m_verbose(parSet.getUntrackedParameter<bool>("verbose", false)),
0019       m_monitorDir(parSet.getUntrackedParameter<std::string>("monitorDir", "")),
0020       m_histDir(parSet.getUntrackedParameter<std::string>("histDir", "")),
0021       m_runInEventLoop(parSet.getUntrackedParameter<bool>("runInEventLoop", false)),
0022       m_runInEndLumi(parSet.getUntrackedParameter<bool>("runInEndLumi", false)),
0023       m_runInEndRun(parSet.getUntrackedParameter<bool>("runInEndRun", false)),
0024       m_runInEndJob(parSet.getUntrackedParameter<bool>("runInEndJob", false)),
0025       m_trackObjects(parSet.getParameter<std::vector<edm::ParameterSet> >("TrackObjects")),
0026       m_hitObjects(parSet.getParameter<std::vector<edm::ParameterSet> >("HitObjects")),
0027       m_disableTrackObjects(parSet.getParameter<std::vector<std::string> >("DisableTrackObjects")),
0028       m_disableHitObjects(parSet.getParameter<std::vector<std::string> >("DisableHitObjects")),
0029       m_noisyStrip(parSet.getParameter<std::vector<edm::ParameterSet> >("NoisyStrip")),
0030       m_deadStrip(parSet.getParameter<std::vector<edm::ParameterSet> >("DeadStrip")),
0031       m_disableNoisyStrip(parSet.getParameter<std::vector<std::string> >("DisableNoisyStrip")),
0032       m_disableDeadStrip(parSet.getParameter<std::vector<std::string> >("DisableDeadStrip")),
0033       m_nrTrackObjects(0),
0034       m_nrHitObjects(0),
0035       m_nrNoisyStrip(0),
0036       m_nrDeadStrip(0),
0037       m_totalNrQtSummaryEnabled(0) {
0038   initialize();
0039 }
0040 
0041 // destructor
0042 L1TEMTFEventInfoClient::~L1TEMTFEventInfoClient() {
0043   //empty
0044 }
0045 
0046 void L1TEMTFEventInfoClient::initialize() {
0047   if (m_verbose)
0048     std::cout << "\nMonitor directory =             " << m_monitorDir << std::endl;
0049 
0050   // L1 systems
0051 
0052   m_nrTrackObjects = m_trackObjects.size();
0053 
0054   m_trackLabel.reserve(m_nrTrackObjects);
0055   // m_trackLabelExt.reserve(m_nrTrackObjects);  // Not needed? - AWB 05.12.16
0056   m_trackDisable.reserve(m_nrTrackObjects);
0057 
0058   // on average five quality test per system - just a best guess
0059   m_trackQualityTestName.reserve(5 * m_nrTrackObjects);   // Not needed? - AWB 05.12.16
0060   m_trackQualityTestHist.reserve(5 * m_nrTrackObjects);   // Not needed? - AWB 05.12.16
0061   m_trackQtSummaryEnabled.reserve(5 * m_nrTrackObjects);  // Not needed? - AWB 05.12.16
0062 
0063   int indexSys = 0;
0064 
0065   int totalNrQualityTests = 0;
0066 
0067   for (const auto& itTrack : m_trackObjects) {
0068     m_trackLabel.push_back(itTrack.getParameter<std::string>("SystemLabel"));
0069 
0070     // m_trackLabelExt.push_back(itTrack.getParameter<std::string>(  // Not needed? - AWB 05.12.16
0071     //         "HwValLabel"));
0072 
0073     m_trackDisable.push_back(itTrack.getParameter<unsigned int>("SystemDisable"));
0074     // check the additional disable flag from m_disableTrackObjects
0075     for (const auto& itSys : m_disableTrackObjects) {
0076       if (itSys == m_trackLabel[indexSys]) {
0077         m_trackDisable[indexSys] = 1;
0078       }
0079     }
0080 
0081     std::vector<edm::ParameterSet> qTests = itTrack.getParameter<std::vector<edm::ParameterSet> >("QualityTests");
0082     size_t qtPerSystem = qTests.size();
0083 
0084     std::vector<std::string> qtNames;
0085     qtNames.reserve(qtPerSystem);
0086 
0087     std::vector<std::string> qtFullPathHists;
0088     qtFullPathHists.reserve(qtPerSystem);
0089 
0090     std::vector<unsigned int> qtSumEnabled;
0091     qtSumEnabled.reserve(qtPerSystem);
0092 
0093     if (m_verbose)
0094       std::cout << "\nLooping over track quality tests" << std::endl;
0095     for (const auto& itQT : qTests) {
0096       totalNrQualityTests++;
0097 
0098       qtNames.push_back(itQT.getParameter<std::string>("QualityTestName"));
0099 
0100       // qtFullPathHists.push_back( m_histDir + "/" + itQT.getParameter<std::string> ("QualityTestHist"));
0101       qtFullPathHists.push_back(itQT.getParameter<std::string>("QualityTestHist"));
0102       if (m_verbose)
0103         std::cout << qtFullPathHists.back() << std::endl;
0104 
0105       unsigned int qtEnabled = itQT.getParameter<unsigned int>("QualityTestSummaryEnabled");
0106 
0107       qtSumEnabled.push_back(qtEnabled);
0108 
0109       if (qtEnabled) {
0110         m_totalNrQtSummaryEnabled++;
0111       }
0112     }
0113 
0114     m_trackQualityTestName.push_back(qtNames);
0115     m_trackQualityTestHist.push_back(qtFullPathHists);
0116     m_trackQtSummaryEnabled.push_back(qtSumEnabled);
0117 
0118     indexSys++;
0119   }
0120 
0121   // L1 objects
0122 
0123   //
0124   m_nrHitObjects = m_hitObjects.size();
0125 
0126   m_hitLabel.reserve(m_nrHitObjects);
0127   m_hitDisable.reserve(m_nrHitObjects);
0128 
0129   // on average five quality test per object - just a best guess
0130   m_hitQualityTestName.reserve(5 * m_nrHitObjects);
0131   m_hitQualityTestHist.reserve(5 * m_nrHitObjects);
0132   m_hitQtSummaryEnabled.reserve(5 * m_nrHitObjects);
0133 
0134   int indexObj = 0;
0135 
0136   for (const auto& itObject : m_hitObjects) {
0137     m_hitLabel.push_back(itObject.getParameter<std::string>("HitLabel"));
0138 
0139     m_hitDisable.push_back(itObject.getParameter<unsigned int>("HitDisable"));
0140     // check the additional disable flag from m_disableHitObjects
0141     for (const auto& itObj : m_disableHitObjects) {
0142       if (itObj == m_hitLabel[indexObj]) {
0143         m_hitDisable[indexObj] = 1;
0144       }
0145     }
0146 
0147     std::vector<edm::ParameterSet> qTests = itObject.getParameter<std::vector<edm::ParameterSet> >("QualityTests");
0148     size_t qtPerObject = qTests.size();
0149 
0150     std::vector<std::string> qtNames;
0151     qtNames.reserve(qtPerObject);
0152 
0153     std::vector<std::string> qtFullPathHists;
0154     qtFullPathHists.reserve(qtPerObject);
0155 
0156     std::vector<unsigned int> qtSumEnabled;
0157     qtSumEnabled.reserve(qtPerObject);
0158 
0159     if (m_verbose)
0160       std::cout << "\nLooping over hit quality tests" << std::endl;
0161     for (const auto& itQT : qTests) {
0162       totalNrQualityTests++;
0163 
0164       qtNames.push_back(itQT.getParameter<std::string>("QualityTestName"));
0165 
0166       // qtFullPathHists.push_back( m_histDir + "/" + itQT.getParameter<std::string> ("QualityTestHist") );
0167       qtFullPathHists.push_back(itQT.getParameter<std::string>("QualityTestHist"));
0168       if (m_verbose)
0169         std::cout << qtFullPathHists.back() << std::endl;
0170 
0171       unsigned int qtEnabled = itQT.getParameter<unsigned int>("QualityTestSummaryEnabled");
0172 
0173       qtSumEnabled.push_back(qtEnabled);
0174 
0175       if (qtEnabled) {
0176         m_totalNrQtSummaryEnabled++;
0177       }
0178     }
0179 
0180     m_hitQualityTestName.push_back(qtNames);
0181     m_hitQualityTestHist.push_back(qtFullPathHists);
0182     m_hitQtSummaryEnabled.push_back(qtSumEnabled);
0183 
0184     indexObj++;
0185   }
0186 
0187   // L1 Strip Noisy=========================================================================================
0188 
0189   m_nrNoisyStrip = m_noisyStrip.size();
0190 
0191   m_noisyLabel.reserve(m_nrNoisyStrip);
0192   m_noisyDisable.reserve(m_nrNoisyStrip);
0193 
0194   // on average 20 quality tests per system
0195   m_noisyQualityTestName.reserve(20 * m_nrNoisyStrip);   // Not needed? - AWB 05.12.16
0196   m_noisyQualityTestHist.reserve(20 * m_nrNoisyStrip);   // Not needed? - AWB 05.12.16
0197   m_noisyQtSummaryEnabled.reserve(20 * m_nrNoisyStrip);  // Not needed? - AWB 05.12.16
0198 
0199   int indexNois = 0;
0200 
0201   for (const auto& itNoisy : m_noisyStrip) {
0202     m_noisyLabel.push_back(itNoisy.getParameter<std::string>("NoisyLabel"));
0203 
0204     m_noisyDisable.push_back(itNoisy.getParameter<unsigned int>("NoisyDisable"));
0205     // check the additional disable flag from m_disableNoisyObjects
0206     for (const auto& itNois : m_disableNoisyStrip) {
0207       if (itNois == m_noisyLabel[indexNois]) {
0208         m_noisyDisable[indexNois] = 1;
0209       }
0210     }
0211 
0212     std::vector<edm::ParameterSet> qTests = itNoisy.getParameter<std::vector<edm::ParameterSet> >("QualityTests");
0213     size_t qtPerNoisy = qTests.size();
0214 
0215     std::vector<std::string> qtNames;
0216     qtNames.reserve(qtPerNoisy);
0217 
0218     std::vector<std::string> qtFullPathHists;
0219     qtFullPathHists.reserve(qtPerNoisy);
0220 
0221     std::vector<unsigned int> qtSumEnabled;
0222     qtSumEnabled.reserve(qtPerNoisy);
0223 
0224     if (m_verbose)
0225       std::cout << "\nLooping over noisy quality tests" << std::endl;
0226     for (const auto& itQT : qTests) {
0227       totalNrQualityTests++;
0228 
0229       qtNames.push_back(itQT.getParameter<std::string>("QualityTestName"));
0230 
0231       qtFullPathHists.push_back(itQT.getParameter<std::string>("QualityTestHist"));
0232       if (m_verbose)
0233         std::cout << qtFullPathHists.back() << std::endl;
0234 
0235       unsigned int qtEnabled = itQT.getParameter<unsigned int>("QualityTestSummaryEnabled");
0236 
0237       qtSumEnabled.push_back(qtEnabled);
0238 
0239       if (qtEnabled) {
0240         m_totalNrQtSummaryEnabled++;
0241       }
0242     }
0243 
0244     m_noisyQualityTestName.push_back(qtNames);
0245     m_noisyQualityTestHist.push_back(qtFullPathHists);
0246     m_noisyQtSummaryEnabled.push_back(qtSumEnabled);
0247 
0248     indexNois++;
0249   }
0250 
0251   // L1 Strip Dead=========================================================================================
0252 
0253   m_nrDeadStrip = m_deadStrip.size();
0254 
0255   m_deadLabel.reserve(m_nrDeadStrip);
0256   m_deadDisable.reserve(m_nrDeadStrip);
0257 
0258   // on average 20 quality tests per system
0259   m_deadQualityTestName.reserve(20 * m_nrDeadStrip);   // Not needed? - AWB 05.12.16
0260   m_deadQualityTestHist.reserve(20 * m_nrDeadStrip);   // Not needed? - AWB 05.12.16
0261   m_deadQtSummaryEnabled.reserve(20 * m_nrDeadStrip);  // Not needed? - AWB 05.12.16
0262 
0263   int indexDed = 0;
0264 
0265   for (const auto& itDead : m_deadStrip) {
0266     m_deadLabel.push_back(itDead.getParameter<std::string>("DeadLabel"));
0267 
0268     m_deadDisable.push_back(itDead.getParameter<unsigned int>("DeadDisable"));
0269     // check the additional disable flag from m_disableDeadObjects
0270     for (const auto& itDed : m_disableDeadStrip) {
0271       if (itDed == m_deadLabel[indexDed]) {
0272         m_deadDisable[indexDed] = 1;
0273       }
0274     }
0275 
0276     std::vector<edm::ParameterSet> qTests = itDead.getParameter<std::vector<edm::ParameterSet> >("QualityTests");
0277     size_t qtPerDead = qTests.size();
0278 
0279     std::vector<std::string> qtNames;
0280     qtNames.reserve(qtPerDead);
0281 
0282     std::vector<std::string> qtFullPathHists;
0283     qtFullPathHists.reserve(qtPerDead);
0284 
0285     std::vector<unsigned int> qtSumEnabled;
0286     qtSumEnabled.reserve(qtPerDead);
0287 
0288     if (m_verbose)
0289       std::cout << "\nLooping over dead quality tests" << std::endl;
0290     for (const auto& itQT : qTests) {
0291       totalNrQualityTests++;
0292 
0293       qtNames.push_back(itQT.getParameter<std::string>("QualityTestName"));
0294 
0295       qtFullPathHists.push_back(itQT.getParameter<std::string>("QualityTestHist"));
0296       if (m_verbose)
0297         std::cout << qtFullPathHists.back() << std::endl;
0298 
0299       unsigned int qtEnabled = itQT.getParameter<unsigned int>("QualityTestSummaryEnabled");
0300 
0301       qtSumEnabled.push_back(qtEnabled);
0302 
0303       if (qtEnabled) {
0304         m_totalNrQtSummaryEnabled++;
0305       }
0306     }
0307 
0308     m_deadQualityTestName.push_back(qtNames);
0309     m_deadQualityTestHist.push_back(qtFullPathHists);
0310     m_deadQtSummaryEnabled.push_back(qtSumEnabled);
0311 
0312     indexDed++;
0313   }
0314 
0315   m_summaryContent.reserve(m_nrTrackObjects + m_nrHitObjects + m_nrNoisyStrip + m_nrDeadStrip);
0316   m_meReportSummaryContent.reserve(totalNrQualityTests);
0317 }
0318 
0319 void L1TEMTFEventInfoClient::dqmEndLuminosityBlock(DQMStore::IBooker& ibooker,
0320                                                    DQMStore::IGetter& igetter,
0321                                                    const edm::LuminosityBlock& lumiSeg,
0322                                                    const edm::EventSetup& evSetup) {
0323   if (m_verbose)
0324     std::cout << "\nInside void L1TEMTFEventInfoClient::dqmEndLuminosityBlock" << std::endl;
0325   if (m_runInEndLumi) {
0326     book(ibooker, igetter);
0327     readQtResults(ibooker, igetter);
0328 
0329     if (m_verbose) {
0330       std::cout << "\n  L1TEMTFEventInfoClient::endLuminosityBlock\n" << std::endl;
0331       dumpContentMonitorElements(ibooker, igetter);
0332     }
0333   }
0334 }
0335 
0336 void L1TEMTFEventInfoClient::dqmEndJob(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) {
0337   if (m_verbose)
0338     std::cout << "\nInside void L1TEMTFEventInfoClient::dqmEndJob" << std::endl;
0339   book(ibooker, igetter);
0340 
0341   readQtResults(ibooker, igetter);
0342 
0343   if (m_verbose) {
0344     std::cout << "\n  L1TEMTFEventInfoClient::endRun\n" << std::endl;
0345     dumpContentMonitorElements(ibooker, igetter);
0346   }
0347 }
0348 
0349 void L1TEMTFEventInfoClient::dumpContentMonitorElements(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) {
0350   if (m_verbose)
0351     std::cout << "\nSummary report " << std::endl;
0352 
0353   // summary content
0354 
0355   MonitorElement* me = igetter.get(m_meReportSummaryMap->getName());
0356 
0357   if (m_verbose)
0358     std::cout << "\nSummary content per system and object as filled in histogram\n  " << m_meReportSummaryMap->getName()
0359               << std::endl;
0360 
0361   if (!me) {
0362     if (m_verbose)
0363       std::cout << "\nNo histogram " << m_meReportSummaryMap->getName()
0364                 << "\nNo summary content per system and object as filled in histogram.\n  " << std::endl;
0365     return;
0366   }
0367 
0368   TH2F* hist = me->getTH2F();
0369 
0370   const int nBinsX = hist->GetNbinsX();
0371   const int nBinsY = hist->GetNbinsY();
0372   if (m_verbose)
0373     std::cout << nBinsX << " " << nBinsY;
0374 
0375   std::vector<std::vector<int> > meReportSummaryMap(nBinsX, std::vector<int>(nBinsY));
0376 
0377   //    for (int iBinX = 0; iBinX < nBinsX; iBinX++) {
0378   //        for (int iBinY = 0; iBinY < nBinsY; iBinY++) {
0379   //            meReportSummaryMap[iBinX][iBinY]
0380   //                    = static_cast<int>(me->GetBinContent(iBinX + 1, iBinY + 1));
0381   //        }
0382   //    }
0383 
0384   if (m_verbose)
0385     std::cout << "\nL1 systems: " << m_nrTrackObjects << " systems included\n"
0386               << "\n Summary content size: " << (m_summaryContent.size()) << std::endl;
0387 
0388   for (unsigned int iTrackObj = 0; iTrackObj < m_nrTrackObjects; ++iTrackObj) {
0389     if (m_verbose)
0390       std::cout << std::setw(10) << m_trackLabel[iTrackObj]
0391                 << std::setw(10)
0392                 // << m_trackLabelExt[iTrackObj] << " \t" << m_trackDisable[iTrackObj]
0393                 << m_trackDisable[iTrackObj] << " \t" << std::setw(25) << " m_summaryContent[" << std::setw(2)
0394                 << iTrackObj << "] = " << meReportSummaryMap[0][iTrackObj] << std::endl;
0395   }
0396 
0397   if (m_verbose)
0398     std::cout << "\n L1 trigger objects: " << m_nrHitObjects << " objects included\n" << std::endl;
0399 
0400   for (unsigned int iMon = m_nrTrackObjects; iMon < m_nrTrackObjects + m_nrHitObjects; ++iMon) {
0401     if (m_verbose)
0402       std::cout << std::setw(20) << m_hitLabel[iMon - m_nrTrackObjects] << " \t"
0403                 << m_hitDisable[iMon - m_nrTrackObjects] << " \t" << std::setw(25) << " m_summaryContent["
0404                 << std::setw(2) << iMon << "] = \t" << m_summaryContent[iMon] << std::endl;
0405   }
0406 
0407   if (m_verbose)
0408     std::cout << std::endl;
0409 
0410   // quality tests
0411 
0412   if (m_verbose)
0413     std::cout << "\nQuality test results as filled in "
0414               << "\n  " << m_monitorDir << "/EventInfo/reportSummaryContents\n"
0415               << "\n  Total number of quality tests: " << (m_meReportSummaryContent.size()) << "\n"
0416               << std::endl;
0417 
0418   for (const auto itME : m_meReportSummaryContent) {
0419     if (m_verbose)
0420       std::cout << std::setw(50) << itME->getName() << " \t" << std::setw(25) << itME->getFloatValue() << std::endl;
0421   }
0422 
0423   if (m_verbose)
0424     std::cout << std::endl;
0425 }
0426 
0427 void L1TEMTFEventInfoClient::book(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) {
0428   if (m_verbose)
0429     std::cout << "\nInside void L1TEMTFEventInfoClient::book" << std::endl;
0430   std::string dirEventInfo = m_monitorDir + "/EventInfo";
0431   if (m_verbose)
0432     std::cout << dirEventInfo << std::endl;
0433 
0434   ibooker.setCurrentFolder(dirEventInfo);
0435   if (m_verbose)
0436     std::cout << "Ran ibooker.setCurrentFolder(dirEventInfo;" << std::endl;
0437 
0438   // ...and book it again
0439   m_meReportSummary = ibooker.bookFloat("reportSummary");
0440   if (m_verbose)
0441     std::cout << "Ran m_meReportSummary = ibooker.bookFloat" << std::endl;
0442 
0443   // initialize reportSummary to 1
0444 
0445   if (m_meReportSummary) {
0446     if (m_verbose)
0447       std::cout << "Initializing reportSummary to 1" << std::endl;
0448     m_meReportSummary->Fill(1);
0449     if (m_verbose)
0450       std::cout << "Ran m_meReportSummary->Fill(1);" << std::endl;
0451   }
0452 
0453   // define float histograms for reportSummaryContents (one histogram per quality test),
0454   // initialize them to zero
0455   // initialize also m_summaryContent to dqm::qstatus::DISABLED
0456 
0457   ibooker.setCurrentFolder(dirEventInfo + "/reportSummaryContents");
0458   if (m_verbose)
0459     std::cout << "Ran ibooker.setCurrentFolder(dirEventInfo" << std::endl;
0460   // general counters:
0461   //   iAllQTest: all quality tests for all systems and objects
0462   //   iAllMon:   all monitored systems and objects
0463   int iAllQTest = 0;
0464   int iAllMon = 0;
0465 
0466   if (m_verbose)
0467     std::cout << "m_nrTrackObjects = " << m_nrTrackObjects << std::endl;
0468   for (unsigned int iMon = 0; iMon < m_nrTrackObjects; ++iMon) {
0469     if (m_verbose)
0470       std::cout << "  * iMon = " << iMon << std::endl;
0471 
0472     m_summaryContent.push_back(dqm::qstatus::DISABLED);
0473     if (m_verbose)
0474       std::cout << "Ran m_summaryContent.push_back(dqm::qstatus::DISABLED);" << std::endl;
0475 
0476     const std::vector<std::string>& trackObjQtName = m_trackQualityTestName[iMon];
0477     if (m_verbose)
0478       std::cout << "Ran const std::vector<std::string>& trackObjQtName = m_trackQualityTestName[iMon];" << std::endl;
0479 
0480     for (const auto& itQtName : trackObjQtName) {
0481       if (m_verbose)
0482         std::cout << "    - m_monitorDir = " << m_monitorDir << ", m_trackLabel[iMon] = " << m_trackLabel[iMon]
0483                   << ", (itQtName) = " << (itQtName) << std::endl;
0484 
0485       // Avoid error in ibooker.bookFloat(hStr))
0486       std::string m_mon_mod = m_monitorDir;
0487       std::replace(m_mon_mod.begin(), m_mon_mod.end(), '/', '_');
0488 
0489       const std::string hStr = m_mon_mod + "_L1Sys_" + m_trackLabel[iMon] + "_" + (itQtName);
0490       if (m_verbose)
0491         std::cout << "    - " << hStr << std::endl;
0492 
0493       m_meReportSummaryContent.push_back(ibooker.bookFloat(hStr));
0494       if (m_verbose)
0495         std::cout << "    - Ran m_meReportSummaryContent.push_back(ibooker.bookFloat(hStr));" << std::endl;
0496       m_meReportSummaryContent[iAllQTest]->Fill(0.);
0497       if (m_verbose)
0498         std::cout << "    - Ran m_meReportSummaryContent[iAllQTest]->Fill(0.);" << std::endl;
0499 
0500       iAllQTest++;
0501     }
0502 
0503     iAllMon++;
0504   }
0505 
0506   for (unsigned int iMon = 0; iMon < m_nrHitObjects; ++iMon) {
0507     if (m_verbose)
0508       std::cout << "  * iMon = " << iMon << std::endl;
0509 
0510     m_summaryContent.push_back(dqm::qstatus::DISABLED);
0511 
0512     const std::vector<std::string>& objQtName = m_hitQualityTestName[iMon];
0513 
0514     for (const auto& itQtName : objQtName) {
0515       // Avoid error in ibooker.bookFloat(hStr))
0516       std::string m_mon_mod = m_monitorDir;
0517       std::replace(m_mon_mod.begin(), m_mon_mod.end(), '/', '_');
0518 
0519       const std::string hStr = m_mon_mod + "_L1Obj_" + m_hitLabel[iMon] + "_" + (itQtName);
0520       if (m_verbose)
0521         std::cout << "    - " << hStr << std::endl;
0522 
0523       m_meReportSummaryContent.push_back(ibooker.bookFloat(hStr));
0524       if (m_verbose)
0525         std::cout << "    - Ran m_meReportSummaryContent.push_back(ibooker.bookFloat(hStr));" << std::endl;
0526       m_meReportSummaryContent[iAllQTest]->Fill(0.);
0527       if (m_verbose)
0528         std::cout << "    - Ran m_meReportSummaryContent[iAllQTest]->Fill(0.);" << std::endl;
0529 
0530       iAllQTest++;
0531     }
0532 
0533     iAllMon++;
0534   }
0535 
0536   // for Noisy Strips ====================================================================
0537   for (unsigned int iMon = 0; iMon < m_nrNoisyStrip; ++iMon) {
0538     m_summaryContent.push_back(dqm::qstatus::DISABLED);
0539 
0540     const std::vector<std::string>& objQtName = m_noisyQualityTestName[iMon];
0541 
0542     for (const auto& itQtName : objQtName) {
0543       // Avoid error in ibooker.bookFloat(hStr))
0544       std::string m_mon_mod = m_monitorDir;
0545       std::replace(m_mon_mod.begin(), m_mon_mod.end(), '/', '_');
0546 
0547       const std::string hStr = m_mon_mod + "_L1Obj_" + m_noisyLabel[iMon] + "_" + (itQtName);
0548       if (m_verbose)
0549         std::cout << "    - " << hStr << std::endl;
0550 
0551       m_meReportSummaryContent.push_back(ibooker.bookFloat(hStr));
0552       m_meReportSummaryContent[iAllQTest]->Fill(0.);
0553 
0554       iAllQTest++;
0555     }
0556     iAllMon++;
0557   }
0558   // for Dead Strips ====================================================================
0559   for (unsigned int iMon = 0; iMon < m_nrDeadStrip; ++iMon) {
0560     m_summaryContent.push_back(dqm::qstatus::DISABLED);
0561 
0562     const std::vector<std::string>& objQtName = m_deadQualityTestName[iMon];
0563 
0564     for (const auto& itQtName : objQtName) {
0565       // Avoid error in ibooker.bookFloat(hStr))
0566       std::string m_mon_mod = m_monitorDir;
0567       std::replace(m_mon_mod.begin(), m_mon_mod.end(), '/', '_');
0568 
0569       const std::string hStr = m_mon_mod + "_L1Obj_" + m_deadLabel[iMon] + "_" + (itQtName);
0570       if (m_verbose)
0571         std::cout << "    - " << hStr << std::endl;
0572 
0573       m_meReportSummaryContent.push_back(ibooker.bookFloat(hStr));
0574       m_meReportSummaryContent[iAllQTest]->Fill(0.);
0575 
0576       iAllQTest++;
0577     }
0578     iAllMon++;
0579   }
0580 
0581   if (m_verbose)
0582     std::cout << "Setting current folder to " << dirEventInfo << std::endl;
0583   ibooker.setCurrentFolder(dirEventInfo);
0584   if (m_verbose)
0585     std::cout << "Ran ibooker.setCurrentFolder(dirEventInfo);" << std::endl;
0586 
0587   // define a histogram with two bins on X and maximum of m_nrTrackObjects, m_nrHitObjects on Y
0588   int nBinsY = std::max(m_nrTrackObjects, m_nrHitObjects);
0589   int nBinsYStrip = std::max(m_nrNoisyStrip, m_nrDeadStrip);
0590 
0591   m_meReportSummaryMap =
0592       ibooker.book2D("reportSummaryMap_EMTF", "reportSummaryMap_EMTF", 2, 1, 3, nBinsY, 1, nBinsY + 1);
0593   m_meReportSummaryMap_chamberStrip = ibooker.book2D(
0594       "reportSummaryMap_chamberStrip", "reportSummaryMap_chamberStrip", 2, 1, 3, nBinsYStrip, 1, nBinsYStrip + 1);
0595 
0596   if (m_monitorDir == "L1TEMU") {
0597     m_meReportSummaryMap->setTitle("L1TEMU: L1 Emulator vs Data Report Summary Map");
0598 
0599   } else if (m_monitorDir == "L1T") {
0600     m_meReportSummaryMap->setTitle("L1T: L1 Trigger Data Report Summary Map");
0601   } else if (m_monitorDir == "L1T2016") {
0602     m_meReportSummaryMap->setTitle("L1T2016: L1 Trigger Data Report Summary Map");
0603   } else {
0604     // do nothing
0605   }
0606 
0607   m_meReportSummaryMap->setAxisTitle(" ", 1);
0608   m_meReportSummaryMap->setAxisTitle(" ", 2);
0609 
0610   m_meReportSummaryMap->setBinLabel(1, "Noisy Check", 1);
0611   m_meReportSummaryMap->setBinLabel(2, "Dead Check", 1);
0612 
0613   m_meReportSummaryMap_chamberStrip->setBinLabel(1, "Noisy Check", 1);
0614   m_meReportSummaryMap_chamberStrip->setBinLabel(2, "Dead Check", 1);
0615 
0616   //    for (int iBin = 0; iBin < nBinsY; ++iBin) {
0617   //        m_meReportSummaryMap->setBinLabel(iBin + 1, " ", 2);   }
0618 
0619   m_meReportSummaryMap->setBinLabel(1, "Hit BX", 2);
0620   m_meReportSummaryMap->setBinLabel(2, "Track BX", 2);
0621   //m_meReportSummaryMap->setBinLabel(3, "Track Phi", 2);
0622 
0623   const std::vector<std::string> suffix_name = {"-4/2", "-4/1",  "-3/2",  "-3/1",  "-2/2",  "-2/1", "-1/3",
0624                                                 "-1/2", "-1/1b", "-1/1a", "+1/1a", "+1/1b", "+1/2", "+1/3",
0625                                                 "+2/1", "+2/2",  "+3/1",  "+3/2",  "+4/1",  "+4/2"};
0626   for (int iBin = 0; iBin < nBinsYStrip; ++iBin) {
0627     m_meReportSummaryMap_chamberStrip->setBinLabel(iBin + 1, "ChamberStrip " + suffix_name[iBin], 2);
0628   }
0629 }
0630 
0631 void L1TEMTFEventInfoClient::readQtResults(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) {
0632   // initialize summary content, summary sum and ReportSummaryContent float histograms
0633   // for all L1 systems and L1 objects
0634 
0635   if (m_verbose)
0636     std::cout << "\nInside L1TEMTFEventInfoClient::readQtResults" << std::endl;  // Extra printout - AWB 03.12.16
0637 
0638   for (std::vector<int>::iterator it = m_summaryContent.begin(); it != m_summaryContent.end(); ++it) {
0639     (*it) = dqm::qstatus::DISABLED;
0640   }
0641 
0642   m_summarySum = 0.;
0643 
0644   for (const auto& itME : m_meReportSummaryContent) {
0645     itME->Fill(0.);
0646   }
0647 
0648   // general counters:
0649   //   iAllQTest: all quality tests for all systems and objects
0650   //   iAllMon:   all monitored systems and objects
0651   int iAllQTest = 0;
0652   int iAllMon = 0;
0653 
0654   // quality tests for all L1 systems
0655 
0656   for (unsigned int iTrackObj = 0; iTrackObj < m_nrTrackObjects; ++iTrackObj) {
0657     // get the reports for each quality test
0658 
0659     const std::vector<std::string>& trackObjQtName = m_trackQualityTestName[iTrackObj];
0660     const std::vector<std::string>& trackObjQtHist = m_trackQualityTestHist[iTrackObj];
0661     const std::vector<unsigned int>& trackObjQtSummaryEnabled = m_trackQtSummaryEnabled[iTrackObj];
0662 
0663     // pro system counter for quality tests
0664     int iTrackObjQTest = 0;
0665 
0666     for (const auto& itQtName : trackObjQtName) {
0667       // get results, status and message
0668 
0669       if (m_verbose)
0670         std::cout << "  itQtName = " << (itQtName) << std::endl;  // Extra printout - AWB 03.12.16
0671 
0672       MonitorElement* qHist = igetter.get(trackObjQtHist[iTrackObjQTest]);
0673 
0674       if (qHist) {
0675         const std::vector<QReport*> qtVec = qHist->getQReports();
0676 
0677         // if (m_verbose) {
0678         if (true) {  // Force printout - AWB 03.12.16
0679 
0680           if (m_verbose)
0681             std::cout << "  - Number of quality tests"
0682                       // if (m_verbose) std::cout << "\nNumber of quality tests"
0683                       << " for histogram " << trackObjQtHist[iTrackObjQTest] << ": " << qtVec.size() << "\n"
0684                       << std::endl;
0685         }
0686 
0687         const QReport* sysQReport = qHist->getQReport(itQtName);
0688         if (sysQReport) {
0689           const float trackObjQtResult = sysQReport->getQTresult();
0690           const int trackObjQtStatus = sysQReport->getStatus();
0691           const std::string& trackObjQtMessage = sysQReport->getMessage();
0692 
0693           if (m_verbose) {
0694             std::cout << "\n"
0695                       << (itQtName) << " quality test:"
0696                       << "\n  result:  " << trackObjQtResult << "\n  status:  " << trackObjQtStatus
0697                       << "\n  message: " << trackObjQtMessage << "\n"
0698                       << "\nFilling m_meReportSummaryContent[" << iAllQTest << "] with value " << trackObjQtResult
0699                       << "\n"
0700                       << std::endl;
0701           }
0702 
0703           m_meReportSummaryContent[iAllQTest]->Fill(trackObjQtResult);
0704 
0705           // for the summary map, keep the highest status value ("ERROR") of all tests
0706           // which are considered for the summary plot
0707           if (trackObjQtSummaryEnabled[iTrackObjQTest]) {
0708             if (trackObjQtStatus > m_summaryContent[iAllMon]) {
0709               m_summaryContent[iAllMon] = trackObjQtStatus;
0710             }
0711 
0712             m_summarySum += trackObjQtResult;
0713           }
0714 
0715         } else {
0716           // for the summary map, if the test was not found but it is assumed to be
0717           // considered for the summary plot, set it to dqm::qstatus::INVALID
0718 
0719           int trackObjQtStatus = dqm::qstatus::INVALID;
0720 
0721           if (trackObjQtSummaryEnabled[iTrackObjQTest]) {
0722             if (trackObjQtStatus > m_summaryContent[iAllMon]) {
0723               m_summaryContent[iAllMon] = trackObjQtStatus;
0724             }
0725           }
0726 
0727           m_meReportSummaryContent[iAllQTest]->Fill(0.);
0728 
0729           if (m_verbose)
0730             std::cout << "\n" << (itQtName) << " quality test not found\n" << std::endl;
0731         }
0732 
0733       } else {
0734         // for the summary map, if the histogram was not found but it is assumed
0735         // to have a test be considered for the summary plot, set it to dqm::qstatus::INVALID
0736 
0737         int trackObjQtStatus = dqm::qstatus::INVALID;
0738 
0739         if (trackObjQtSummaryEnabled[iTrackObjQTest]) {
0740           if (trackObjQtStatus > m_summaryContent[iAllMon]) {
0741             m_summaryContent[iAllMon] = trackObjQtStatus;
0742           }
0743         }
0744 
0745         m_meReportSummaryContent[iAllQTest]->Fill(0.);
0746 
0747         if (m_verbose)
0748           std::cout << "\nHistogram " << trackObjQtHist[iTrackObjQTest] << " not found\n" << std::endl;
0749       }
0750 
0751       // increase counters for quality tests
0752       iTrackObjQTest++;
0753       iAllQTest++;
0754     }
0755 
0756     iAllMon++;
0757   }
0758 
0759   // quality tests for all L1 objects
0760 
0761   for (unsigned int iHitObj = 0; iHitObj < m_nrHitObjects; ++iHitObj) {
0762     // get the reports for each quality test
0763 
0764     const std::vector<std::string>& hitObjQtName = m_hitQualityTestName[iHitObj];
0765     const std::vector<std::string>& hitObjQtHist = m_hitQualityTestHist[iHitObj];
0766     const std::vector<unsigned int>& hitObjQtSummaryEnabled = m_hitQtSummaryEnabled[iHitObj];
0767 
0768     // pro object counter for quality tests
0769     int iHitObjQTest = 0;
0770 
0771     for (const auto& itQtName : hitObjQtName) {
0772       // get results, status and message
0773 
0774       MonitorElement* qHist = igetter.get(hitObjQtHist[iHitObjQTest]);
0775 
0776       if (qHist) {
0777         const std::vector<QReport*> qtVec = qHist->getQReports();
0778 
0779         if (m_verbose)
0780           std::cout << "\nNumber of quality tests "
0781                     << " for histogram " << hitObjQtHist[iHitObjQTest] << ": " << qtVec.size() << "\n"
0782                     << std::endl;
0783 
0784         const QReport* objQReport = qHist->getQReport(itQtName);
0785         if (objQReport) {
0786           const float hitObjQtResult = objQReport->getQTresult();
0787           const int hitObjQtStatus = objQReport->getStatus();
0788           const std::string& hitObjQtMessage = objQReport->getMessage();
0789 
0790           if (m_verbose) {
0791             std::cout << "\n"
0792                       << (itQtName) << " quality test:"
0793                       << "\n  result:  " << hitObjQtResult << "\n  status:  " << hitObjQtStatus
0794                       << "\n  message: " << hitObjQtMessage << "\n"
0795                       << "\nFilling m_meReportSummaryContent[" << iAllQTest << "] with value " << hitObjQtResult << "\n"
0796                       << std::endl;
0797           }
0798 
0799           m_meReportSummaryContent[iAllQTest]->Fill(hitObjQtResult);
0800 
0801           // for the summary map, keep the highest status value ("ERROR") of all tests
0802           // which are considered for the summary plot
0803           if (hitObjQtSummaryEnabled[iHitObjQTest]) {
0804             if (hitObjQtStatus > m_summaryContent[iAllMon]) {
0805               m_summaryContent[iAllMon] = hitObjQtStatus;
0806             }
0807 
0808             m_summarySum += hitObjQtResult;
0809           }
0810 
0811         } else {
0812           // for the summary map, if the test was not found but it is assumed to be
0813           // considered for the summary plot, set it to dqm::qstatus::INVALID
0814 
0815           int hitObjQtStatus = dqm::qstatus::INVALID;
0816 
0817           if (hitObjQtSummaryEnabled[iHitObjQTest]) {
0818             if (hitObjQtStatus > m_summaryContent[iAllMon]) {
0819               m_summaryContent[iAllMon] = hitObjQtStatus;
0820             }
0821           }
0822 
0823           m_meReportSummaryContent[iAllQTest]->Fill(0.);
0824 
0825           if (m_verbose)
0826             std::cout << "\n" << (itQtName) << " quality test not found\n" << std::endl;
0827         }
0828 
0829       } else {
0830         // for the summary map, if the histogram was not found but it is assumed
0831         // to have a test be considered for the summary plot, set it to dqm::qstatus::INVALID
0832 
0833         int hitObjQtStatus = dqm::qstatus::INVALID;
0834 
0835         if (hitObjQtSummaryEnabled[iHitObjQTest]) {
0836           if (hitObjQtStatus > m_summaryContent[iAllMon]) {
0837             m_summaryContent[iAllMon] = hitObjQtStatus;
0838           }
0839         }
0840 
0841         m_meReportSummaryContent[iAllQTest]->Fill(0.);
0842 
0843         if (m_verbose)
0844           std::cout << "\nHistogram " << hitObjQtHist[iHitObjQTest] << " not found\n" << std::endl;
0845       }
0846       // increase counters for quality tests
0847       iHitObjQTest++;
0848       iAllQTest++;
0849     }
0850     iAllMon++;
0851   }
0852 
0853   // quality tests for all L1 Noisy Strip =================================================================
0854 
0855   for (unsigned int iNoisyStrp = 0; iNoisyStrp < m_nrNoisyStrip; ++iNoisyStrp) {
0856     // get the reports for each quality test
0857     const std::vector<std::string>& noisyStrpQtName = m_noisyQualityTestName[iNoisyStrp];
0858     const std::vector<std::string>& noisyStrpQtHist = m_noisyQualityTestHist[iNoisyStrp];
0859     const std::vector<unsigned int>& noisyStrpQtSummaryEnabled = m_noisyQtSummaryEnabled[iNoisyStrp];
0860 
0861     // pro object counter for quality tests
0862     int iNoisyStrpQTest = 0;
0863 
0864     for (const auto& itQtName : noisyStrpQtName) {
0865       // get results, status and message
0866       MonitorElement* qHist = igetter.get(noisyStrpQtHist[iNoisyStrpQTest]);
0867 
0868       if (qHist) {
0869         const std::vector<QReport*> qtVec = qHist->getQReports();
0870 
0871         if (m_verbose)
0872           std::cout << "\nNumber of quality tests "
0873                     << " for histogram " << noisyStrpQtHist[iNoisyStrpQTest] << ": " << qtVec.size() << "\n"
0874                     << std::endl;
0875 
0876         const QReport* objQReport = qHist->getQReport(itQtName);
0877         if (objQReport) {
0878           const float noisyStrpQtResult = objQReport->getQTresult();
0879           const int noisyStrpQtStatus = objQReport->getStatus();
0880           const std::string& noisyStrpQtMessage = objQReport->getMessage();
0881 
0882           if (m_verbose) {
0883             std::cout << "\n"
0884                       << (itQtName) << " quality test:"
0885                       << "\n  result:  " << noisyStrpQtResult << "\n  status:  " << noisyStrpQtStatus
0886                       << "\n  message: " << noisyStrpQtMessage << "\n"
0887                       << "\nFilling m_meReportSummaryContent[" << iAllQTest << "] with value " << noisyStrpQtResult
0888                       << "\n"
0889                       << std::endl;
0890           }
0891 
0892           m_meReportSummaryContent[iAllQTest]->Fill(noisyStrpQtResult);
0893 
0894           // for the summary map, keep the highest status value ("ERROR") of all tests
0895           // which are considered for the summary plot
0896           if (noisyStrpQtSummaryEnabled[iNoisyStrpQTest]) {
0897             if (noisyStrpQtStatus > m_summaryContent[iAllMon]) {
0898               m_summaryContent[iAllMon] = noisyStrpQtStatus;
0899             }
0900             m_summarySum += noisyStrpQtResult;
0901           }
0902 
0903         } else {
0904           // for the summary map, if the test was not found but it is assumed to be
0905           // considered for the summary plot, set it to dqm::qstatus::INVALID
0906 
0907           int noisyStrpQtStatus = dqm::qstatus::INVALID;
0908 
0909           if (noisyStrpQtSummaryEnabled[iNoisyStrpQTest]) {
0910             if (noisyStrpQtStatus > m_summaryContent[iAllMon]) {
0911               m_summaryContent[iAllMon] = noisyStrpQtStatus;
0912             }
0913           }
0914 
0915           m_meReportSummaryContent[iAllQTest]->Fill(0.);
0916 
0917           if (m_verbose)
0918             std::cout << "\n" << (itQtName) << " quality test not found\n" << std::endl;
0919         }
0920 
0921       } else {
0922         // for the summary map, if the histogram was not found but it is assumed
0923         // to have a test be considered for the summary plot, set it to dqm::qstatus::INVALID
0924 
0925         int noisyStrpQtStatus = dqm::qstatus::INVALID;
0926 
0927         if (noisyStrpQtSummaryEnabled[iNoisyStrpQTest]) {
0928           if (noisyStrpQtStatus > m_summaryContent[iAllMon]) {
0929             m_summaryContent[iAllMon] = noisyStrpQtStatus;
0930           }
0931         }
0932 
0933         m_meReportSummaryContent[iAllQTest]->Fill(0.);
0934 
0935         if (m_verbose)
0936           std::cout << "\nHistogram " << noisyStrpQtHist[iNoisyStrpQTest] << " not found\n" << std::endl;
0937       }
0938       // increase counters for quality tests
0939       iNoisyStrpQTest++;
0940       iAllQTest++;
0941     }
0942     iAllMon++;
0943   }
0944   // quality tests for all L1 Dead Strip =================================================================
0945 
0946   for (unsigned int iDeadStrp = 0; iDeadStrp < m_nrDeadStrip; ++iDeadStrp) {
0947     // get the reports for each quality test
0948     const std::vector<std::string>& deadStrpQtName = m_deadQualityTestName[iDeadStrp];
0949     const std::vector<std::string>& deadStrpQtHist = m_deadQualityTestHist[iDeadStrp];
0950     const std::vector<unsigned int>& deadStrpQtSummaryEnabled = m_deadQtSummaryEnabled[iDeadStrp];
0951 
0952     // pro object counter for quality tests
0953     int iDeadStrpQTest = 0;
0954 
0955     for (const auto& itQtName : deadStrpQtName) {
0956       // get results, status and message
0957 
0958       MonitorElement* qHist = igetter.get(deadStrpQtHist[iDeadStrpQTest]);
0959 
0960       if (qHist) {
0961         const std::vector<QReport*> qtVec = qHist->getQReports();
0962 
0963         if (m_verbose)
0964           std::cout << "\nNumber of quality tests "
0965                     << " for histogram " << deadStrpQtHist[iDeadStrpQTest] << ": " << qtVec.size() << "\n"
0966                     << std::endl;
0967 
0968         const QReport* objQReport = qHist->getQReport(itQtName);
0969         if (objQReport) {
0970           const float deadStrpQtResult = objQReport->getQTresult();
0971           const int deadStrpQtStatus = objQReport->getStatus();
0972           const std::string& deadStrpQtMessage = objQReport->getMessage();
0973 
0974           if (m_verbose) {
0975             std::cout << "\n"
0976                       << (itQtName) << " quality test:"
0977                       << "\n  result:  " << deadStrpQtResult << "\n  status:  " << deadStrpQtStatus
0978                       << "\n  message: " << deadStrpQtMessage << "\n"
0979                       << "\nFilling m_meReportSummaryContent[" << iAllQTest << "] with value " << deadStrpQtResult
0980                       << "\n"
0981                       << std::endl;
0982           }
0983 
0984           m_meReportSummaryContent[iAllQTest]->Fill(deadStrpQtResult);
0985 
0986           // for the summary map, keep the highest status value ("ERROR") of all tests
0987           // which are considered for the summary plot
0988           if (deadStrpQtSummaryEnabled[iDeadStrpQTest]) {
0989             if (deadStrpQtStatus > m_summaryContent[iAllMon]) {
0990               m_summaryContent[iAllMon] = deadStrpQtStatus;
0991             }
0992             m_summarySum += deadStrpQtResult;
0993           }
0994 
0995         } else {
0996           // for the summary map, if the test was not found but it is assumed to be
0997           // considered for the summary plot, set it to dqm::qstatus::INVALID
0998 
0999           int deadStrpQtStatus = dqm::qstatus::INVALID;
1000 
1001           if (deadStrpQtSummaryEnabled[iDeadStrpQTest]) {
1002             if (deadStrpQtStatus > m_summaryContent[iAllMon]) {
1003               m_summaryContent[iAllMon] = deadStrpQtStatus;
1004             }
1005           }
1006 
1007           m_meReportSummaryContent[iAllQTest]->Fill(0.);
1008 
1009           if (m_verbose)
1010             std::cout << "\n" << (itQtName) << " quality test not found\n" << std::endl;
1011         }
1012 
1013       } else {
1014         // for the summary map, if the histogram was not found but it is assumed
1015         // to have a test be considered for the summary plot, set it to dqm::qstatus::INVALID
1016 
1017         int deadStrpQtStatus = dqm::qstatus::INVALID;
1018 
1019         if (deadStrpQtSummaryEnabled[iDeadStrpQTest]) {
1020           if (deadStrpQtStatus > m_summaryContent[iAllMon]) {
1021             m_summaryContent[iAllMon] = deadStrpQtStatus;
1022           }
1023         }
1024 
1025         m_meReportSummaryContent[iAllQTest]->Fill(0.);
1026 
1027         if (m_verbose)
1028           std::cout << "\nHistogram " << deadStrpQtHist[iDeadStrpQTest] << " not found\n" << std::endl;
1029       }
1030 
1031       // increase counters for quality tests
1032       iDeadStrpQTest++;
1033       iAllQTest++;
1034     }
1035     iAllMon++;
1036   }
1037 
1038   // reportSummary value
1039   m_reportSummary = m_summarySum / float(m_totalNrQtSummaryEnabled);
1040   if (m_meReportSummary) {
1041     m_meReportSummary->Fill(m_reportSummary);
1042   }
1043 
1044   // fill the ReportSummaryMap for L1 systems (bin 1 on X)
1045   for (unsigned int iTrackObj = 0; iTrackObj < m_nrTrackObjects; ++iTrackObj) {
1046     double summCont = static_cast<double>(m_summaryContent[iTrackObj]);
1047     m_meReportSummaryMap->setBinContent(1, iTrackObj + 1, summCont);
1048   }
1049   // fill the ReportSummaryMap for L1 objects (bin 2 on X)
1050   for (unsigned int iMon = m_nrTrackObjects; iMon < m_nrTrackObjects + m_nrHitObjects; ++iMon) {
1051     double summCont = static_cast<double>(m_summaryContent[iMon]);
1052     m_meReportSummaryMap->setBinContent(2, iMon - m_nrTrackObjects + 1, summCont);
1053   }
1054 
1055   // fill the ReportSummaryMap_chamberStrip for L1 Noisy Strip (bin 1 on X)
1056   for (unsigned int iNoisyStrp = m_nrTrackObjects + m_nrHitObjects;
1057        iNoisyStrp < m_nrTrackObjects + m_nrHitObjects + m_nrNoisyStrip;
1058        ++iNoisyStrp) {
1059     double summCont = static_cast<double>(m_summaryContent[iNoisyStrp]);
1060     m_meReportSummaryMap_chamberStrip->setBinContent(1, iNoisyStrp - m_nrTrackObjects - m_nrHitObjects + 1, summCont);
1061   }
1062   // fill the ReportSummaryMap_chamberStrip for L1 objects (bin 2 on X)
1063   for (unsigned int iDeadStrp = m_nrTrackObjects + m_nrHitObjects + m_nrNoisyStrip;
1064        iDeadStrp < m_nrTrackObjects + m_nrHitObjects + m_nrNoisyStrip + m_nrDeadStrip;
1065        ++iDeadStrp) {
1066     double summCont = static_cast<double>(m_summaryContent[iDeadStrp]);
1067     m_meReportSummaryMap_chamberStrip->setBinContent(
1068         2, iDeadStrp - m_nrTrackObjects - m_nrHitObjects - m_nrNoisyStrip + 1, summCont);
1069   }
1070 }