Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-03-13 02:31:37 

0001 /*! \file SiPixelDataQuality.cc
0002  *  \brief This class represents ...
0003  *
0004  *  (Documentation under development)
0005  *
0006  */
0007 #include "DQM/SiPixelCommon/interface/SiPixelFolderOrganizer.h"
0008 #include "DQM/SiPixelMonitorClient/interface/ANSIColors.h"
0009 #include "DQM/SiPixelMonitorClient/interface/SiPixelDataQuality.h"
0010 #include "DQM/SiPixelMonitorClient/interface/SiPixelEDAClient.h"
0011 #include "DQM/SiPixelMonitorClient/interface/SiPixelUtility.h"
0012 
0013 #include "DQMServices/Core/interface/DQMStore.h"
0014 
0015 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0016 #include "FWCore/ParameterSet/interface/FileInPath.h"
0017 
0018 #include "DataFormats/DetId/interface/DetId.h"
0019 #include "DataFormats/GeometrySurface/interface/Surface.h"
0020 #include "DataFormats/TrackerCommon/interface/PixelBarrelName.h"
0021 #include "DataFormats/TrackerCommon/interface/PixelEndcapName.h"
0022 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
0023 
0024 #include "CondFormats/SiPixelObjects/interface/DetectorIndex.h"
0025 #include "CondFormats/SiPixelObjects/interface/SiPixelFrameConverter.h"
0026 
0027 #include "Geometry/CommonTopologies/interface/PixelTopology.h"
0028 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
0029 #include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"
0030 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
0031 #include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
0032 
0033 #include "Rtypes.h"
0034 #include "TAxis.h"
0035 #include "TClass.h"
0036 #include "TH1F.h"
0037 #include "TH2F.h"
0038 #include "TImage.h"
0039 #include "TImageDump.h"
0040 #include "TPad.h"
0041 #include "TPaveLabel.h"
0042 #include "TPaveText.h"
0043 #include "TProfile.h"
0044 #include "TROOT.h"
0045 #include "TRandom.h"
0046 #include "TStopwatch.h"
0047 #include "TString.h"
0048 #include "TStyle.h"
0049 #include "TSystem.h"
0050 #include "TText.h"
0051 
0052 #include <cmath>
0053 #include <iostream>
0054 #include <map>
0055 
0056 #include <cstdlib>  // for free() - Root can allocate with malloc() - sigh...
0057 #include <fstream>
0058 
0059 using namespace std;
0060 using namespace edm;
0061 
0062 //------------------------------------------------------------------------------
0063 /*! \brief Constructor of the SiPixelInformationExtractor class.
0064  *
0065  */
0066 SiPixelDataQuality::SiPixelDataQuality(bool offlineXMLfile) : offlineXMLfile_(offlineXMLfile) {
0067   edm::LogInfo("SiPixelDataQuality") << " Creating SiPixelDataQuality "
0068                                      << "\n";
0069 
0070   allMods_ = 0;
0071   errorMods_ = 0;
0072   qflag_ = 1.;
0073 
0074   allmodsMap = nullptr;
0075   errmodsMap = nullptr;
0076   goodmodsMap = nullptr;
0077   allmodsVec = nullptr;
0078   errmodsVec = nullptr;
0079   goodmodsVec = nullptr;
0080   for (int i = 0; i < 40; ++i) {
0081     lastallmods_[i] = 0;
0082     lasterrmods_[i] = 0;
0083   }
0084   timeoutCounter_ = 0;
0085   lastLS_ = -1;
0086 }
0087 
0088 //------------------------------------------------------------------------------
0089 /*! \brief Destructor of the SiPixelDataQuality class.
0090  *
0091  */
0092 SiPixelDataQuality::~SiPixelDataQuality() {
0093   edm::LogInfo("SiPixelDataQuality") << " Deleting SiPixelDataQuality "
0094                                      << "\n";
0095   if (allmodsMap)
0096     delete allmodsMap;
0097   if (errmodsMap)
0098     delete errmodsMap;
0099   if (goodmodsMap)
0100     delete goodmodsMap;
0101   if (allmodsVec)
0102     delete allmodsVec;
0103   if (errmodsVec)
0104     delete errmodsVec;
0105   if (goodmodsVec)
0106     delete goodmodsVec;
0107 }
0108 
0109 //------------------------------------------------------------------------------
0110 /*! \brief (Documentation under construction).
0111  *
0112  *  Given a pointer to ME returns the associated detId
0113  */
0114 int SiPixelDataQuality::getDetId(MonitorElement *mE) {
0115   const string &mEName = mE->getName();
0116 
0117   int detId = 0;
0118 
0119   if (mEName.find("_3") != string::npos) {
0120     string detIdString = mEName.substr((mEName.find_last_of('_')) + 1, 9);
0121     std::istringstream isst;
0122     isst.str(detIdString);
0123     isst >> detId;
0124   }
0125 
0126   return detId;
0127 }
0128 
0129 /////////////////////////////////////////////////////////////////////////////////////////////////////
0130 
0131 void SiPixelDataQuality::bookGlobalQualityFlag(DQMStore::IBooker &iBooker, bool Tier0Flag, int nFEDs) {
0132   // std::cout<<"BOOK GLOBAL QUALITY FLAG MEs!"<<std::endl;
0133   iBooker.cd();
0134 
0135   iBooker.setCurrentFolder("Pixel/Barrel");
0136   if (!Tier0Flag) {
0137     ClusterModAll = iBooker.book1D("NClustertoChargeRatio_AllMod", "Cluster Noise All Modules", 768, 0., 768.);
0138     ClusterMod1 = iBooker.book1D(
0139         "NClustertoChargeRatio_NormMod1", "Normalized N_{Clusters} to Charge Ratio per Module1", 192, 0., 192.);
0140     ClusterMod2 = iBooker.book1D(
0141         "NClustertoChargeRatio_NormMod2", "Normalized N_{Clusters} to Charge Ratio per Module2", 192, 0., 192.);
0142     ClusterMod3 = iBooker.book1D(
0143         "NClustertoChargeRatio_NormMod3", "Normalized N_{Clusters} to Charge Ratio per Module3", 192, 0., 192.);
0144     ClusterMod4 = iBooker.book1D(
0145         "NClustertoChargeRatio_NormMod4", "Normalized N_{Clusters} to Charge Ratio per Module4", 192, 0., 192.);
0146   }
0147   iBooker.setCurrentFolder("Pixel/EventInfo");
0148   if (!Tier0Flag) {
0149     SummaryReportMap = iBooker.book2D("reportSummaryMap", "Pixel Summary Map", 3000, 0., 3000., 40, 0., 40.);
0150     SummaryReportMap->setAxisTitle("Lumi Section", 1);
0151     SummaryReportMap->setAxisTitle("Pixel FED #", 2);
0152     allmodsVec = new TH1D("allmodsVec", "allmodsVec", 40, 0., 40.);
0153     errmodsVec = new TH1D("errmodsVec", "errmodsVec", 40, 0., 40.);
0154     goodmodsVec = new TH1D("goodmodsVec", "goodmodsVec", 40, 0., 40.);
0155   } else {
0156     SummaryReportMap = iBooker.book2D("reportSummaryMap", "Pixel Summary Map", 2, 0., 2., 7, 0., 7.);
0157     SummaryReportMap->setBinLabel(1, "Barrel", 1);
0158     SummaryReportMap->setBinLabel(2, "Endcaps", 1);
0159     SummaryReportMap->setBinLabel(1, "Errors", 2);
0160     SummaryReportMap->setBinLabel(2, "NDigis", 2);
0161     SummaryReportMap->setBinLabel(3, "DigiCharge", 2);
0162     SummaryReportMap->setBinLabel(4, "ClusterSize", 2);
0163     SummaryReportMap->setBinLabel(5, "NClusters", 2);
0164     SummaryReportMap->setBinLabel(6, "ClusterCharge", 2);
0165     SummaryReportMap->setBinLabel(7, "HitEff", 2);
0166     allmodsMap = new TH2F("allmodsMap", "allmodsMap", 2, 0., 2., 7, 0., 7.);
0167     errmodsMap = new TH2F("errmodsMap", "errmodsMap", 2, 0., 2., 7, 0., 7.);
0168     goodmodsMap = new TH2F("goodmodsMap", "goodmodsMap", 2, 0., 2., 7, 0., 7.);
0169   }
0170   SummaryPixel = iBooker.bookFloat("reportSummary");
0171   iBooker.setCurrentFolder("Pixel/EventInfo/reportSummaryContents");
0172   SummaryBarrel = iBooker.bookFloat("PixelBarrelFraction");
0173   SummaryEndcap = iBooker.bookFloat("PixelEndcapFraction");
0174   // book the data certification cuts:
0175   iBooker.setCurrentFolder("Pixel/AdditionalPixelErrors");
0176   NErrorsFEDs = iBooker.bookFloat("FEDsNErrorsCut");
0177   iBooker.setCurrentFolder("Pixel/Barrel");
0178   NErrorsBarrel = iBooker.bookFloat("BarrelNErrorsCut");
0179   NDigisBarrel = iBooker.bookInt("BarrelNDigisCut");
0180   DigiChargeBarrel = iBooker.bookInt("BarrelDigiChargeCut");
0181   ClusterSizeBarrel = iBooker.bookInt("BarrelClusterSizeCut");
0182   NClustersBarrel = iBooker.bookInt("BarrelNClustersCut");
0183   ClusterChargeBarrel = iBooker.bookInt("BarrelClusterChargeCut");
0184   iBooker.setCurrentFolder("Pixel/Endcap");
0185   NErrorsEndcap = iBooker.bookFloat("EndcapNErrorsCut");
0186   NDigisEndcap = iBooker.bookInt("EndcapNDigisCut");
0187   DigiChargeEndcap = iBooker.bookInt("EndcapDigiChargeCut");
0188   ClusterSizeEndcap = iBooker.bookInt("EndcapClusterSizeCut");
0189   NClustersEndcap = iBooker.bookInt("EndcapNClustersCut");
0190   ClusterChargeEndcap = iBooker.bookInt("EndcapClusterChargeCut");
0191   if (Tier0Flag) {
0192     iBooker.setCurrentFolder("Pixel/Tracks");
0193     NPixelTracks = iBooker.bookInt("PixelTracksCut");
0194   }
0195 
0196   // Init MonitoringElements:
0197   if (nFEDs > 0) {
0198     if (SummaryPixel)
0199       SummaryPixel->Fill(1.);
0200     if (SummaryBarrel)
0201       SummaryBarrel->Fill(1.);
0202     if (SummaryEndcap)
0203       SummaryEndcap->Fill(1.);
0204   } else {
0205     if (SummaryPixel)
0206       SummaryPixel->Fill(-1.);
0207     if (SummaryBarrel)
0208       SummaryBarrel->Fill(-1.);
0209     if (SummaryEndcap)
0210       SummaryEndcap->Fill(-1.);
0211   }
0212   if (NErrorsBarrel)
0213     NErrorsBarrel->Fill(1.);
0214   if (NErrorsEndcap)
0215     NErrorsEndcap->Fill(1.);
0216   if (NErrorsFEDs)
0217     NErrorsFEDs->Fill(1.);
0218   if (NDigisBarrel)
0219     NDigisBarrel->Fill(1);
0220   if (NDigisEndcap)
0221     NDigisEndcap->Fill(1);
0222   if (DigiChargeBarrel)
0223     DigiChargeBarrel->Fill(1);
0224   if (DigiChargeEndcap)
0225     DigiChargeEndcap->Fill(1);
0226   if (ClusterSizeBarrel)
0227     ClusterSizeBarrel->Fill(1);
0228   if (ClusterSizeEndcap)
0229     ClusterSizeEndcap->Fill(1);
0230   if (ClusterChargeBarrel)
0231     ClusterChargeBarrel->Fill(1);
0232   if (ClusterChargeEndcap)
0233     ClusterChargeEndcap->Fill(1);
0234   if (NClustersBarrel)
0235     NClustersBarrel->Fill(1);
0236   if (NClustersEndcap)
0237     NClustersEndcap->Fill(1);
0238   if (Tier0Flag) {
0239     if (NPixelTracks)
0240       NPixelTracks->Fill(1);
0241   }
0242 
0243   if (SummaryReportMap) {
0244     if (!Tier0Flag)
0245       for (int i = 1; i != 3001; i++)
0246         for (int j = 1; j != 41; j++)
0247           SummaryReportMap->setBinContent(i, j, -1.);
0248     if (Tier0Flag)
0249       for (int i = 1; i != 3; i++)
0250         for (int j = 1; j != 8; j++)
0251           SummaryReportMap->setBinContent(i, j, -1.);
0252   }
0253   if (!Tier0Flag) {
0254     for (int j = 1; j != 41; j++) {
0255       if (allmodsVec)
0256         allmodsVec->SetBinContent(j, 0.);
0257       if (errmodsVec)
0258         errmodsVec->SetBinContent(j, 0.);
0259       if (goodmodsVec)
0260         goodmodsVec->SetBinContent(j, 0.);
0261     }
0262   }
0263   if (Tier0Flag) {
0264     for (int i = 1; i != 3; i++)
0265       for (int j = 1; j != 8; j++) {
0266         if (allmodsMap)
0267           allmodsMap->SetBinContent(i, j, 0.);
0268         if (errmodsMap)
0269           errmodsMap->SetBinContent(i, j, 0.);
0270         if (goodmodsMap)
0271           goodmodsMap->SetBinContent(i, j, 0.);
0272       }
0273   }
0274 
0275   iBooker.cd();
0276 }
0277 
0278 //**********************************************************************************************
0279 
0280 void SiPixelDataQuality::computeGlobalQualityFlag(
0281     DQMStore::IBooker &iBooker, DQMStore::IGetter &iGetter, bool init, int nFEDs, bool Tier0Flag) {
0282   if (init) {
0283     allMods_ = 0;
0284     errorMods_ = 0;
0285     qflag_ = 0.;
0286     barrelMods_ = 0;
0287     endcapMods_ = 0;
0288     objectCount_ = 0;
0289     DONE_ = false;
0290 
0291     // Error counters and flags:
0292     n_errors_barrel_ = 0;
0293     barrel_error_flag_ = 0.;
0294     n_errors_endcap_ = 0;
0295     endcap_error_flag_ = 0.;
0296     n_errors_pixel_ = 0;
0297     pixel_error_flag_ = 0.;
0298     digiStatsBarrel = false, clusterStatsBarrel = false, trackStatsBarrel = false;
0299     digiCounterBarrel = 0, clusterCounterBarrel = 0, trackCounterBarrel = 0;
0300     digiStatsEndcap = false, clusterStatsEndcap = false, trackStatsEndcap = false;
0301     digiCounterEndcap = 0, clusterCounterEndcap = 0, trackCounterEndcap = 0;
0302   }
0303   if (nFEDs == 0)
0304     return;
0305 
0306   string currDir = iBooker.pwd();
0307   string dname = currDir.substr(currDir.find_last_of('/') + 1);
0308 
0309   if ((!Tier0Flag && dname.find("Module_") != string::npos) ||
0310       (Tier0Flag && (dname.find("Ladder_") != string::npos || dname.find("Blade_") != string::npos))) {
0311     objectCount_++;
0312 
0313     if (currDir.find("Pixel") != string::npos)
0314       allMods_++;
0315     if (currDir.find("Barrel") != string::npos)
0316       barrelMods_++;
0317     if (currDir.find("Endcap") != string::npos)
0318       endcapMods_++;
0319     vector<string> meVec = iGetter.getMEs();
0320     for (vector<string>::const_iterator it = meVec.begin(); it != meVec.end(); it++) {
0321       string full_path = currDir + "/" + (*it);
0322       if (full_path.find("ndigis_") != string::npos) {
0323         MonitorElement *me = iGetter.get(full_path);
0324         if (!me)
0325           continue;
0326         if (me->getEntries() > 25) {
0327           if (full_path.find("Barrel") != string::npos)
0328             digiCounterBarrel++;
0329           if (full_path.find("Endcap") != string::npos)
0330             digiCounterEndcap++;
0331         }
0332       } else if (Tier0Flag && full_path.find("nclusters_OnTrack_") != string::npos) {
0333         MonitorElement *me = iGetter.get(full_path);
0334         if (!me)
0335           continue;
0336         if (me->getEntries() > 25) {
0337           if (full_path.find("Barrel") != string::npos)
0338             clusterCounterBarrel++;
0339           if (full_path.find("Endcap") != string::npos)
0340             clusterCounterEndcap++;
0341         }
0342       } else if (!Tier0Flag && full_path.find("nclusters_") != string::npos) {
0343         MonitorElement *me = iGetter.get(full_path);
0344         if (!me)
0345           continue;
0346         if (me->getEntries() > 25) {
0347           if (full_path.find("Barrel") != string::npos)
0348             clusterCounterBarrel++;
0349           if (full_path.find("Endcap") != string::npos)
0350             clusterCounterEndcap++;
0351         }
0352       }
0353     }
0354   }
0355   vector<string> subDirVec = iGetter.getSubdirs();
0356   for (vector<string>::const_iterator ic = subDirVec.begin(); ic != subDirVec.end(); ic++) {
0357     iGetter.cd(*ic);
0358     iBooker.cd(*ic);
0359     init = false;
0360     computeGlobalQualityFlag(iBooker, iGetter, init, nFEDs, Tier0Flag);
0361     iBooker.goUp();
0362     iGetter.setCurrentFolder(iBooker.pwd());
0363   }
0364 
0365   // Make sure I have finished looping over all Modules/Ladders/Blades:
0366   if (!Tier0Flag) {  // online case
0367     if (objectCount_ == 1440)
0368       DONE_ = true;
0369   } else {  // offline case
0370     if (objectCount_ == 288)
0371       DONE_ = true;
0372   }
0373 
0374   if (DONE_ && currDir == "Pixel/EventInfo/reportSummaryContents") {
0375     // Evaluate error flag now, only stored in AdditionalPixelErrors:
0376     MonitorElement *me_err = iGetter.get("Pixel/AdditionalPixelErrors/FedETypeNErr");
0377     MonitorElement *me_evt = iGetter.get("Pixel/EventInfo/processedEvents");
0378     if (me_err && me_evt) {
0379       for (int i = 1; i != 41; i++)
0380         for (int j = 1; j != 22; j++)
0381           if (me_err->getBinContent(i, j) > 0) {
0382             n_errors_pixel_ = n_errors_pixel_ + int(me_err->getBinContent(i, j));
0383             if (i < 33)
0384               n_errors_barrel_ = n_errors_barrel_ + int(me_err->getBinContent(i, j));
0385             if (i > 32)
0386               n_errors_endcap_ = n_errors_endcap_ + int(me_err->getBinContent(i, j));
0387           }
0388       int NProcEvts = me_evt->getIntValue();
0389       if (NProcEvts > 0) {
0390         barrel_error_flag_ = (float(NProcEvts) - float(n_errors_barrel_)) / float(NProcEvts);
0391         endcap_error_flag_ = (float(NProcEvts) - float(n_errors_endcap_)) / float(NProcEvts);
0392         pixel_error_flag_ = (float(NProcEvts) - float(n_errors_barrel_) - float(n_errors_endcap_)) / float(NProcEvts);
0393       }
0394     }
0395     NErrorsBarrel = iGetter.get("Pixel/Barrel/BarrelNErrorsCut");
0396     if (NErrorsBarrel)
0397       NErrorsBarrel->Fill(barrel_error_flag_);
0398     NErrorsEndcap = iGetter.get("Pixel/Endcap/EndcapNErrorsCut");
0399     if (NErrorsEndcap)
0400       NErrorsEndcap->Fill(endcap_error_flag_);
0401 
0402     string meName0;
0403     MonitorElement *me;
0404 
0405     // Fill the Digi flags:
0406     if (!Tier0Flag) {
0407       meName0 = "Pixel/Barrel/SUMDIG_ndigis_Barrel";
0408       if (digiCounterBarrel / 768 > 0.5)
0409         digiStatsBarrel = true;
0410       if (digiCounterEndcap / 672 > 0.5)
0411         digiStatsEndcap = true;
0412     } else {
0413       meName0 = "Pixel/Barrel/SUMOFF_ndigis_Barrel";
0414       if (digiCounterBarrel / 192 > 0.5)
0415         digiStatsBarrel = true;
0416       if (digiCounterEndcap / 96 > 0.5)
0417         digiStatsEndcap = true;
0418     }
0419     me = iGetter.get(meName0);
0420     if (me) {
0421       NDigisBarrel = iGetter.get("Pixel/Barrel/BarrelNDigisCut");
0422       if (NDigisBarrel && digiStatsBarrel) {
0423         if (me->hasError())
0424           NDigisBarrel->Fill(0);
0425         else
0426           NDigisBarrel->Fill(1);
0427       }
0428     }
0429     if (!Tier0Flag)
0430       meName0 = "Pixel/Endcap/SUMDIG_ndigis_Endcap";
0431     else
0432       meName0 = "Pixel/Endcap/SUMOFF_ndigis_Endcap";
0433     me = iGetter.get(meName0);
0434     if (me) {
0435       NDigisEndcap = iGetter.get("Pixel/Endcap/EndcapNDigisCut");
0436       if (NDigisEndcap && digiStatsEndcap) {
0437         if (me->hasError())
0438           NDigisEndcap->Fill(0);
0439         else
0440           NDigisEndcap->Fill(1);
0441       }
0442     }
0443     if (!Tier0Flag)
0444       meName0 = "Pixel/Barrel/SUMDIG_adc_Barrel";
0445     else
0446       meName0 = "Pixel/Barrel/SUMOFF_adc_Barrel";
0447     me = iGetter.get(meName0);
0448     if (me) {
0449       DigiChargeBarrel = iGetter.get("Pixel/Barrel/BarrelDigiChargeCut");
0450       if (DigiChargeBarrel && digiStatsBarrel) {
0451         if (me->hasError())
0452           DigiChargeBarrel->Fill(0);
0453         else
0454           DigiChargeBarrel->Fill(1);
0455       }
0456     }
0457     if (!Tier0Flag)
0458       meName0 = "Pixel/Endcap/SUMDIG_adc_Endcap";
0459     else
0460       meName0 = "Pixel/Endcap/SUMOFF_adc_Endcap";
0461     me = iGetter.get(meName0);
0462     if (me) {
0463       DigiChargeEndcap = iGetter.get("Pixel/Endcap/EndcapDigiChargeCut");
0464       if (DigiChargeEndcap && digiStatsEndcap) {
0465         if (me->hasError())
0466           DigiChargeEndcap->Fill(0);
0467         else
0468           DigiChargeEndcap->Fill(1);
0469       }
0470     }
0471 
0472     // Fill the Cluster flags:
0473     if (!Tier0Flag) {
0474       meName0 = "Pixel/Barrel/SUMCLU_size_Barrel";
0475       if (clusterCounterBarrel / 768 > 0.5)
0476         clusterStatsBarrel = true;
0477       if (clusterCounterEndcap / 672 > 0.5)
0478         clusterStatsEndcap = true;
0479     } else {
0480       meName0 = "Pixel/Barrel/SUMOFF_size_OnTrack_Barrel";
0481       if (clusterCounterBarrel / 192 > 0.5)
0482         clusterStatsBarrel = true;
0483       if (clusterCounterEndcap / 96 > 0.5)
0484         clusterStatsEndcap = true;
0485     }
0486     me = iGetter.get(meName0);
0487     if (me) {
0488       ClusterSizeBarrel = iGetter.get("Pixel/Barrel/BarrelClusterSizeCut");
0489       if (ClusterSizeBarrel && clusterStatsBarrel) {
0490         if (me->hasError())
0491           ClusterSizeBarrel->Fill(0);
0492         else
0493           ClusterSizeBarrel->Fill(1);
0494       }
0495     }
0496     if (!Tier0Flag)
0497       meName0 = "Pixel/Endcap/SUMCLU_size_Endcap";
0498     else
0499       meName0 = "Pixel/Endcap/SUMOFF_size_OnTrack_Endcap";
0500     me = iGetter.get(meName0);
0501     if (me) {
0502       ClusterSizeEndcap = iGetter.get("Pixel/Endcap/EndcapClusterSizeCut");
0503       if (ClusterSizeEndcap && clusterStatsEndcap) {
0504         if (me->hasError())
0505           ClusterSizeEndcap->Fill(0);
0506         else
0507           ClusterSizeEndcap->Fill(1);
0508       }
0509     }
0510     if (!Tier0Flag)
0511       meName0 = "Pixel/Barrel/SUMCLU_charge_Barrel";
0512     else
0513       meName0 = "Pixel/Barrel/SUMOFF_charge_OnTrack_Barrel";
0514     me = iGetter.get(meName0);
0515     if (me) {
0516       ClusterChargeBarrel = iGetter.get("Pixel/Barrel/BarrelClusterChargeCut");
0517       if (ClusterChargeBarrel && clusterStatsBarrel) {
0518         if (me->hasError())
0519           ClusterChargeBarrel->Fill(0);
0520         else
0521           ClusterChargeBarrel->Fill(1);
0522       }
0523     }
0524     if (!Tier0Flag)
0525       meName0 = "Pixel/Endcap/SUMCLU_charge_Endcap";
0526     else
0527       meName0 = "Pixel/Endcap/SUMOFF_charge_OnTrack_Endcap";
0528     me = iGetter.get(meName0);
0529     if (me) {
0530       ClusterChargeEndcap = iGetter.get("Pixel/Endcap/EndcapClusterChargeCut");
0531       if (ClusterChargeEndcap && clusterStatsEndcap) {
0532         if (me->hasError())
0533           ClusterChargeEndcap->Fill(0);
0534         else
0535           ClusterChargeEndcap->Fill(1);
0536       }
0537     }
0538     if (!Tier0Flag)
0539       meName0 = "Pixel/Barrel/SUMCLU_nclusters_Barrel";
0540     else
0541       meName0 = "Pixel/Barrel/SUMOFF_nclusters_OnTrack_Barrel";
0542     me = iGetter.get(meName0);
0543     if (me) {
0544       NClustersBarrel = iGetter.get("Pixel/Barrel/BarrelNClustersCut");
0545       if (NClustersBarrel && clusterStatsBarrel) {
0546         if (me->hasError())
0547           NClustersBarrel->Fill(0);
0548         else
0549           NClustersBarrel->Fill(1);
0550       }
0551     }
0552     if (!Tier0Flag)
0553       meName0 = "Pixel/Endcap/SUMCLU_nclusters_Endcap";
0554     else
0555       meName0 = "Pixel/Endcap/SUMOFF_nclusters_OnTrack_Endcap";
0556     me = iGetter.get(meName0);
0557     if (me) {
0558       NClustersEndcap = iGetter.get("Pixel/Endcap/EndcapNClustersCut");
0559       if (NClustersEndcap && clusterStatsEndcap) {
0560         if (me->hasError())
0561           NClustersEndcap->Fill(0);
0562         else
0563           NClustersEndcap->Fill(1);
0564       }
0565     }
0566     // Pixel Track multiplicity / Pixel hit efficiency
0567     meName0 = "Pixel/Tracks/ntracks_generalTracks";
0568     me = iGetter.get(meName0);
0569     if (me) {
0570       NPixelTracks = iGetter.get("Pixel/Tracks/PixelTracksCut");
0571       if (NPixelTracks && me->getBinContent(1) > 1000) {
0572         if ((float)me->getBinContent(2) / (float)me->getBinContent(1) < 0.01) {
0573           NPixelTracks->Fill(0);
0574         } else {
0575           NPixelTracks->Fill(1);
0576         }
0577       }
0578     }
0579 
0580     //********************************************************************************************************
0581 
0582     // Final combination of all Data Quality results:
0583     float pixelFlag = -1., barrelFlag = -1., endcapFlag = -1.;
0584     float barrel_errors_temp[1] = {-1.};
0585     int barrel_cuts_temp[5] = {5 * -1};
0586     float endcap_errors_temp[1] = {-1.};
0587     int endcap_cuts_temp[5] = {5 * -1};
0588     int pixel_cuts_temp[1] = {-1};
0589     float combinedCuts = 1.;
0590     int numerator = 0, denominator = 0;
0591 
0592     // Barrel results:
0593     me = iGetter.get("Pixel/Barrel/BarrelNErrorsCut");
0594     if (me)
0595       barrel_errors_temp[0] = me->getFloatValue();
0596     me = iGetter.get("Pixel/Barrel/BarrelNDigisCut");
0597     if (me)
0598       barrel_cuts_temp[0] = me->getIntValue();
0599     me = iGetter.get("Pixel/Barrel/BarrelDigiChargeCut");
0600     if (me)
0601       barrel_cuts_temp[1] = me->getIntValue();
0602     me = iGetter.get("Pixel/Barrel/BarrelClusterSizeCut");
0603     if (me)
0604       barrel_cuts_temp[2] = me->getIntValue();
0605     me = iGetter.get("Pixel/Barrel/BarrelNClustersCut");
0606     if (me)
0607       barrel_cuts_temp[3] = me->getIntValue();
0608     me = iGetter.get("Pixel/Barrel/BarrelClusterChargeCut");
0609     if (me)
0610       barrel_cuts_temp[4] = me->getIntValue();
0611     for (int k = 0; k != 5; k++) {
0612       if (barrel_cuts_temp[k] >= 0) {
0613         numerator = numerator + barrel_cuts_temp[k];
0614         denominator++;
0615       }
0616     }
0617     if (denominator != 0)
0618       combinedCuts = float(numerator) / float(denominator);
0619     barrelFlag = barrel_errors_temp[0] * combinedCuts;
0620 
0621     // Endcap results:
0622     combinedCuts = 1.;
0623     numerator = 0;
0624     denominator = 0;
0625     me = iGetter.get("Pixel/Endcap/EndcapNErrorsCut");
0626     if (me)
0627       endcap_errors_temp[0] = me->getFloatValue();
0628     me = iGetter.get("Pixel/Endcap/EndcapNDigisCut");
0629     if (me)
0630       endcap_cuts_temp[0] = me->getIntValue();
0631     me = iGetter.get("Pixel/Endcap/EndcapDigiChargeCut");
0632     if (me)
0633       endcap_cuts_temp[1] = me->getIntValue();
0634     me = iGetter.get("Pixel/Endcap/EndcapClusterSizeCut");
0635     if (me)
0636       endcap_cuts_temp[2] = me->getIntValue();
0637     me = iGetter.get("Pixel/Endcap/EndcapNClustersCut");
0638     if (me)
0639       endcap_cuts_temp[3] = me->getIntValue();
0640     me = iGetter.get("Pixel/Endcap/EndcapClusterChargeCut");
0641     if (me)
0642       endcap_cuts_temp[4] = me->getIntValue();
0643     for (int k = 0; k != 5; k++) {
0644       if (endcap_cuts_temp[k] >= 0) {
0645         numerator = numerator + endcap_cuts_temp[k];
0646         denominator++;
0647       }
0648     }
0649     if (denominator != 0)
0650       combinedCuts = float(numerator) / float(denominator);
0651     endcapFlag = endcap_errors_temp[0] * combinedCuts;
0652 
0653     // Track results:
0654 
0655     me = iGetter.get("Pixel/Tracks/PixelTracksCut");
0656     if (me)
0657       pixel_cuts_temp[0] = me->getIntValue();
0658 
0659     // Combination of all:
0660     combinedCuts = 1.;
0661     numerator = 0;
0662     denominator = 0;
0663     for (int k = 0; k != 5; k++) {
0664       if (barrel_cuts_temp[k] >= 0) {
0665         numerator = numerator + barrel_cuts_temp[k];
0666         denominator++;
0667       }
0668       if (endcap_cuts_temp[k] >= 0) {
0669         numerator = numerator + endcap_cuts_temp[k];
0670         denominator++;
0671       }
0672       if (k < 1 && pixel_cuts_temp[k] >= 0) {
0673         numerator = numerator + pixel_cuts_temp[k];
0674         denominator++;
0675       }
0676     }
0677     if (denominator != 0)
0678       combinedCuts = float(numerator) / float(denominator);
0679     pixelFlag = float(pixel_error_flag_) * float(combinedCuts);
0680 
0681     SummaryPixel = iGetter.get("Pixel/EventInfo/reportSummary");
0682     if (SummaryPixel)
0683       SummaryPixel->Fill(pixelFlag);
0684     SummaryBarrel = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelBarrelFraction");
0685     if (SummaryBarrel)
0686       SummaryBarrel->Fill(barrelFlag);
0687     SummaryEndcap = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelEndcapFraction");
0688     if (SummaryEndcap)
0689       SummaryEndcap->Fill(endcapFlag);
0690   }
0691 }
0692 
0693 //**********************************************************************************************
0694 
0695 void SiPixelDataQuality::computeGlobalQualityFlagByLumi(DQMStore::IGetter &iGetter,
0696                                                         bool init,
0697                                                         int nFEDs,
0698                                                         bool Tier0Flag,
0699                                                         int nEvents_lastLS_,
0700                                                         int nErrorsBarrel_lastLS_,
0701                                                         int nErrorsEndcap_lastLS_) {
0702   if (nFEDs == 0)
0703     return;
0704 
0705   // evaluate fatal FED errors for data quality:
0706   float BarrelRate_LS = 1.;
0707   float EndcapRate_LS = 1.;
0708   float PixelRate_LS = 1.;
0709   MonitorElement *me = iGetter.get("Pixel/AdditionalPixelErrors/byLumiErrors");
0710   if (me) {
0711     double nBarrelErrors_LS = me->getBinContent(1) - nErrorsBarrel_lastLS_;
0712     double nEndcapErrors_LS = me->getBinContent(2) - nErrorsEndcap_lastLS_;
0713     double nEvents_LS = me->getBinContent(0) - nEvents_lastLS_;
0714     if (nBarrelErrors_LS / nEvents_LS > 0.5)
0715       BarrelRate_LS = 0.;
0716     if (nEndcapErrors_LS / nEvents_LS > 0.5)
0717       EndcapRate_LS = 0.;
0718     if ((nBarrelErrors_LS + nEndcapErrors_LS) / nEvents_LS > 0.5)
0719       PixelRate_LS = 0.;
0720   }
0721 
0722   // evaluate mean cluster charge on tracks for data quality:
0723   float BarrelClusterCharge = 1.;
0724   float EndcapClusterCharge = 1.;
0725   float PixelClusterCharge = 1.;
0726   MonitorElement *me1 = iGetter.get("Pixel/Clusters/OnTrack/charge_siPixelClusters_Barrel");
0727   if (me1 && me1->getMean() < 12.)
0728     BarrelClusterCharge = 0.;
0729   MonitorElement *me2 = iGetter.get("Pixel/Clusters/OnTrack/charge_siPixelClusters_Endcap");
0730   if (me2 && me2->getMean() < 12.)
0731     EndcapClusterCharge = 0.;
0732   MonitorElement *me3 = iGetter.get("Pixel/Clusters/OnTrack/charge_siPixelClusters");
0733   if (me3 && me3->getMean() < 12.)
0734     PixelClusterCharge = 0.;
0735 
0736   // evaluate average FED occupancy for data quality:
0737   float BarrelOccupancy = 1.;
0738   float EndcapOccupancy = 1.;
0739   float PixelOccupancy = 1.;
0740   MonitorElement *me4 = iGetter.get("Pixel/averageDigiOccupancy");
0741   if (me4) {
0742     double minBarrelOcc = 999999.;
0743     double maxBarrelOcc = -1.;
0744     double meanBarrelOcc = 0.;
0745     double minEndcapOcc = 999999.;
0746     double maxEndcapOcc = -1.;
0747     double meanEndcapOcc = 0.;
0748     for (int i = 1; i != 41; i++) {
0749       if (i <= 32 && me4->getBinContent(i) < minBarrelOcc)
0750         minBarrelOcc = me4->getBinContent(i);
0751       if (i <= 32 && me4->getBinContent(i) > maxBarrelOcc)
0752         maxBarrelOcc = me4->getBinContent(i);
0753       if (i <= 32)
0754         meanBarrelOcc += me4->getBinContent(i);
0755       if (i > 32 && me4->getBinContent(i) < minEndcapOcc)
0756         minEndcapOcc = me4->getBinContent(i);
0757       if (i > 32 && me4->getBinContent(i) > maxEndcapOcc)
0758         maxEndcapOcc = me4->getBinContent(i);
0759       if (i > 32)
0760         meanEndcapOcc += me4->getBinContent(i);
0761     }
0762     meanBarrelOcc = meanBarrelOcc / 32.;
0763     meanEndcapOcc = meanEndcapOcc / 8.;
0764     if (minBarrelOcc < 0.1 * meanBarrelOcc || maxBarrelOcc > 2.5 * meanBarrelOcc)
0765       BarrelOccupancy = 0.;
0766     if (minEndcapOcc < 0.2 * meanEndcapOcc || maxEndcapOcc > 1.8 * meanEndcapOcc)
0767       EndcapOccupancy = 0.;
0768     PixelOccupancy = BarrelOccupancy * EndcapOccupancy;
0769   }
0770 
0771   float pixelFlag = PixelRate_LS * PixelClusterCharge * PixelOccupancy;
0772   float barrelFlag = BarrelRate_LS * BarrelClusterCharge * BarrelOccupancy;
0773   float endcapFlag = EndcapRate_LS * EndcapClusterCharge * EndcapOccupancy;
0774   SummaryPixel = iGetter.get("Pixel/EventInfo/reportSummary");
0775   if (SummaryPixel)
0776     SummaryPixel->Fill(pixelFlag);
0777   SummaryBarrel = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelBarrelFraction");
0778   if (SummaryBarrel)
0779     SummaryBarrel->Fill(barrelFlag);
0780   SummaryEndcap = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelEndcapFraction");
0781   if (SummaryEndcap)
0782     SummaryEndcap->Fill(endcapFlag);
0783 }
0784 
0785 //**********************************************************************************************
0786 
0787 void SiPixelDataQuality::fillGlobalQualityPlot(DQMStore::IBooker &iBooker,
0788                                                DQMStore::IGetter &iGetter,
0789                                                bool init,
0790                                                const SiPixelFedCablingMap *theCablingMap,
0791                                                int nFEDs,
0792                                                bool Tier0Flag,
0793                                                int lumisec) {
0794   // std::cout<<"Entering SiPixelDataQuality::fillGlobalQualityPlot:
0795   // "<<nFEDs<<std::endl;
0796   if (init) {
0797     count = 0;
0798     errcount = 0;
0799     count1 = 0;
0800     count2 = 0;
0801     count3 = 0;
0802     count4 = 0;
0803     count5 = 0;
0804     count6 = 0;
0805     modCounter_ = 0;
0806     if (!Tier0Flag) {
0807       // The plots that these Vecs are integrated throughout a run
0808       // So at each lumi section I save their last values (lastmods)
0809       // And then subtract them out later when filling the SummaryMap
0810       for (int j = 1; j != 41; j++) {
0811         if (allmodsVec)
0812           lastallmods_[j - 1] = allmodsVec->GetBinContent(j);
0813         if (errmodsVec)
0814           lasterrmods_[j - 1] = errmodsVec->GetBinContent(j);
0815         if (allmodsVec)
0816           allmodsVec->SetBinContent(j, 0.);
0817         if (errmodsVec)
0818           errmodsVec->SetBinContent(j, 0.);
0819         if (goodmodsVec)
0820           goodmodsVec->SetBinContent(j, 0.);
0821       }
0822     }
0823     if (Tier0Flag) {
0824       for (int i = 1; i != 3; i++)
0825         for (int j = 1; j != 8; j++) {
0826           if (allmodsMap)
0827             allmodsMap->SetBinContent(i, j, 0.);
0828           if (errmodsMap)
0829             errmodsMap->SetBinContent(i, j, 0.);
0830           if (goodmodsMap)
0831             goodmodsMap->SetBinContent(i, j, 0.);
0832         }
0833     }
0834   }
0835 
0836   //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
0837   // Fill Maps:
0838   // Online:
0839   if (nFEDs == 0)
0840     return;
0841 
0842   if (!Tier0Flag) {
0843     // Not elegant, but not sure where else to put this sweet new plot!
0844     MonitorElement *meTmp = iGetter.get("Pixel/Barrel/NClustertoChargeRatio_AllMod");
0845     MonitorElement *meTop = iGetter.get("Pixel/Barrel/SUMCLU_nclusters_Barrel");
0846     MonitorElement *meBot = iGetter.get("Pixel/Barrel/SUMCLU_charge_Barrel");
0847     if (meTop && meBot && meTmp) {
0848       for (int bin = 1; bin < 769; ++bin) {
0849         float content = 0.0;
0850         if (meBot->getBinContent(bin) > 0.0) {
0851           content = meTop->getBinContent(bin) / meBot->getBinContent(bin);
0852         }
0853         meTmp->setBinContent(bin, content);
0854       }
0855       for (int j = 0; j < 4; ++j) {
0856         static const char buf[] = "Pixel/Barrel/NClustertoChargeRatio_NormMod%i";
0857         char modplot[sizeof(buf) + 16];
0858         sprintf(modplot, buf, j + 1);
0859         MonitorElement *meFinal = iGetter.get(modplot);
0860         if (!meFinal)
0861           continue;
0862         for (int i = 1; i < 769; ++i) {
0863           int k = 3 - j;
0864           if (int(i + k) % 4 == 0)
0865             meFinal->setBinContent(int((i + k) / 4), meTmp->getBinContent(i));
0866         }
0867         // Filling done. Now modification.
0868         float SFLay[3], TotLay[3];
0869         for (int ll = 0; ll < 3; ++ll)
0870           TotLay[ll] = 0.0;
0871         for (int bin = 1; bin < (meFinal->getNbinsX() + 1); ++bin) {
0872           int layer = int((bin % 48) / 16);
0873           TotLay[layer] += meFinal->getBinContent(bin);
0874         }
0875         float laynorm = TotLay[1] / 64.;
0876         for (int ll = 0; ll < 3; ++ll) {
0877           SFLay[ll] = 0.0;
0878           if (TotLay[ll] > 0.0 && TotLay[1] > 0.0)
0879             SFLay[ll] = TotLay[1] / TotLay[ll] * (1. / laynorm);
0880         }
0881         // now loop through plot
0882         for (int bin = 1; bin < (meFinal->getNbinsX() + 1); ++bin) {
0883           // access the layer number for bin: int((i%48)/16)
0884           int layer = int((bin % 48) / 16);
0885           float content = meFinal->getBinContent(bin);
0886           // apply scale factor to bin content
0887           meFinal->setBinContent(bin, content * SFLay[layer]);
0888         }
0889       }
0890     }
0891 
0892     string currDir = iBooker.pwd();
0893     if (currDir.find("Reference") != string::npos || currDir.find("Additional") != string::npos)
0894       return;
0895     string dname = currDir.substr(currDir.find_last_of('/') + 1);
0896     if (dname.find("Module_") != string::npos && currDir.find("Reference") == string::npos) {
0897       vector<string> meVec = iGetter.getMEs();
0898       int detId = -1;
0899       int fedId = -1;
0900       for (vector<string>::const_iterator it = meVec.begin(); it != meVec.end();
0901            it++) {  // loop over all modules and fill ndigis into allmodsMap
0902         // checking for any digis or FED errors to decide if this module is in
0903         // DAQ:
0904         string full_path = currDir + "/" + (*it);
0905         if (detId == -1 && full_path.find("SUMOFF") == string::npos &&
0906             (full_path.find("ndigis") != string::npos && full_path.find("SUMDIG") == string::npos) &&
0907             (getDetId(iGetter.get(full_path)) > 100)) {
0908           MonitorElement *me = iGetter.get(full_path);
0909           if (!me)
0910             continue;
0911           if ((full_path.find("ndigis") != string::npos)) {
0912             modCounter_++;
0913             detId = getDetId(me);
0914             for (int fedid = 0; fedid != 40; ++fedid) {
0915               SiPixelFrameConverter converter(theCablingMap, fedid);
0916               uint32_t newDetId = detId;
0917               if (converter.hasDetUnit(newDetId)) {
0918                 fedId = fedid;
0919                 break;
0920               }
0921             }
0922             double NDigis = 0;
0923             if (full_path.find("ndigis") != string::npos)
0924               NDigis = me->getEntries();
0925             float weight = (allmodsVec->GetBinContent(fedId + 1)) + NDigis;
0926             allmodsVec->SetBinContent(fedId + 1, weight);
0927           }
0928         }
0929       }  // end loop over MEs
0930     }  // end of module dir's
0931     vector<string> subDirVec = iGetter.getSubdirs();
0932     for (vector<string>::const_iterator ic = subDirVec.begin(); ic != subDirVec.end(); ic++) {
0933       iBooker.cd(*ic);
0934       iGetter.cd(*ic);
0935       init = false;
0936       fillGlobalQualityPlot(iBooker, iGetter, init, theCablingMap, nFEDs, Tier0Flag, lumisec);
0937       iBooker.goUp();
0938       iGetter.setCurrentFolder(iBooker.pwd());
0939     }
0940     if (modCounter_ == 1440) {
0941       iBooker.cd("Pixel/EventInfo/reportSummaryContents");
0942       iGetter.cd("Pixel/EventInfo/reportSummaryContents");
0943       if (iBooker.pwd() == "Pixel/EventInfo/reportSummaryContents") {
0944         for (int i = 0; i != 40; i++) {  // loop over FEDs to fetch the errors
0945           static const char buf[] = "Pixel/AdditionalPixelErrors/FED_%d/FedChNErr";
0946           char fedplot[sizeof(buf) + 4];
0947           int NErrors = 0;
0948           for (int j = 0; j != 37; j++) {  // loop over FED channels within a FED
0949             sprintf(fedplot, buf, i);
0950             MonitorElement *me = iGetter.get(fedplot);
0951             if (me)
0952               NErrors = NErrors + me->getBinContent(j + 1);
0953           }
0954           // If I fill, then I end up majorly overcounting the numbers of
0955           // errors...
0956           if (NErrors > 0) {
0957             errmodsVec->SetBinContent(i + 1, NErrors);
0958           }
0959         }
0960         SummaryReportMap = iGetter.get("Pixel/EventInfo/reportSummaryMap");
0961         if (SummaryReportMap) {
0962           float contents = 0.;
0963           for (int i = 1; i != 41; i++) {
0964             // Dynamically subtracting previous (integrated) lumi section values
0965             // in order to only show current lumi section's numbers
0966             float mydigis = allmodsVec->GetBinContent(i) - lastallmods_[i - 1];
0967             float myerrs = errmodsVec->GetBinContent(i) - lasterrmods_[i - 1];
0968             if ((mydigis + myerrs) > 0.) {
0969               contents = mydigis / (mydigis + myerrs);
0970             } else {
0971               // Changed so that dynamic zooming will still
0972               // advance over these bins(in renderplugins)
0973               contents = -0.5;
0974             }
0975             SummaryReportMap->setBinContent(lumisec + 1, i, contents);
0976           }  // end for loop over summaryReportMap bins
0977         }  // end if reportSummaryMap ME exists
0978       }  // end if in summary directory
0979     }  // end if modCounter_
0980   } else {  // Offline
0981     float barrel_errors_temp[1] = {-1.};
0982     int barrel_cuts_temp[6] = {6 * -1};
0983     float endcap_errors_temp[1] = {-1.};
0984     int endcap_cuts_temp[6] = {6 * -1};
0985     int pixel_cuts_temp[1] = {-1};
0986     // Barrel results:
0987     MonitorElement *me;
0988     me = iGetter.get("Pixel/Barrel/BarrelNErrorsCut");
0989     if (me)
0990       barrel_errors_temp[0] = me->getFloatValue();
0991     me = iGetter.get("Pixel/Endcap/EndcapNErrorsCut");
0992     if (me)
0993       endcap_errors_temp[0] = me->getFloatValue();
0994     SummaryReportMap->setBinContent(1, 1, barrel_errors_temp[0]);
0995     SummaryReportMap->setBinContent(2, 1, endcap_errors_temp[0]);
0996     me = iGetter.get("Pixel/Barrel/BarrelNDigisCut");
0997     if (me)
0998       barrel_cuts_temp[0] = me->getIntValue();
0999     me = iGetter.get("Pixel/Barrel/BarrelDigiChargeCut");
1000     if (me)
1001       barrel_cuts_temp[1] = me->getIntValue();
1002     me = iGetter.get("Pixel/Barrel/BarrelClusterSizeCut");
1003     if (me)
1004       barrel_cuts_temp[2] = me->getIntValue();
1005     me = iGetter.get("Pixel/Barrel/BarrelNClustersCut");
1006     if (me)
1007       barrel_cuts_temp[3] = me->getIntValue();
1008     me = iGetter.get("Pixel/Barrel/BarrelClusterChargeCut");
1009     if (me)
1010       barrel_cuts_temp[4] = me->getIntValue();
1011     me = iGetter.get("Pixel/Endcap/EndcapNDigisCut");
1012     if (me)
1013       endcap_cuts_temp[0] = me->getIntValue();
1014     me = iGetter.get("Pixel/Endcap/EndcapDigiChargeCut");
1015     if (me)
1016       endcap_cuts_temp[1] = me->getIntValue();
1017     me = iGetter.get("Pixel/Endcap/EndcapClusterSizeCut");
1018     if (me)
1019       endcap_cuts_temp[2] = me->getIntValue();
1020     me = iGetter.get("Pixel/Endcap/EndcapNClustersCut");
1021     if (me)
1022       endcap_cuts_temp[3] = me->getIntValue();
1023     me = iGetter.get("Pixel/Endcap/EndcapClusterChargeCut");
1024     if (me)
1025       endcap_cuts_temp[4] = me->getIntValue();
1026     for (int j = 2; j != 7; j++) {
1027       SummaryReportMap->setBinContent(1, j, barrel_cuts_temp[j - 2]);
1028       SummaryReportMap->setBinContent(2, j, endcap_cuts_temp[j - 2]);
1029     }
1030     me = iGetter.get("Pixel/Tracks/PixelTracksCut");
1031     if (me)
1032       pixel_cuts_temp[0] = me->getIntValue();
1033     SummaryReportMap->setBinContent(1, 7, pixel_cuts_temp[0]);
1034     SummaryReportMap->setBinContent(2, 7, pixel_cuts_temp[0]);
1035   }  // end of offline map
1036   if (allmodsMap)
1037     allmodsMap->Clear();
1038   if (goodmodsMap)
1039     goodmodsMap->Clear();
1040   if (errmodsMap)
1041     errmodsMap->Clear();
1042 }
1043 
1044 //**********************************************************************************************
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!