CMS 3D CMS Logo

/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/DQM/L1TMonitorClient/src/L1TEventInfoClient.cc

Go to the documentation of this file.
00001 
00015 // this class header
00016 #include "DQM/L1TMonitorClient/interface/L1TEventInfoClient.h"
00017 
00018 // system include files
00019 #include <stdio.h>
00020 #include <sstream>
00021 #include <fstream>
00022 #include <iostream>
00023 #include <iomanip>
00024 
00025 #include <math.h>
00026 #include <memory>
00027 
00028 #include <vector>
00029 #include <string>
00030 
00031 // user include files
00032 #include "FWCore/ServiceRegistry/interface/Service.h"
00033 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00034 #include "FWCore/Framework/interface/EventSetup.h"
00035 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00036 #include "FWCore/Utilities/interface/Exception.h"
00037 
00038 #include "DQMServices/Core/interface/QReport.h"
00039 #include "DQMServices/Core/interface/DQMStore.h"
00040 # include "DQMServices/Core/interface/DQMDefinitions.h"
00041 
00042 #include <TH2F.h>
00043 #include "TROOT.h"
00044 
00045 // constructor
00046 L1TEventInfoClient::L1TEventInfoClient(const edm::ParameterSet& parSet) :
00047             m_verbose(parSet.getUntrackedParameter<bool>("verbose", false)),
00048             m_monitorDir(parSet.getUntrackedParameter<std::string>("monitorDir", "")),
00049             m_runInEventLoop(parSet.getUntrackedParameter<bool>("runInEventLoop", false)),
00050             m_runInEndLumi(parSet.getUntrackedParameter<bool>("runInEndLumi", false)),
00051             m_runInEndRun(parSet.getUntrackedParameter<bool>("runInEndRun", false)),
00052             m_runInEndJob(parSet.getUntrackedParameter<bool>("runInEndJob", false)),
00053             m_l1Systems(parSet.getParameter<std::vector<edm::ParameterSet> >("L1Systems")),
00054             m_l1Objects(parSet.getParameter<std::vector<edm::ParameterSet> >("L1Objects")),
00055             m_disableL1Systems(parSet.getParameter<std::vector<std::string> >("DisableL1Systems")),
00056             m_disableL1Objects(parSet.getParameter<std::vector<std::string> >("DisableL1Objects")),
00057             m_nrL1Systems(0),
00058             m_nrL1Objects(0),
00059             m_totalNrQtSummaryEnabled(0) {
00060 
00061     initialize();
00062 }
00063 
00064 // destructor
00065 L1TEventInfoClient::~L1TEventInfoClient() {
00066 
00067     //empty
00068 
00069 }
00070 
00071 void L1TEventInfoClient::initialize() {
00072 
00073     // get back-end interface
00074     m_dbe = edm::Service<DQMStore>().operator->();
00075 
00076     if (m_verbose) {
00077         std::cout << "\nMonitor directory =             " << m_monitorDir
00078                 << std::endl;
00079     }
00080 
00081     // L1 systems
00082 
00083     m_nrL1Systems = m_l1Systems.size();
00084 
00085     m_systemLabel.reserve(m_nrL1Systems);
00086     m_systemLabelExt.reserve(m_nrL1Systems);
00087     m_systemDisable.reserve(m_nrL1Systems);
00088 
00089     // on average five quality test per system - just a best guess
00090     m_systemQualityTestName.reserve(5*m_nrL1Systems);
00091     m_systemQualityTestHist.reserve(5*m_nrL1Systems);
00092     m_systemQtSummaryEnabled.reserve(5*m_nrL1Systems);
00093 
00094     int indexSys = 0;
00095 
00096     int totalNrQualityTests = 0;
00097 
00098     for (std::vector<edm::ParameterSet>::const_iterator itSystem =
00099             m_l1Systems.begin(); itSystem != m_l1Systems.end(); ++itSystem) {
00100 
00101         m_systemLabel.push_back(itSystem->getParameter<std::string>(
00102                 "SystemLabel"));
00103 
00104         m_systemLabelExt.push_back(itSystem->getParameter<std::string>(
00105                 "HwValLabel"));
00106 
00107         m_systemDisable.push_back(itSystem->getParameter<unsigned int>(
00108                 "SystemDisable"));
00109         // check the additional disable flag from m_disableL1Systems
00110         for (std::vector<std::string>::const_iterator itSys =
00111                 m_disableL1Systems.begin(); itSys != m_disableL1Systems.end(); ++itSys) {
00112 
00113             if (*itSys == m_systemLabel[indexSys]) {
00114                 m_systemDisable[indexSys] = 1;
00115 
00116             }
00117         }
00118 
00119         std::vector < edm::ParameterSet > qTests = itSystem->getParameter<
00120                 std::vector<edm::ParameterSet> > ("QualityTests");
00121         size_t qtPerSystem = qTests.size();
00122 
00123         std::vector < std::string > qtNames;
00124         qtNames.reserve(qtPerSystem);
00125 
00126         std::vector < std::string > qtFullPathHists;
00127         qtFullPathHists.reserve(qtPerSystem);
00128 
00129         std::vector<unsigned int> qtSumEnabled;
00130         qtSumEnabled.reserve(qtPerSystem);
00131 
00132         for (std::vector<edm::ParameterSet>::const_iterator itQT =
00133                 qTests.begin(); itQT != qTests.end(); ++itQT) {
00134 
00135             totalNrQualityTests++;
00136 
00137             qtNames.push_back(
00138                     itQT->getParameter<std::string> ("QualityTestName"));
00139 
00140             qtFullPathHists.push_back(
00141                     itQT->getParameter<std::string> ("QualityTestHist"));
00142 
00143             unsigned int qtEnabled = itQT->getParameter<unsigned int> (
00144                     "QualityTestSummaryEnabled");
00145 
00146             qtSumEnabled.push_back(qtEnabled);
00147 
00148             if (qtEnabled) {
00149                 m_totalNrQtSummaryEnabled++;
00150             }
00151         }
00152 
00153         m_systemQualityTestName.push_back(qtNames);
00154         m_systemQualityTestHist.push_back(qtFullPathHists);
00155         m_systemQtSummaryEnabled.push_back(qtSumEnabled);
00156 
00157         indexSys++;
00158 
00159     }
00160 
00161     // L1 objects
00162 
00163     //
00164     m_nrL1Objects = m_l1Objects.size();
00165 
00166     m_objectLabel.reserve(m_nrL1Objects);
00167     m_objectDisable.reserve(m_nrL1Objects);
00168 
00169     // on average five quality test per object - just a best guess
00170     m_objectQualityTestName.reserve(5*m_nrL1Objects);
00171     m_objectQualityTestHist.reserve(5*m_nrL1Objects);
00172     m_objectQtSummaryEnabled.reserve(5*m_nrL1Objects);
00173 
00174     int indexObj = 0;
00175 
00176     for (std::vector<edm::ParameterSet>::const_iterator itObject =
00177             m_l1Objects.begin(); itObject != m_l1Objects.end(); ++itObject) {
00178 
00179         m_objectLabel.push_back(itObject->getParameter<std::string>(
00180                 "ObjectLabel"));
00181 
00182         m_objectDisable.push_back(itObject->getParameter<unsigned int>(
00183                 "ObjectDisable"));
00184         // check the additional disable flag from m_disableL1Objects
00185         for (std::vector<std::string>::const_iterator itObj =
00186                 m_disableL1Objects.begin(); itObj != m_disableL1Objects.end(); ++itObj) {
00187 
00188             if (*itObj == m_objectLabel[indexObj]) {
00189                 m_objectDisable[indexObj] = 1;
00190 
00191             }
00192         }
00193 
00194         std::vector < edm::ParameterSet > qTests = itObject->getParameter<
00195                 std::vector<edm::ParameterSet> > ("QualityTests");
00196         size_t qtPerObject = qTests.size();
00197 
00198         std::vector < std::string > qtNames;
00199         qtNames.reserve(qtPerObject);
00200 
00201         std::vector < std::string > qtFullPathHists;
00202         qtFullPathHists.reserve(qtPerObject);
00203 
00204         std::vector<unsigned int> qtSumEnabled;
00205         qtSumEnabled.reserve(qtPerObject);
00206 
00207         for (std::vector<edm::ParameterSet>::const_iterator itQT =
00208                 qTests.begin(); itQT != qTests.end(); ++itQT) {
00209 
00210             totalNrQualityTests++;
00211 
00212             qtNames.push_back(
00213                     itQT->getParameter<std::string> ("QualityTestName"));
00214 
00215             qtFullPathHists.push_back(
00216                     itQT->getParameter<std::string> ("QualityTestHist"));
00217 
00218             unsigned int qtEnabled = itQT->getParameter<unsigned int> (
00219                     "QualityTestSummaryEnabled");
00220 
00221             qtSumEnabled.push_back(qtEnabled);
00222 
00223             if (qtEnabled) {
00224                 m_totalNrQtSummaryEnabled++;
00225             }
00226         }
00227 
00228         m_objectQualityTestName.push_back(qtNames);
00229         m_objectQualityTestHist.push_back(qtFullPathHists);
00230         m_objectQtSummaryEnabled.push_back(qtSumEnabled);
00231 
00232         indexObj++;
00233 
00234     }
00235 
00236     m_summaryContent.reserve(m_nrL1Systems + m_nrL1Objects);
00237     m_meReportSummaryContent.reserve(totalNrQualityTests);
00238 
00239 }
00240 
00241 
00242 void L1TEventInfoClient::beginJob() {
00243 
00244 
00245     // get backend interface
00246     m_dbe = edm::Service<DQMStore>().operator->();
00247 
00248 }
00249 
00250 
00251 void L1TEventInfoClient::beginRun(const edm::Run& run,
00252         const edm::EventSetup& evSetup) {
00253 
00254     bookHistograms();
00255 
00256 }
00257 
00258 
00259 void L1TEventInfoClient::beginLuminosityBlock(
00260         const edm::LuminosityBlock& lumiSeg, const edm::EventSetup& evSetup) {
00261 
00262 }
00263 
00264 
00265 void L1TEventInfoClient::analyze(const edm::Event& iEvent,
00266         const edm::EventSetup& evSetup) {
00267 
00268     // there is no loop on events in the offline harvesting step
00269     // code here will not be executed offline
00270 
00271     if (m_runInEventLoop) {
00272 
00273         readQtResults();
00274 
00275     }
00276 }
00277 
00278 
00279 void L1TEventInfoClient::endLuminosityBlock(
00280         const edm::LuminosityBlock& lumiSeg, const edm::EventSetup& evSetup) {
00281 
00282     if (m_runInEndLumi) {
00283 
00284         readQtResults();
00285 
00286         if (m_verbose) {
00287 
00288             std::cout << "\n  L1TEventInfoClient::endLuminosityBlock\n"
00289                     << std::endl;
00290             dumpContentMonitorElements();
00291         }
00292 
00293     }
00294 }
00295 
00296 
00297 void L1TEventInfoClient::endRun(const edm::Run& run,
00298         const edm::EventSetup& evSetup) {
00299 
00300     if (m_runInEndRun) {
00301 
00302         readQtResults();
00303 
00304         if (m_verbose) {
00305 
00306             std::cout << "\n  L1TEventInfoClient::endRun\n" << std::endl;
00307             dumpContentMonitorElements();
00308         }
00309 
00310     }
00311 }
00312 
00313 
00314 void L1TEventInfoClient::endJob() {
00315 
00316     if (m_runInEndJob) {
00317 
00318         readQtResults();
00319 
00320         if (m_verbose) {
00321 
00322             std::cout << "\n  L1TEventInfoClient::endRun\n" << std::endl;
00323             dumpContentMonitorElements();
00324         }
00325     }
00326 }
00327 
00328 
00329 void L1TEventInfoClient::dumpContentMonitorElements() {
00330 
00331     std::cout << "\nSummary report " << std::endl;
00332 
00333     // summary content
00334 
00335     MonitorElement* me = m_dbe->get(m_meReportSummaryMap->getName());
00336 
00337     std::cout
00338             << "\nSummary content per system and object as filled in histogram\n  "
00339             << m_meReportSummaryMap->getName() << std::endl;
00340 
00341     if (!me) {
00342 
00343         std::cout << "\nNo histogram " << m_meReportSummaryMap->getName()
00344                 << "\nNo summary content per system and object as filled in histogram.\n  "
00345                 << std::endl;
00346         return;
00347 
00348     }
00349 
00350     TH2F* hist = me->getTH2F();
00351 
00352     const int nBinsX = hist->GetNbinsX();
00353     const int nBinsY = hist->GetNbinsY();
00354     std::cout << nBinsX << " " << nBinsY;
00355 
00356     std::vector<std::vector<int> > meReportSummaryMap(nBinsX, std::vector<int>(
00357             nBinsY));
00358 
00359 //    for (int iBinX = 0; iBinX < nBinsX; iBinX++) {
00360 //        for (int iBinY = 0; iBinY < nBinsY; iBinY++) {
00361 //            meReportSummaryMap[iBinX][iBinY]
00362 //                    = static_cast<int>(me->GetBinContent(iBinX + 1, iBinY + 1));
00363 //        }
00364 //    }
00365 
00366     std::cout << "\nL1 systems: " << m_nrL1Systems << " systems included\n"
00367             << "\n Summary content size: " << (m_summaryContent.size())
00368             << std::endl;
00369 
00370     for (unsigned int iSys = 0; iSys < m_nrL1Systems; ++iSys) {
00371 
00372         std::cout << std::setw(10) << m_systemLabel[iSys] << std::setw(10)
00373                 << m_systemLabelExt[iSys] << " \t" << m_systemDisable[iSys]
00374                 << " \t" << std::setw(25) << " m_summaryContent["
00375                 << std::setw(2) << iSys << "] = " << meReportSummaryMap[0][iSys]
00376                 << std::endl;
00377     }
00378 
00379     std::cout << "\n L1 trigger objects: " << m_nrL1Objects
00380             << " objects included\n" << std::endl;
00381 
00382     for (unsigned int iMon = m_nrL1Systems; iMon < m_nrL1Systems
00383             + m_nrL1Objects; ++iMon) {
00384 
00385         std::cout << std::setw(20) << m_objectLabel[iMon - m_nrL1Systems]
00386                 << " \t" << m_objectDisable[iMon - m_nrL1Systems] << " \t"
00387                 << std::setw(25) << " m_summaryContent[" << std::setw(2)
00388                 << iMon << "] = \t" << m_summaryContent[iMon] << std::endl;
00389     }
00390 
00391     std::cout << std::endl;
00392 
00393     // quality tests
00394 
00395     std::cout << "\nQuality test results as filled in " << "\n  "
00396             << m_monitorDir << "/EventInfo/reportSummaryContents\n"
00397             << "\n  Total number of quality tests: "
00398             << (m_meReportSummaryContent.size()) << "\n" << std::endl;
00399 
00400     for (std::vector<MonitorElement*>::const_iterator itME =
00401             m_meReportSummaryContent.begin(); itME
00402             != m_meReportSummaryContent.end(); ++itME) {
00403 
00404         std::cout << std::setw(50) << (*itME)->getName() << " \t"
00405                 << std::setw(25) << (*itME)->getFloatValue() << std::endl;
00406 
00407     }
00408 
00409     std::cout << std::endl;
00410 
00411 }
00412 
00413 
00414 
00415 void L1TEventInfoClient::bookHistograms() {
00416 
00417     std::string dirEventInfo = m_monitorDir + "/EventInfo";
00418 
00419     m_dbe->setCurrentFolder(dirEventInfo);
00420 
00421     // remove m_meReportSummary if it exists
00422     if ((m_meReportSummary = m_dbe->get(dirEventInfo + "/reportSummary"))) {
00423         m_dbe->removeElement(m_meReportSummary->getName());
00424     }
00425 
00426     // ...and book it again
00427     m_meReportSummary = m_dbe->bookFloat("reportSummary");
00428 
00429     // initialize reportSummary to 1
00430 
00431     if (m_meReportSummary) {
00432         m_meReportSummary->Fill(1);
00433     }
00434 
00435     // define float histograms for reportSummaryContents (one histogram per quality test),
00436     // initialize them to zero
00437     // initialize also m_summaryContent to dqm::qstatus::DISABLED
00438 
00439     m_dbe->setCurrentFolder(dirEventInfo + "/reportSummaryContents");
00440 
00441     char histoQT[100];
00442 
00443     // general counters:
00444     //   iAllQTest: all quality tests for all systems and objects
00445     //   iAllMon:   all monitored systems and objects
00446     int iAllQTest = 0;
00447     int iAllMon = 0;
00448 
00449     for (unsigned int iMon = 0; iMon < m_nrL1Systems; ++iMon) {
00450 
00451         m_summaryContent.push_back(dqm::qstatus::DISABLED);
00452 
00453         const std::vector<std::string>& sysQtName =
00454                 m_systemQualityTestName[iMon];
00455 
00456         for (std::vector<std::string>::const_iterator itQtName =
00457                 sysQtName.begin(); itQtName != sysQtName.end(); ++itQtName) {
00458 
00459             const std::string hStr = m_monitorDir + "_L1Sys_" +m_systemLabel[iMon] + "_" + (*itQtName);
00460 
00461             const char* cStr = hStr.c_str();
00462             sprintf(histoQT, cStr);
00463 
00464             m_meReportSummaryContent.push_back(m_dbe->bookFloat(histoQT));
00465             m_meReportSummaryContent[iAllQTest]->Fill(0.);
00466 
00467             iAllQTest++;
00468         }
00469 
00470         iAllMon++;
00471     }
00472 
00473 
00474     for (unsigned int iMon = 0; iMon < m_nrL1Objects; ++iMon) {
00475 
00476         m_summaryContent.push_back(dqm::qstatus::DISABLED);
00477 
00478         const std::vector<std::string>& objQtName =
00479                 m_objectQualityTestName[iMon];
00480 
00481         for (std::vector<std::string>::const_iterator itQtName =
00482                 objQtName.begin(); itQtName != objQtName.end(); ++itQtName) {
00483 
00484             const std::string hStr = m_monitorDir + "_L1Obj_" + m_objectLabel[iMon] + "_"
00485                     + (*itQtName);
00486 
00487             const char* cStr = hStr.c_str();
00488             sprintf(histoQT, cStr);
00489 
00490             m_meReportSummaryContent.push_back(m_dbe->bookFloat(histoQT));
00491             m_meReportSummaryContent[iAllQTest]->Fill(0.);
00492 
00493             iAllQTest++;
00494         }
00495 
00496         iAllMon++;
00497 
00498     }
00499 
00500     m_dbe->setCurrentFolder(dirEventInfo);
00501 
00502     if ((m_meReportSummaryMap = m_dbe->get(dirEventInfo + "/reportSummaryMap"))) {
00503         m_dbe->removeElement(m_meReportSummaryMap->getName());
00504     }
00505 
00506     // define a histogram with two bins on X and maximum of m_nrL1Systems, m_nrL1Objects on Y
00507 
00508     int nBinsY = std::max(m_nrL1Systems, m_nrL1Objects);
00509 
00510     m_meReportSummaryMap = m_dbe->book2D("reportSummaryMap",
00511             "reportSummaryMap", 2, 1, 3, nBinsY, 1, nBinsY + 1);
00512 
00513     if (m_monitorDir == "L1TEMU") {
00514         m_meReportSummaryMap->setTitle(
00515                 "L1TEMU: L1 Emulator vs Data Report Summary Map");
00516 
00517     } else if (m_monitorDir == "L1T") {
00518         m_meReportSummaryMap->setTitle(
00519                 "L1T: L1 Trigger Data Report Summary Map");
00520     } else {
00521         // do nothing
00522     }
00523 
00524     m_meReportSummaryMap->setAxisTitle("", 1);
00525     m_meReportSummaryMap->setAxisTitle("", 2);
00526 
00527     m_meReportSummaryMap->setBinLabel(1, "L1 systems", 1);
00528     m_meReportSummaryMap->setBinLabel(2, "L1 objects", 1);
00529 
00530     for (int iBin = 0; iBin < nBinsY; ++iBin) {
00531 
00532         m_meReportSummaryMap->setBinLabel(iBin + 1, " ", 2);
00533     }
00534 
00535 }
00536 
00537 
00538 void L1TEventInfoClient::readQtResults() {
00539 
00540     // initialize summary content, summary sum and ReportSummaryContent float histograms
00541     // for all L1 systems and L1 objects
00542 
00543     for (std::vector<int>::iterator it = m_summaryContent.begin(); it
00544             != m_summaryContent.end(); ++it) {
00545 
00546         (*it) = dqm::qstatus::DISABLED;
00547 
00548     }
00549 
00550     m_summarySum = 0.;
00551 
00552     for (std::vector<MonitorElement*>::iterator itME =
00553             m_meReportSummaryContent.begin(); itME
00554             != m_meReportSummaryContent.end(); ++itME) {
00555 
00556         (*itME)->Fill(0.);
00557 
00558     }
00559 
00560 
00561     // general counters:
00562     //   iAllQTest: all quality tests for all systems and objects
00563     //   iAllMon:   all monitored systems and objects
00564     int iAllQTest = 0;
00565     int iAllMon = 0;
00566 
00567 
00568     // quality tests for all L1 systems
00569 
00570     for (unsigned int iSys = 0; iSys < m_nrL1Systems; ++iSys) {
00571 
00572         // get the reports for each quality test
00573 
00574         const std::vector<std::string>& sysQtName =
00575                 m_systemQualityTestName[iSys];
00576         const std::vector<std::string>& sysQtHist =
00577                 m_systemQualityTestHist[iSys];
00578         const std::vector<unsigned int>& sysQtSummaryEnabled =
00579                 m_systemQtSummaryEnabled[iSys];
00580 
00581         // pro system counter for quality tests
00582         int iSysQTest = 0;
00583 
00584         for (std::vector<std::string>::const_iterator itQtName =
00585                 sysQtName.begin(); itQtName != sysQtName.end(); ++itQtName) {
00586 
00587             // get results, status and message
00588 
00589             MonitorElement* qHist = m_dbe->get(sysQtHist[iSysQTest]);
00590 
00591             if (qHist) {
00592                 const std::vector<QReport*> qtVec = qHist->getQReports();
00593                 const std::string hName = qHist->getName();
00594 
00595                 if (m_verbose) {
00596 
00597                     std::cout << "\nNumber of quality tests "
00598                             << " for histogram " << sysQtHist[iSysQTest]
00599                             << ": " << qtVec.size() << "\n" << std::endl;
00600                 }
00601 
00602                 const QReport* sysQReport = qHist->getQReport(*itQtName);
00603                 if (sysQReport) {
00604                     const float sysQtResult = sysQReport->getQTresult();
00605                     const int sysQtStatus = sysQReport->getStatus();
00606                     const std::string& sysQtMessage = sysQReport->getMessage();
00607 
00608                     if (m_verbose) {
00609                         std::cout << "\n" << (*itQtName) << " quality test:"
00610                                 << "\n  result:  " << sysQtResult
00611                                 << "\n  status:  " << sysQtStatus
00612                                 << "\n  message: " << sysQtMessage << "\n"
00613                                 << "\nFilling m_meReportSummaryContent["
00614                                 << iAllQTest << "] with value "
00615                                 << sysQtResult << "\n" << std::endl;
00616                     }
00617 
00618                     m_meReportSummaryContent[iAllQTest]->Fill(sysQtResult);
00619 
00620                     // for the summary map, keep the highest status value ("ERROR") of all tests
00621                     // which are considered for the summary plot
00622                     if (sysQtSummaryEnabled[iSysQTest]) {
00623 
00624                         if (sysQtStatus > m_summaryContent[iAllMon]) {
00625                             m_summaryContent[iAllMon] = sysQtStatus;
00626                         }
00627 
00628                         m_summarySum += sysQtResult;
00629                     }
00630 
00631 
00632                 } else {
00633 
00634                     // for the summary map, if the test was not found but it is assumed to be
00635                     // considered for the summary plot, set it to dqm::qstatus::INVALID
00636 
00637                     int sysQtStatus = dqm::qstatus::INVALID;
00638 
00639                     if (sysQtSummaryEnabled[iSysQTest]) {
00640 
00641                         if (sysQtStatus > m_summaryContent[iAllMon]) {
00642                             m_summaryContent[iAllMon] = sysQtStatus;
00643                         }
00644                     }
00645 
00646                     m_meReportSummaryContent[iAllQTest]->Fill(0.);
00647 
00648                     if (m_verbose) {
00649 
00650                         std::cout << "\n" << (*itQtName)
00651                                 << " quality test not found\n" << std::endl;
00652                     }
00653                 }
00654 
00655             } else {
00656                 // for the summary map, if the histogram was not found but it is assumed
00657                 // to have a test be considered for the summary plot, set it to dqm::qstatus::INVALID
00658 
00659                 int sysQtStatus = dqm::qstatus::INVALID;
00660 
00661                 if (sysQtSummaryEnabled[iSysQTest]) {
00662 
00663                     if (sysQtStatus > m_summaryContent[iAllMon]) {
00664                         m_summaryContent[iAllMon] = sysQtStatus;
00665                     }
00666                 }
00667 
00668                 m_meReportSummaryContent[iAllQTest]->Fill(0.);
00669 
00670                 if (m_verbose) {
00671 
00672                     std::cout << "\nHistogram " << sysQtHist[iSysQTest]
00673                             << " not found\n" << std::endl;
00674                 }
00675 
00676             }
00677 
00678             // increase counters for quality tests
00679             iSysQTest++;
00680             iAllQTest++;
00681 
00682         }
00683 
00684         iAllMon++;
00685 
00686     }
00687 
00688     // quality tests for all L1 objects
00689 
00690     for (unsigned int iObj = 0; iObj < m_nrL1Objects; ++iObj) {
00691 
00692         // get the reports for each quality test
00693 
00694         const std::vector<std::string>& objQtName =
00695                 m_objectQualityTestName[iObj];
00696         const std::vector<std::string>& objQtHist =
00697                 m_objectQualityTestHist[iObj];
00698         const std::vector<unsigned int>& objQtSummaryEnabled =
00699                 m_objectQtSummaryEnabled[iObj];
00700 
00701         // pro object counter for quality tests
00702         int iObjQTest = 0;
00703 
00704         for (std::vector<std::string>::const_iterator itQtName =
00705                 objQtName.begin(); itQtName != objQtName.end(); ++itQtName) {
00706 
00707             // get results, status and message
00708 
00709             MonitorElement* qHist = m_dbe->get(objQtHist[iObjQTest]);
00710 
00711             if (qHist) {
00712                 const std::vector<QReport*> qtVec = qHist->getQReports();
00713                 const std::string hName = qHist->getName();
00714 
00715                 if (m_verbose) {
00716 
00717                     std::cout << "\nNumber of quality tests "
00718                             << " for histogram " << objQtHist[iObjQTest]
00719                             << ": " << qtVec.size() << "\n" << std::endl;
00720                 }
00721 
00722                 const QReport* objQReport = qHist->getQReport(*itQtName);
00723                 if (objQReport) {
00724                     const float objQtResult = objQReport->getQTresult();
00725                     const int objQtStatus = objQReport->getStatus();
00726                     const std::string& objQtMessage = objQReport->getMessage();
00727 
00728                     if (m_verbose) {
00729                         std::cout << "\n" << (*itQtName) << " quality test:"
00730                                 << "\n  result:  " << objQtResult
00731                                 << "\n  status:  " << objQtStatus
00732                                 << "\n  message: " << objQtMessage << "\n"
00733                                 << "\nFilling m_meReportSummaryContent["
00734                                 << iAllQTest << "] with value "
00735                                 << objQtResult << "\n" << std::endl;
00736                     }
00737 
00738                     m_meReportSummaryContent[iAllQTest]->Fill(objQtResult);
00739 
00740                     // for the summary map, keep the highest status value ("ERROR") of all tests
00741                     // which are considered for the summary plot
00742                     if (objQtSummaryEnabled[iObjQTest]) {
00743 
00744                         if (objQtStatus > m_summaryContent[iAllMon]) {
00745                             m_summaryContent[iAllMon] = objQtStatus;
00746                         }
00747 
00748                         m_summarySum += objQtResult;
00749                     }
00750 
00751                 } else {
00752 
00753                     // for the summary map, if the test was not found but it is assumed to be
00754                     // considered for the summary plot, set it to dqm::qstatus::INVALID
00755 
00756                     int objQtStatus = dqm::qstatus::INVALID;
00757 
00758                     if (objQtSummaryEnabled[iObjQTest]) {
00759 
00760                         if (objQtStatus > m_summaryContent[iAllMon]) {
00761                             m_summaryContent[iAllMon] = objQtStatus;
00762                         }
00763                     }
00764 
00765                     m_meReportSummaryContent[iAllQTest]->Fill(0.);
00766 
00767                     if (m_verbose) {
00768 
00769                         std::cout << "\n" << (*itQtName)
00770                                 << " quality test not found\n" << std::endl;
00771                     }
00772 
00773                 }
00774 
00775             } else {
00776                 // for the summary map, if the histogram was not found but it is assumed
00777                 // to have a test be considered for the summary plot, set it to dqm::qstatus::INVALID
00778 
00779                 int objQtStatus = dqm::qstatus::INVALID;
00780 
00781                 if (objQtSummaryEnabled[iObjQTest]) {
00782 
00783                     if (objQtStatus > m_summaryContent[iAllMon]) {
00784                         m_summaryContent[iAllMon] = objQtStatus;
00785                     }
00786                 }
00787 
00788                 m_meReportSummaryContent[iAllQTest]->Fill(0.);
00789 
00790                 if (m_verbose) {
00791                     std::cout << "\nHistogram " << objQtHist[iObjQTest]
00792                             << " not found\n" << std::endl;
00793                 }
00794 
00795             }
00796 
00797             // increase counters for quality tests
00798             iObjQTest++;
00799             iAllQTest++;
00800         }
00801 
00802         iAllMon++;
00803 
00804     }
00805 
00806 
00807 
00808     // reportSummary value
00809     m_reportSummary = m_summarySum / float(m_totalNrQtSummaryEnabled);
00810     if (m_meReportSummary) {
00811         m_meReportSummary->Fill(m_reportSummary);
00812     }
00813 
00814     // fill the ReportSummaryMap for L1 systems (bin 1 on X)
00815     for (unsigned int iSys = 0; iSys < m_nrL1Systems; ++iSys) {
00816 
00817         double summCont = static_cast<double>(m_summaryContent[iSys]);
00818         m_meReportSummaryMap->setBinContent(1, iSys + 1, summCont);
00819     }
00820 
00821     // fill the ReportSummaryMap for L1 objects (bin 2 on X)
00822     for (unsigned int iMon = m_nrL1Systems; iMon < m_nrL1Systems
00823             + m_nrL1Objects; ++iMon) {
00824 
00825         double summCont = static_cast<double>(m_summaryContent[iMon]);
00826         m_meReportSummaryMap->setBinContent(2, iMon - m_nrL1Systems + 1, summCont);
00827 
00828     }
00829 
00830 }
00831 
00832 
00833