SiPixelDataQuality.cc

Go to the documentation of this file.

#include "DQM/SiPixelMonitorClient/interface/SiPixelDataQuality.h"
#include "DQM/SiPixelMonitorClient/interface/SiPixelUtility.h"
#include "DQM/SiPixelMonitorClient/interface/SiPixelEDAClient.h"
#include "DQM/SiPixelMonitorClient/interface/ANSIColors.h"
#include "DQM/SiPixelCommon/interface/SiPixelFolderOrganizer.h"

#include "DQMServices/Core/interface/DQMStore.h"
#include "DQMServices/Core/interface/MonitorElement.h"

#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/GeometrySurface/interface/Surface.h"
#include "DataFormats/SiPixelDetId/interface/PixelBarrelName.h"
#include "DataFormats/SiPixelDetId/interface/PixelEndcapName.h"
#include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"

#include "CondFormats/SiPixelObjects/interface/DetectorIndex.h"
#include "CondFormats/SiPixelObjects/interface/SiPixelFrameConverter.h"

#include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h"
#include "Geometry/CommonTopologies/interface/PixelTopology.h"

#include "TClass.h"
#include "TText.h"
#include "TROOT.h"
#include "TPad.h"
#include "TStyle.h"
#include "TSystem.h"
#include "TString.h"
#include "TImage.h"
#include "TPaveText.h"
#include "TImageDump.h"
#include "TRandom.h"
#include "TStopwatch.h"
#include "TAxis.h"
#include "TPaveLabel.h"
#include "Rtypes.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TProfile.h"

#include <iostream>
#include <math.h>
#include <map>

#include <fstream>
#include <cstdlib> // for free() - Root can allocate with malloc() - sigh...
 
using namespace std;
using namespace edm;

//------------------------------------------------------------------------------
SiPixelDataQuality::SiPixelDataQuality(bool offlineXMLfile) : offlineXMLfile_(offlineXMLfile) {
  edm::LogInfo("SiPixelDataQuality") << 
    " Creating SiPixelDataQuality " << "\n" ;
  
  allMods_=0;
  errorMods_=0;
  qflag_=1.;

  allmodsMap=0;
  errmodsMap=0;
  goodmodsMap=0;
  allmodsVec=0;
  errmodsVec=0;
  goodmodsVec=0;
  for (int i = 0; i < 40; ++i)
    {lastallmods_[i] = 0; lasterrmods_[i] = 0;}
  timeoutCounter_=0;
  lastLS_=-1;
}

//------------------------------------------------------------------------------
SiPixelDataQuality::~SiPixelDataQuality() {
  edm::LogInfo("SiPixelDataQuality") << 
    " Deleting SiPixelDataQuality " << "\n" ;
  if(allmodsMap) delete allmodsMap;
  if(errmodsMap) delete errmodsMap;
  if(goodmodsMap) delete goodmodsMap;
  if(allmodsVec) delete allmodsVec;
  if(errmodsVec) delete errmodsVec;
  if(goodmodsVec) delete goodmodsVec;
}


//------------------------------------------------------------------------------
int SiPixelDataQuality::getDetId(MonitorElement * mE) 
{
 string mEName = mE->getName() ;

 int detId = 0;
 
 if( mEName.find("_3") != string::npos )
 {
  string detIdString = mEName.substr((mEName.find_last_of("_"))+1,9);
  std::istringstream isst;
  isst.str(detIdString);
  isst>>detId;
 }
      
  return detId ;
  
}


void SiPixelDataQuality::bookGlobalQualityFlag(DQMStore::IBooker & iBooker, bool Tier0Flag, int nFEDs) {
//std::cout<<"BOOK GLOBAL QUALITY FLAG MEs!"<<std::endl;
  iBooker.cd();

  iBooker.setCurrentFolder("Pixel/Barrel");
  if(!Tier0Flag){
    ClusterModAll = iBooker.book1D("NClustertoChargeRatio_AllMod","Cluster Noise All Modules", 768, 0., 768.);
    ClusterMod1   = iBooker.book1D("NClustertoChargeRatio_NormMod1",  "Normalized N_{Clusters} to Charge Ratio per Module1", 192, 0., 192.);
    ClusterMod2   = iBooker.book1D("NClustertoChargeRatio_NormMod2",  "Normalized N_{Clusters} to Charge Ratio per Module2", 192, 0., 192.);
    ClusterMod3   = iBooker.book1D("NClustertoChargeRatio_NormMod3",  "Normalized N_{Clusters} to Charge Ratio per Module3", 192, 0., 192.);
    ClusterMod4   = iBooker.book1D("NClustertoChargeRatio_NormMod4",  "Normalized N_{Clusters} to Charge Ratio per Module4", 192, 0., 192.);
  } 
  iBooker.setCurrentFolder("Pixel/EventInfo");
  if(!Tier0Flag){
    SummaryReportMap = iBooker.book2D("reportSummaryMap","Pixel Summary Map",3000,0.,3000.,40,0.,40.);
    SummaryReportMap->setAxisTitle("Lumi Section",1);
    SummaryReportMap->setAxisTitle("Pixel FED #",2);
    allmodsVec = new TH1D("allmodsVec","allmodsVec",40,0.,40.);
    errmodsVec = new TH1D("errmodsVec","errmodsVec",40,0.,40.);
    goodmodsVec = new TH1D("goodmodsVec","goodmodsVec",40,0.,40.);
  }else{
    SummaryReportMap = iBooker.book2D("reportSummaryMap","Pixel Summary Map",2,0.,2.,7,0.,7.);
    SummaryReportMap->setBinLabel(1,"Barrel",1);
    SummaryReportMap->setBinLabel(2,"Endcaps",1);
    SummaryReportMap->setBinLabel(1,"Errors",2);
    SummaryReportMap->setBinLabel(2,"NDigis",2);
    SummaryReportMap->setBinLabel(3,"DigiCharge",2);
    SummaryReportMap->setBinLabel(4,"ClusterSize",2);
    SummaryReportMap->setBinLabel(5,"NClusters",2);
    SummaryReportMap->setBinLabel(6,"ClusterCharge",2);
    SummaryReportMap->setBinLabel(7,"HitEff",2);
    allmodsMap = new TH2F("allmodsMap","allmodsMap",2,0.,2.,7,0.,7.);
    errmodsMap = new TH2F("errmodsMap","errmodsMap",2,0.,2.,7,0.,7.);
    goodmodsMap = new TH2F("goodmodsMap","goodmodsMap",2,0.,2.,7,0.,7.);
  }  
    SummaryPixel = iBooker.bookFloat("reportSummary");
  iBooker.setCurrentFolder("Pixel/EventInfo/reportSummaryContents");
    SummaryBarrel = iBooker.bookFloat("PixelBarrelFraction");
    SummaryEndcap = iBooker.bookFloat("PixelEndcapFraction");
  // book the data certification cuts:
  iBooker.setCurrentFolder("Pixel/AdditionalPixelErrors");
    NErrorsFEDs = iBooker.bookFloat("FEDsNErrorsCut");
  iBooker.setCurrentFolder("Pixel/Barrel");
    NErrorsBarrel = iBooker.bookFloat("BarrelNErrorsCut");
    NDigisBarrel = iBooker.bookInt("BarrelNDigisCut");
    DigiChargeBarrel = iBooker.bookInt("BarrelDigiChargeCut");
    ClusterSizeBarrel = iBooker.bookInt("BarrelClusterSizeCut");
    NClustersBarrel = iBooker.bookInt("BarrelNClustersCut");
    ClusterChargeBarrel = iBooker.bookInt("BarrelClusterChargeCut");
  iBooker.setCurrentFolder("Pixel/Endcap");
    NErrorsEndcap = iBooker.bookFloat("EndcapNErrorsCut");
    NDigisEndcap = iBooker.bookInt("EndcapNDigisCut");
    DigiChargeEndcap = iBooker.bookInt("EndcapDigiChargeCut");
    ClusterSizeEndcap = iBooker.bookInt("EndcapClusterSizeCut");
    NClustersEndcap = iBooker.bookInt("EndcapNClustersCut");
    ClusterChargeEndcap = iBooker.bookInt("EndcapClusterChargeCut");
  if(Tier0Flag){
    iBooker.setCurrentFolder("Pixel/Tracks");
      NPixelTracks = iBooker.bookInt("PixelTracksCut");
  }
    
    // Init MonitoringElements:
    if(nFEDs>0){
      if(SummaryPixel) SummaryPixel->Fill(1.);
      if(SummaryBarrel) SummaryBarrel->Fill(1.);
      if(SummaryEndcap) SummaryEndcap->Fill(1.);
    }else{
      if(SummaryPixel) SummaryPixel->Fill(-1.);
      if(SummaryBarrel) SummaryBarrel->Fill(-1.);
      if(SummaryEndcap) SummaryEndcap->Fill(-1.);
    }
    if(NErrorsBarrel) NErrorsBarrel->Fill(1.);
    if(NErrorsEndcap) NErrorsEndcap->Fill(1.);
    if(NErrorsFEDs) NErrorsFEDs->Fill(1.);
    if(NDigisBarrel) NDigisBarrel->Fill(1);
    if(NDigisEndcap) NDigisEndcap->Fill(1);
    if(DigiChargeBarrel) DigiChargeBarrel->Fill(1);
    if(DigiChargeEndcap) DigiChargeEndcap->Fill(1);
    if(ClusterSizeBarrel) ClusterSizeBarrel->Fill(1);
    if(ClusterSizeEndcap) ClusterSizeEndcap->Fill(1);
    if(ClusterChargeBarrel) ClusterChargeBarrel->Fill(1);
    if(ClusterChargeEndcap) ClusterChargeEndcap->Fill(1);
    if(NClustersBarrel) NClustersBarrel->Fill(1);
    if(NClustersEndcap) NClustersEndcap->Fill(1);
    if(Tier0Flag){
      if(NPixelTracks) NPixelTracks->Fill(1);
    }
   
    if(SummaryReportMap){
      if(!Tier0Flag) for(int i=1; i!=3001; i++) for(int j=1; j!=41; j++) SummaryReportMap->setBinContent(i,j,-1.);
      if(Tier0Flag) for(int i=1; i!=3; i++) for(int j=1; j!=8; j++) SummaryReportMap->setBinContent(i,j,-1.);
    }
    if(!Tier0Flag){
      for(int j=1; j!=41; j++){
        if(allmodsVec) allmodsVec->SetBinContent(j,0.);
        if(errmodsVec) errmodsVec->SetBinContent(j,0.);
        if(goodmodsVec) goodmodsVec->SetBinContent(j,0.);
      }
    }
    if(Tier0Flag){
      for(int i=1; i!=3; i++) for(int j=1; j!=8; j++){
        if(allmodsMap) allmodsMap->SetBinContent(i,j,0.);
        if(errmodsMap) errmodsMap->SetBinContent(i,j,0.);
        if(goodmodsMap) goodmodsMap->SetBinContent(i,j,0.);
      }
    }
    
  iBooker.cd();  
}

//**********************************************************************************************

void SiPixelDataQuality::computeGlobalQualityFlag(DQMStore::IBooker & iBooker,
                          DQMStore::IGetter & iGetter,
                          bool init,
                          int nFEDs,
                          bool Tier0Flag){
  if(init){
    allMods_=0; errorMods_=0; qflag_=0.; 
    barrelMods_=0; endcapMods_=0;
    objectCount_=0;
    DONE_ = false;
    
    //Error counters and flags:
    n_errors_barrel_=0; barrel_error_flag_=0.;
    n_errors_endcap_=0; endcap_error_flag_=0.;
    n_errors_pixel_=0; pixel_error_flag_=0.;
    digiStatsBarrel = false, clusterStatsBarrel = false, trackStatsBarrel = false;
    digiCounterBarrel = 0, clusterCounterBarrel = 0, trackCounterBarrel = 0;
    digiStatsEndcap = false, clusterStatsEndcap = false, trackStatsEndcap = false;
    digiCounterEndcap = 0, clusterCounterEndcap = 0, trackCounterEndcap = 0;
    init=false;
  }
  if(nFEDs==0) return;  
  
  string currDir = iBooker.pwd();
  string dname = currDir.substr(currDir.find_last_of("/")+1);
  
  if((!Tier0Flag && dname.find("Module_")!=string::npos) || 
     (Tier0Flag && (dname.find("Ladder_")!=string::npos || dname.find("Blade_")!=string::npos))){

    objectCount_++;

    if(currDir.find("Pixel")!=string::npos) allMods_++;
    if(currDir.find("Barrel")!=string::npos) barrelMods_++;
    if(currDir.find("Endcap")!=string::npos) endcapMods_++;
    vector<string> meVec = iGetter.getMEs();
    for (vector<string>::const_iterator it = meVec.begin(); it != meVec.end(); it++) {
      string full_path = currDir + "/" + (*it);
      if(full_path.find("ndigis_")!=string::npos){
        MonitorElement * me = iGetter.get(full_path);
        if(!me) continue;
        if(me->getEntries()>25){
      if(full_path.find("Barrel")!=string::npos) digiCounterBarrel++;
      if(full_path.find("Endcap")!=string::npos) digiCounterEndcap++;
        }
      }else if(Tier0Flag && full_path.find("nclusters_OnTrack_")!=string::npos){
        MonitorElement * me = iGetter.get(full_path);
        if(!me) continue;
        if(me->getEntries()>25){
      if(full_path.find("Barrel")!=string::npos) clusterCounterBarrel++;
      if(full_path.find("Endcap")!=string::npos) clusterCounterEndcap++;
        }
      }else if(!Tier0Flag && full_path.find("nclusters_")!=string::npos){
        MonitorElement * me = iGetter.get(full_path);
        if(!me) continue;
        if(me->getEntries()>25){
      if(full_path.find("Barrel")!=string::npos) clusterCounterBarrel++;
      if(full_path.find("Endcap")!=string::npos) clusterCounterEndcap++;
        }
      }
    }
  }
  vector<string> subDirVec = iGetter.getSubdirs();  
  for (vector<string>::const_iterator ic = subDirVec.begin();
       ic != subDirVec.end(); ic++) {
    iGetter.cd(*ic);
    iBooker.cd(*ic);
    init=false;
    computeGlobalQualityFlag(iBooker,iGetter,init,nFEDs,Tier0Flag);
    iBooker.goUp();
    iGetter.setCurrentFolder(iBooker.pwd());
  }
  
  // Make sure I have finished looping over all Modules/Ladders/Blades:
  if(!Tier0Flag){ // online case
    if(objectCount_ == 1440) DONE_ = true;
  }else{ // offline case
    if(objectCount_ == 288) DONE_ = true;
  } 
  
  if(DONE_ && currDir=="Pixel/EventInfo/reportSummaryContents"){ 

  // Evaluate error flag now, only stored in AdditionalPixelErrors:
  MonitorElement * me_err = iGetter.get("Pixel/AdditionalPixelErrors/FedETypeNErr");
  MonitorElement * me_evt = iGetter.get("Pixel/EventInfo/processedEvents");
  if(me_err && me_evt){
    for(int i=1; i!=41; i++)for(int j=1; j!=22; j++)
      if(me_err->getBinContent(i,j)>0){
        n_errors_pixel_=n_errors_pixel_+int(me_err->getBinContent(i,j));
        if(i<33) n_errors_barrel_=n_errors_barrel_+int(me_err->getBinContent(i,j));
        if(i>32) n_errors_endcap_=n_errors_endcap_+int(me_err->getBinContent(i,j));
      }
    int NProcEvts = me_evt->getIntValue();
    if(NProcEvts>0){
      barrel_error_flag_ = (float(NProcEvts)-float(n_errors_barrel_))/float(NProcEvts);
      endcap_error_flag_ = (float(NProcEvts)-float(n_errors_endcap_))/float(NProcEvts);
      pixel_error_flag_ = (float(NProcEvts)-float(n_errors_barrel_)-float(n_errors_endcap_))/float(NProcEvts);
    }
  }
  NErrorsBarrel = iGetter.get("Pixel/Barrel/BarrelNErrorsCut");
  if(NErrorsBarrel) NErrorsBarrel->Fill(barrel_error_flag_);
  NErrorsEndcap = iGetter.get("Pixel/Endcap/EndcapNErrorsCut");
  if(NErrorsEndcap)   NErrorsEndcap->Fill(endcap_error_flag_);
  
  string meName0;
  MonitorElement * me;
  
  // Fill the Digi flags:
  if(!Tier0Flag){
    meName0 = "Pixel/Barrel/SUMDIG_ndigis_Barrel";
    if(digiCounterBarrel/768 > 0.5) digiStatsBarrel = true;
    if(digiCounterEndcap/672 > 0.5) digiStatsEndcap = true;
  }else{
    meName0 = "Pixel/Barrel/SUMOFF_ndigis_Barrel"; 
    if(digiCounterBarrel/192 > 0.5) digiStatsBarrel = true;
    if(digiCounterEndcap/96 > 0.5) digiStatsEndcap = true;
  }
  me = iGetter.get(meName0);
  if(me){
    NDigisBarrel = iGetter.get("Pixel/Barrel/BarrelNDigisCut");
    if(NDigisBarrel && digiStatsBarrel){
      if(me->hasError()) NDigisBarrel->Fill(0);
      else NDigisBarrel->Fill(1); 
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Endcap/SUMDIG_ndigis_Endcap";
  else meName0 = "Pixel/Endcap/SUMOFF_ndigis_Endcap"; 
  me = iGetter.get(meName0);
  if(me){
    NDigisEndcap = iGetter.get("Pixel/Endcap/EndcapNDigisCut");
    if(NDigisEndcap && digiStatsEndcap){
      if(me->hasError()) NDigisEndcap->Fill(0);
      else NDigisEndcap->Fill(1);
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Barrel/SUMDIG_adc_Barrel";
  else meName0 = "Pixel/Barrel/SUMOFF_adc_Barrel"; 
  me = iGetter.get(meName0);
  if(me){
    DigiChargeBarrel = iGetter.get("Pixel/Barrel/BarrelDigiChargeCut");
    if(DigiChargeBarrel && digiStatsBarrel){
      if(me->hasError()) DigiChargeBarrel->Fill(0);
      else DigiChargeBarrel->Fill(1);
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Endcap/SUMDIG_adc_Endcap";
  else meName0 = "Pixel/Endcap/SUMOFF_adc_Endcap"; 
  me = iGetter.get(meName0);
  if(me){
    DigiChargeEndcap = iGetter.get("Pixel/Endcap/EndcapDigiChargeCut");
    if(DigiChargeEndcap && digiStatsEndcap){
      if(me->hasError()) DigiChargeEndcap->Fill(0);
      else DigiChargeEndcap->Fill(1);
    }
  }
     
     
    // Fill the Cluster flags:
  if(!Tier0Flag){
    meName0 = "Pixel/Barrel/SUMCLU_size_Barrel";
    if(clusterCounterBarrel/768 > 0.5) clusterStatsBarrel = true;
    if(clusterCounterEndcap/672 > 0.5) clusterStatsEndcap = true;
  }else{
    meName0 = "Pixel/Barrel/SUMOFF_size_OnTrack_Barrel"; 
    if(clusterCounterBarrel/192 > 0.5) clusterStatsBarrel = true;
    if(clusterCounterEndcap/96 > 0.5) clusterStatsEndcap = true;
  }
  me = iGetter.get(meName0);
  if(me){
    ClusterSizeBarrel = iGetter.get("Pixel/Barrel/BarrelClusterSizeCut");
    if(ClusterSizeBarrel && clusterStatsBarrel){
      if(me->hasError()) ClusterSizeBarrel->Fill(0);
      else ClusterSizeBarrel->Fill(1);
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Endcap/SUMCLU_size_Endcap";
  else meName0 = "Pixel/Endcap/SUMOFF_size_OnTrack_Endcap"; 
  me = iGetter.get(meName0);
  if(me){
    ClusterSizeEndcap = iGetter.get("Pixel/Endcap/EndcapClusterSizeCut");
    if(ClusterSizeEndcap && clusterStatsEndcap){
      if(me->hasError()) ClusterSizeEndcap->Fill(0);
      else ClusterSizeEndcap->Fill(1);
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Barrel/SUMCLU_charge_Barrel";
  else meName0 = "Pixel/Barrel/SUMOFF_charge_OnTrack_Barrel"; 
  me = iGetter.get(meName0);
  if(me){
    ClusterChargeBarrel = iGetter.get("Pixel/Barrel/BarrelClusterChargeCut");
    if(ClusterChargeBarrel && clusterStatsBarrel){
      if(me->hasError()) ClusterChargeBarrel->Fill(0);
      else ClusterChargeBarrel->Fill(1);
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Endcap/SUMCLU_charge_Endcap";
  else meName0 = "Pixel/Endcap/SUMOFF_charge_OnTrack_Endcap"; 
  me = iGetter.get(meName0);
  if(me){
    ClusterChargeEndcap = iGetter.get("Pixel/Endcap/EndcapClusterChargeCut");
    if(ClusterChargeEndcap && clusterStatsEndcap){
      if(me->hasError()) ClusterChargeEndcap->Fill(0);
      else ClusterChargeEndcap->Fill(1);
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Barrel/SUMCLU_nclusters_Barrel";
  else meName0 = "Pixel/Barrel/SUMOFF_nclusters_OnTrack_Barrel"; 
  me = iGetter.get(meName0);
  if(me){
    NClustersBarrel = iGetter.get("Pixel/Barrel/BarrelNClustersCut");
    if(NClustersBarrel && clusterStatsBarrel){
      if(me->hasError()) NClustersBarrel->Fill(0);
      else NClustersBarrel->Fill(1);
    }
  }
  if(!Tier0Flag) meName0 = "Pixel/Endcap/SUMCLU_nclusters_Endcap";
  else meName0 = "Pixel/Endcap/SUMOFF_nclusters_OnTrack_Endcap"; 
  me = iGetter.get(meName0);
  if(me){
    NClustersEndcap = iGetter.get("Pixel/Endcap/EndcapNClustersCut");
    if(NClustersEndcap && clusterStatsEndcap){
      if(me->hasError()) NClustersEndcap->Fill(0);
      else NClustersEndcap->Fill(1);
    }
  }
  // Pixel Track multiplicity / Pixel hit efficiency
  meName0 = "Pixel/Tracks/ntracks_generalTracks";
  me = iGetter.get(meName0);
  if(me){
    NPixelTracks = iGetter.get("Pixel/Tracks/PixelTracksCut");
    if(NPixelTracks && me->getBinContent(1)>1000){
      if((float)me->getBinContent(2)/(float)me->getBinContent(1)<0.01){
        NPixelTracks->Fill(0);
      }else{ 
        NPixelTracks->Fill(1);
      }
    }
  }
  
  
//********************************************************************************************************  
  
  // Final combination of all Data Quality results:
  float pixelFlag = -1., barrelFlag = -1., endcapFlag = -1.;
  float barrel_errors_temp[1]={-1.}; int barrel_cuts_temp[5]={5*-1}; 
  float endcap_errors_temp[1]={-1.}; int endcap_cuts_temp[5]={5*-1}; 
  int pixel_cuts_temp[1]={-1};
  float combinedCuts = 1.; int numerator = 0, denominator = 0;

  // Barrel results:
  me = iGetter.get("Pixel/Barrel/BarrelNErrorsCut");
  if(me) barrel_errors_temp[0] = me->getFloatValue();
  me = iGetter.get("Pixel/Barrel/BarrelNDigisCut");
  if(me) barrel_cuts_temp[0] = me->getIntValue();
  me = iGetter.get("Pixel/Barrel/BarrelDigiChargeCut");
  if(me) barrel_cuts_temp[1] = me->getIntValue();
  me = iGetter.get("Pixel/Barrel/BarrelClusterSizeCut");
  if(me) barrel_cuts_temp[2] = me->getIntValue();
  me = iGetter.get("Pixel/Barrel/BarrelNClustersCut");
  if(me) barrel_cuts_temp[3] = me->getIntValue();
  me = iGetter.get("Pixel/Barrel/BarrelClusterChargeCut");
  if(me) barrel_cuts_temp[4] = me->getIntValue();
  for(int k=0; k!=5; k++){
    if(barrel_cuts_temp[k]>=0){
      numerator = numerator + barrel_cuts_temp[k];
      denominator++;
    }
  } 
  if(denominator!=0) combinedCuts = float(numerator)/float(denominator);  
  barrelFlag = barrel_errors_temp[0] * combinedCuts;
  
    // Endcap results:
  combinedCuts = 1.; numerator = 0; denominator = 0;
  me = iGetter.get("Pixel/Endcap/EndcapNErrorsCut");
  if(me) endcap_errors_temp[0] = me->getFloatValue();
  me = iGetter.get("Pixel/Endcap/EndcapNDigisCut");
  if(me) endcap_cuts_temp[0] = me->getIntValue();
  me = iGetter.get("Pixel/Endcap/EndcapDigiChargeCut");
  if(me) endcap_cuts_temp[1] = me->getIntValue();
  me = iGetter.get("Pixel/Endcap/EndcapClusterSizeCut");
  if(me) endcap_cuts_temp[2] = me->getIntValue();
  me = iGetter.get("Pixel/Endcap/EndcapNClustersCut");
  if(me) endcap_cuts_temp[3] = me->getIntValue();
  me = iGetter.get("Pixel/Endcap/EndcapClusterChargeCut");
  if(me) endcap_cuts_temp[4] = me->getIntValue();
  for(int k=0; k!=5; k++){
    if(endcap_cuts_temp[k]>=0){
      numerator = numerator + endcap_cuts_temp[k];
      denominator++;
    }
  } 
  if(denominator!=0) combinedCuts = float(numerator)/float(denominator);  
  endcapFlag = endcap_errors_temp[0] * combinedCuts;
  
  // Track results:
  combinedCuts = 1.; numerator = 0; denominator = 0;
  me = iGetter.get("Pixel/Tracks/PixelTracksCut");
  if(me) pixel_cuts_temp[0] = me->getIntValue();

  //Combination of all:
  combinedCuts = 1.; numerator = 0; denominator = 0;
  for(int k=0; k!=5; k++){
    if(barrel_cuts_temp[k]>=0){
      numerator = numerator + barrel_cuts_temp[k];
      denominator++;
    }
    if(endcap_cuts_temp[k]>=0){
      numerator = numerator + endcap_cuts_temp[k];
      denominator++;
    }
    if(k<1 && pixel_cuts_temp[k]>=0){
      numerator = numerator + pixel_cuts_temp[k];
      denominator++;
    }
  } 
  if(denominator!=0) combinedCuts = float(numerator)/float(denominator); 
  pixelFlag = float(pixel_error_flag_) * float(combinedCuts);
  
  
  SummaryPixel = iGetter.get("Pixel/EventInfo/reportSummary");
  if(SummaryPixel) SummaryPixel->Fill(pixelFlag);
  SummaryBarrel = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelBarrelFraction");
  if(SummaryBarrel) SummaryBarrel->Fill(barrelFlag);
  SummaryEndcap = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelEndcapFraction");
  if(SummaryEndcap)   SummaryEndcap->Fill(endcapFlag);
  }
}

//**********************************************************************************************

void SiPixelDataQuality::computeGlobalQualityFlagByLumi(DQMStore::IGetter & iGetter, 
                                                           bool init,
                               int nFEDs,
                               bool Tier0Flag,
                               int nEvents_lastLS_,
                               int nErrorsBarrel_lastLS_,
                               int nErrorsEndcap_lastLS_){
  if(nFEDs==0) return;  
  
  // evaluate fatal FED errors for data quality:
  float BarrelRate_LS = 1.;
  float EndcapRate_LS = 1.;
  float PixelRate_LS = 1.;
  MonitorElement * me = iGetter.get("Pixel/AdditionalPixelErrors/byLumiErrors");
  if(me){
    double nBarrelErrors_LS = me->getBinContent(1) - nErrorsBarrel_lastLS_;
    double nEndcapErrors_LS = me->getBinContent(2) - nErrorsEndcap_lastLS_;
    double nEvents_LS = me->getBinContent(0) - nEvents_lastLS_;
    if(nBarrelErrors_LS/nEvents_LS>0.5) BarrelRate_LS=0.;
    if(nEndcapErrors_LS/nEvents_LS>0.5) EndcapRate_LS=0.;
    if((nBarrelErrors_LS + nEndcapErrors_LS)/nEvents_LS>0.5) PixelRate_LS=0.;
  }
  
  // evaluate mean cluster charge on tracks for data quality:
  float BarrelClusterCharge = 1.;
  float EndcapClusterCharge = 1.;
  float PixelClusterCharge = 1.;
  MonitorElement * me1 = iGetter.get("Pixel/Clusters/OnTrack/charge_siPixelClusters_Barrel");
  if(me1 && me1->getMean()<12.) BarrelClusterCharge = 0.;
  MonitorElement * me2 = iGetter.get("Pixel/Clusters/OnTrack/charge_siPixelClusters_Endcap");
  if(me2 && me2->getMean()<12.) EndcapClusterCharge = 0.;
  MonitorElement * me3 = iGetter.get("Pixel/Clusters/OnTrack/charge_siPixelClusters");
  if(me3 && me3->getMean()<12.) PixelClusterCharge = 0.;
  
  // evaluate average FED occupancy for data quality:
  float BarrelOccupancy = 1.;
  float EndcapOccupancy = 1.;
  float PixelOccupancy = 1.;
  MonitorElement * me4 = iGetter.get("Pixel/averageDigiOccupancy");
  if(me4){
    double minBarrelOcc = 999999.; 
    double maxBarrelOcc = -1.; 
    double meanBarrelOcc = 0.;
    double minEndcapOcc = 999999.;
    double maxEndcapOcc = -1.;
    double meanEndcapOcc = 0.;
    for(int i=1; i!=41; i++){
      if(i<=32 && me4->getBinContent(i)<minBarrelOcc) minBarrelOcc=me4->getBinContent(i); 
      if(i<=32 && me4->getBinContent(i)>maxBarrelOcc) maxBarrelOcc=me4->getBinContent(i);
      if(i<=32) meanBarrelOcc+=me4->getBinContent(i);
      if(i>32 && me4->getBinContent(i)<minEndcapOcc) minEndcapOcc=me4->getBinContent(i); 
      if(i>32 && me4->getBinContent(i)>maxEndcapOcc) maxEndcapOcc=me4->getBinContent(i); 
      if(i>32) meanEndcapOcc+=me4->getBinContent(i);
    } 
    meanBarrelOcc = meanBarrelOcc/32.;
    meanEndcapOcc = meanEndcapOcc/8.;
    if(minBarrelOcc<0.1*meanBarrelOcc || maxBarrelOcc>2.5*meanBarrelOcc) BarrelOccupancy=0.;
    if(minEndcapOcc<0.2*meanEndcapOcc || maxEndcapOcc>1.8*meanEndcapOcc) EndcapOccupancy=0.;
    PixelOccupancy=BarrelOccupancy*EndcapOccupancy;
  }
  
  float pixelFlag = PixelRate_LS * PixelClusterCharge * PixelOccupancy;
  float barrelFlag = BarrelRate_LS * BarrelClusterCharge * BarrelOccupancy;
  float endcapFlag = EndcapRate_LS * EndcapClusterCharge * EndcapOccupancy;
  SummaryPixel = iGetter.get("Pixel/EventInfo/reportSummary");
  if(SummaryPixel) SummaryPixel->Fill(pixelFlag);
  SummaryBarrel = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelBarrelFraction");
  if(SummaryBarrel) SummaryBarrel->Fill(barrelFlag);
  SummaryEndcap = iGetter.get("Pixel/EventInfo/reportSummaryContents/PixelEndcapFraction");
  if(SummaryEndcap)   SummaryEndcap->Fill(endcapFlag);
  
}

//**********************************************************************************************

void SiPixelDataQuality::fillGlobalQualityPlot(DQMStore::IBooker & iBooker, DQMStore::IGetter & iGetter, bool init, edm::ESHandle<SiPixelFedCablingMap> theCablingMap, int nFEDs, bool Tier0Flag, int lumisec){
//std::cout<<"Entering SiPixelDataQuality::fillGlobalQualityPlot: "<<nFEDs<<std::endl;
  if(init){
    count=0; errcount=0;
    init=false;
    count1=0;
    count2=0;
    count3=0;
    count4=0;
    count5=0;
    count6=0;
    modCounter_=0;
  if(!Tier0Flag){
    
    //The plots that these Vecs are integrated throughout a run
    //So at each lumi section I save their last values (lastmods)
    //And then subtract them out later when filling the SummaryMap
    for(int j=1; j!=41; j++){
      if(allmodsVec) lastallmods_[j-1] = allmodsVec->GetBinContent(j);
      if(errmodsVec) lasterrmods_[j-1] = errmodsVec->GetBinContent(j);
      if(allmodsVec) allmodsVec->SetBinContent(j,0.);
      if(errmodsVec) errmodsVec->SetBinContent(j,0.);
      if(goodmodsVec) goodmodsVec->SetBinContent(j,0.);
    }
  }
  if(Tier0Flag){
    for(int i=1; i!=3; i++) for(int j=1; j!=8; j++){
      if(allmodsMap) allmodsMap->SetBinContent(i,j,0.);
      if(errmodsMap) errmodsMap->SetBinContent(i,j,0.);
      if(goodmodsMap) goodmodsMap->SetBinContent(i,j,0.);
    }
  }
  }
  
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  
// Fill Maps:
  // Online:    
  if(nFEDs==0) return;

  if(!Tier0Flag){
    //Not elegant, but not sure where else to put this sweet new plot!
    MonitorElement * meTmp = iGetter.get("Pixel/Barrel/NClustertoChargeRatio_AllMod");
    MonitorElement * meTop = iGetter.get("Pixel/Barrel/SUMCLU_nclusters_Barrel");
    MonitorElement * meBot = iGetter.get("Pixel/Barrel/SUMCLU_charge_Barrel");
    if(meTop && meBot && meTmp){
      for (int bin = 1; bin < 769; ++bin){
    float content = 0.0;
    if (meBot->getBinContent(bin) > 0.0){
      content = meTop->getBinContent(bin)/meBot->getBinContent(bin); 
    }
    meTmp->setBinContent(bin,content);
      }
      for (int j = 0; j < 4; ++j){
    static const char buf[] = "Pixel/Barrel/NClustertoChargeRatio_NormMod%i";
    char modplot[sizeof(buf)+2];
    sprintf(modplot,buf,j+1);
    MonitorElement * meFinal = iGetter.get(modplot);
    if(!meFinal) continue;
    for (int i = 1; i < 769; ++i){
      int k = 3 - j;
      if (int(i+k)%4 == 0)
        meFinal->setBinContent(int((i+k)/4), meTmp->getBinContent(i));
    }
    //Filling done. Now modification.
    float SFLay[3], TotLay[3];
    for (int ll = 0; ll < 3; ++ll) TotLay[ll] = 0.0;
    for (int bin = 1; bin < (meFinal->getNbinsX()+1);++bin){
          int layer     =   int((bin%48)/16);
      TotLay[layer] += meFinal->getBinContent(bin);
    }
    float laynorm = TotLay[1]/64.;
    for (int ll = 0; ll < 3; ++ll){
      SFLay[ll] = 0.0; if (TotLay[ll] > 0.0 && TotLay[1] > 0.0) SFLay[ll] = TotLay[1]/TotLay[ll]*(1./laynorm);
    }
    //now loop through plot
    for (int bin = 1; bin < (meFinal->getNbinsX()+1); ++bin){
      //access the layer number for bin: int((i%48)/16)
      int layer     =   int((bin%48)/16);
      float content =   meFinal->getBinContent(bin);
      //apply scale factor to bin content
      meFinal->setBinContent(bin,content*SFLay[layer]);
    }
      }
    }
    
    string currDir = iBooker.pwd();
    if(currDir.find("Reference")!=string::npos || currDir.find("Additional")!=string::npos) return;
    string dname = currDir.substr(currDir.find_last_of("/")+1);
    if(dname.find("Module_")!=string::npos && currDir.find("Reference")==string::npos){
      vector<string> meVec = iGetter.getMEs();
      int detId=-1; int fedId=-1;
      for (vector<string>::const_iterator it = meVec.begin(); it != meVec.end(); it++){//loop over all modules and fill ndigis into allmodsMap
        //checking for any digis or FED errors to decide if this module is in DAQ:  
        string full_path = currDir + "/" + (*it);
        if(detId==-1 && full_path.find("SUMOFF")==string::npos &&
           (full_path.find("ndigis")!=string::npos && full_path.find("SUMDIG")==string::npos) && 
       (getDetId(iGetter.get(full_path)) > 100)){
          MonitorElement * me = iGetter.get(full_path);
          if (!me) continue;
      if((full_path.find("ndigis")!=string::npos)){ 
        modCounter_++;
            detId = getDetId(me);
            for(int fedid=0; fedid!=40; ++fedid){
              SiPixelFrameConverter converter(theCablingMap.product(),fedid);
          uint32_t newDetId = detId;
              if(converter.hasDetUnit(newDetId)){
                fedId=fedid;
                break;   
              }
            }
        double NDigis = 0;
        if(full_path.find("ndigis")!=string::npos) NDigis = me->getEntries(); 
        float weight = (allmodsVec->GetBinContent(fedId+1))+NDigis;
        allmodsVec->SetBinContent(fedId+1,weight);
      }
        }
      }//end loop over MEs
    }//end of module dir's
    vector<string> subDirVec = iGetter.getSubdirs();  
    for (vector<string>::const_iterator ic = subDirVec.begin();
         ic != subDirVec.end(); ic++) {
      iBooker.cd(*ic);
      iGetter.cd(*ic);
      init=false;
      fillGlobalQualityPlot(iBooker,iGetter,init,theCablingMap,nFEDs,Tier0Flag,lumisec);
      iBooker.goUp();
      iGetter.setCurrentFolder(iBooker.pwd());
    }
    if(modCounter_==1440){
      iBooker.cd("Pixel/EventInfo/reportSummaryContents");
      iGetter.cd("Pixel/EventInfo/reportSummaryContents");
      if(iBooker.pwd()=="Pixel/EventInfo/reportSummaryContents"){
        for(int i=0; i!=40; i++){//loop over FEDs to fetch the errors
          static const char buf[] = "Pixel/AdditionalPixelErrors/FED_%d/FedChNErr";
          char fedplot[sizeof(buf)+4]; 
      int NErrors = 0;
      for(int j=0; j!=37; j++){//loop over FED channels within a FED
            sprintf(fedplot,buf,i);
        MonitorElement * me = iGetter.get(fedplot);
        if(me) NErrors = NErrors + me->getBinContent(j+1);
      }
      //If I fill, then I end up majorly overcounting the numbers of errors...
      if(NErrors>0){ errmodsVec->SetBinContent(i+1,NErrors); } 
    }
        SummaryReportMap = iGetter.get("Pixel/EventInfo/reportSummaryMap");
        if(SummaryReportMap){ 
          float contents=0.;
          for(int i=1; i!=41; i++){
        //Dynamically subtracting previous (integrated) lumi section values
        //in order to only show current lumi section's numbers
        float mydigis = allmodsVec->GetBinContent(i) - lastallmods_[i-1];
            float myerrs  = errmodsVec->GetBinContent(i) - lasterrmods_[i-1];
        if ((mydigis + myerrs) > 0.){
          contents = mydigis/(mydigis + myerrs);
            }else{
          //Changed so that dynamic zooming will still
          //advance over these bins(in renderplugins)
              contents = -0.5;
            }
            SummaryReportMap->setBinContent(lumisec+1,i,contents);
          }//end for loop over summaryReportMap bins
        }//end if reportSummaryMap ME exists
      }//end if in summary directory
    }//end if modCounter_  
  }else{ // Offline
    float barrel_errors_temp[1]={-1.}; int barrel_cuts_temp[6]={6*-1}; 
    float endcap_errors_temp[1]={-1.}; int endcap_cuts_temp[6]={6*-1}; 
    int pixel_cuts_temp[1]={-1};
    // Barrel results:
    MonitorElement * me;
    me = iGetter.get("Pixel/Barrel/BarrelNErrorsCut");
    if(me) barrel_errors_temp[0] = me->getFloatValue();
    me = iGetter.get("Pixel/Endcap/EndcapNErrorsCut");
    if(me) endcap_errors_temp[0] = me->getFloatValue();
    SummaryReportMap->setBinContent(1,1,barrel_errors_temp[0]);
    SummaryReportMap->setBinContent(2,1,endcap_errors_temp[0]);
    me = iGetter.get("Pixel/Barrel/BarrelNDigisCut");
    if(me) barrel_cuts_temp[0] = me->getIntValue();
    me = iGetter.get("Pixel/Barrel/BarrelDigiChargeCut");
    if(me) barrel_cuts_temp[1] = me->getIntValue();
    me = iGetter.get("Pixel/Barrel/BarrelClusterSizeCut");
    if(me) barrel_cuts_temp[2] = me->getIntValue();
    me = iGetter.get("Pixel/Barrel/BarrelNClustersCut");
    if(me) barrel_cuts_temp[3] = me->getIntValue();
    me = iGetter.get("Pixel/Barrel/BarrelClusterChargeCut");
    if(me) barrel_cuts_temp[4] = me->getIntValue();  
    me = iGetter.get("Pixel/Endcap/EndcapNDigisCut");
    if(me) endcap_cuts_temp[0] = me->getIntValue();
    me = iGetter.get("Pixel/Endcap/EndcapDigiChargeCut");
    if(me) endcap_cuts_temp[1] = me->getIntValue();
    me = iGetter.get("Pixel/Endcap/EndcapClusterSizeCut");
    if(me) endcap_cuts_temp[2] = me->getIntValue();
    me = iGetter.get("Pixel/Endcap/EndcapNClustersCut");
    if(me) endcap_cuts_temp[3] = me->getIntValue();
    me = iGetter.get("Pixel/Endcap/EndcapClusterChargeCut");
    if(me) endcap_cuts_temp[4] = me->getIntValue();  
    for(int j=2; j!=7; j++){
      SummaryReportMap->setBinContent(1,j,barrel_cuts_temp[j-2]);
      SummaryReportMap->setBinContent(2,j,endcap_cuts_temp[j-2]);
    }
    me = iGetter.get("Pixel/Tracks/PixelTracksCut");
    if(me) pixel_cuts_temp[0] = me->getIntValue();  
    SummaryReportMap->setBinContent(1,7,pixel_cuts_temp[0]);
    SummaryReportMap->setBinContent(2,7,pixel_cuts_temp[0]);
  }//end of offline map
  if(allmodsMap) allmodsMap->Clear();
  if(goodmodsMap) goodmodsMap->Clear();
  if(errmodsMap) errmodsMap->Clear();
}

//**********************************************************************************************