HcalRecHitsDQMClient.cc

Go to the documentation of this file.

#include "DQMOffline/Hcal/interface/HcalRecHitsDQMClient.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/Service.h"

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

HcalRecHitsDQMClient::HcalRecHitsDQMClient(const edm::ParameterSet& iConfig):conf_(iConfig)
{

  outputFile_ = iConfig.getUntrackedParameter<std::string>("outputFile", "myfile.root");
  debug_ = false;
  verbose_ = false;
  dirName_=iConfig.getParameter<std::string>("DQMDirName");
}


HcalRecHitsDQMClient::~HcalRecHitsDQMClient()
{ 
  
}

void HcalRecHitsDQMClient::beginJob()
{
 

}


void HcalRecHitsDQMClient::beginRun(const edm::Run& run, const edm::EventSetup& es){
   
  edm::ESHandle<HcalDDDRecConstants> pHRNDC;
  es.get<HcalRecNumberingRecord>().get( pHRNDC );
  hcons = &(*pHRNDC);
  maxDepthHB_ = hcons->getMaxDepth(0);
  maxDepthHE_ = hcons->getMaxDepth(1);
  maxDepthHF_ = hcons->getMaxDepth(2);
  maxDepthHO_ = hcons->getMaxDepth(3);
 
  edm::ESHandle<CaloGeometry> geometry;

  es.get<CaloGeometryRecord > ().get(geometry);
 
  const std::vector<DetId>& hbCells = geometry->getValidDetIds(DetId::Hcal, HcalBarrel);
  const std::vector<DetId>& heCells = geometry->getValidDetIds(DetId::Hcal, HcalEndcap);
  const std::vector<DetId>& hoCells = geometry->getValidDetIds(DetId::Hcal, HcalOuter);
  const std::vector<DetId>& hfCells = geometry->getValidDetIds(DetId::Hcal, HcalForward);
 
  nChannels_[1] = hbCells.size(); 
  nChannels_[2] = heCells.size(); 
  nChannels_[3] = hoCells.size(); 
  nChannels_[4] = hfCells.size();
  nChannels_[0] = nChannels_[1] + nChannels_[2] + nChannels_[3] + nChannels_[4];
 
  //std::cout << "Channels HB:" << nChannels_[1] << " HE:" << nChannels_[2] << " HO:" << nChannels_[3] << " HF:" << nChannels_[4] << std::endl;
 
  //We hardcode the HF depths because in the dual readout configuration, rechits are not defined for depths 3&4
  maxDepthHF_ = (maxDepthHF_ > 2 ? 2 : maxDepthHF_); //We reatin the dynamic possibility that HF might have 0 or 1 depths
 
  maxDepthAll_ = ( maxDepthHB_ + maxDepthHO_ > maxDepthHE_ ? maxDepthHB_ + maxDepthHO_ : maxDepthHE_ );
  maxDepthAll_ = ( maxDepthAll_ > maxDepthHF_ ? maxDepthAll_ : maxDepthHF_ );
 
}

void HcalRecHitsDQMClient::dqmEndJob(DQMStore::IBooker & ibooker, DQMStore::IGetter & igetter)
{
  igetter.setCurrentFolder(dirName_);

  if (verbose_) std::cout << "\nrunClient" << std::endl; 

  std::vector<MonitorElement*> hcalMEs;

  // Since out folders are fixed to three, we can just go over these three folders
  // i.e., CaloTowersD/CaloTowersTask, HcalRecHitsD/HcalRecHitTask, NoiseRatesV/NoiseRatesTask.
  std::vector<std::string> fullPathHLTFolders = igetter.getSubdirs();
  for(unsigned int i=0;i<fullPathHLTFolders.size();i++) {

    if (verbose_) std::cout <<"\nfullPath: "<< fullPathHLTFolders[i] << std::endl;
    igetter.setCurrentFolder(fullPathHLTFolders[i]);

    std::vector<std::string> fullSubPathHLTFolders = igetter.getSubdirs();
    for(unsigned int j=0;j<fullSubPathHLTFolders.size();j++) {

      if (verbose_) std::cout <<"fullSub: "<<fullSubPathHLTFolders[j] << std::endl;

      if( strcmp(fullSubPathHLTFolders[j].c_str(), "HcalRecHitsD/HcalRecHitTask") ==0  ){
         hcalMEs = igetter.getContents(fullSubPathHLTFolders[j]);
         if (verbose_) std::cout <<"hltMES size : "<<hcalMEs.size()<<std::endl;
         if( !HcalRecHitsEndjob(hcalMEs) ) std::cout<<"\nError in HcalRecHitsEndjob!"<<std::endl<<std::endl;
      }

    }    

  }

}


// called after entering the HcalRecHitsD/HcalRecHitTask directory
// hcalMEs are within that directory
int HcalRecHitsDQMClient::HcalRecHitsEndjob(const std::vector<MonitorElement*> &hcalMEs){

   MonitorElement* Nhf=nullptr;

   //Search for emap histograms, and collect them into this vector
   //All subdtectors are plotted together in these histograms. We only need to look for different depths
   std::vector<MonitorElement*> emap_depths;

   //This vector is filled occupancy_maps identified by both subdetector and depth
   std::vector<MonitorElement*> occupancy_maps;
   std::vector<std::string> occupancyID;

   //This vector is filled with emean_vs_ieta histograms, they are divided by both subdetector and depth
   std::vector<MonitorElement*> emean_vs_ieta;

   //These are the only histograms filled in this module; however, the histograms are created empty in HcalRecHitsAnalyzer
   //occupancy_vs_ieta, divided by both subdetector and depth
   std::vector<MonitorElement*> occupancy_vs_ieta;
   std::vector<std::string> occupancy_vs_ietaID;

   //RecHit_StatusWord & RecHit_Aux_StatusWord
   //Divided by subdectector
   std::vector<MonitorElement*> RecHit_StatusWord;
   std::vector<float>           RecHit_StatusWord_Channels;
   std::vector<MonitorElement*> RecHit_Aux_StatusWord;
   std::vector<float>           RecHit_Aux_StatusWord_Channels;

   for(unsigned int ih=0; ih<hcalMEs.size(); ih++){

      //N_HF is not special, it is just convient to get the total number of events
      //The number of entries in N_HF is equal to the number of events
      if( hcalMEs[ih]->getName() == "N_HF" ){ 
         Nhf= hcalMEs[ih];
         continue;
      }

      // ***********************
      // * We fill the various MonitorElement vectors by searching for a matching substring
      // * The methods that are used are agnostic to the ordering of vectors
      // ***********************     

      if( hcalMEs[ih]->getName().find("emap_depth") != std::string::npos ){
         emap_depths.push_back(hcalMEs[ih]);
         continue;  
      } 

      if( hcalMEs[ih]->getName().find("occupancy_map_H") != std::string::npos ){
         occupancy_maps.push_back(hcalMEs[ih]);

         // Use occupancyID to save the subdetector and depth information
         // This will help preserve both indifference to vector ordering and specific details of the detector topology
         // The position in occupancyID must correspond to the histogram position in occupancy_maps

         // Save the string after "occupancy_map_"
         
         std::string prefix = "occupancy_map_";

         occupancyID.push_back( hcalMEs[ih]->getName().substr(prefix.size()) );

         continue;
      }

      if( hcalMEs[ih]->getName().find("emean_vs_ieta_H") != std::string::npos ){
         emean_vs_ieta.push_back(hcalMEs[ih]);
         continue;
      }

      if( hcalMEs[ih]->getName().find("occupancy_vs_ieta_H") != std::string::npos ){
         occupancy_vs_ieta.push_back(hcalMEs[ih]);

         // Use occupancy_vs_ietaID to save the subdetector and depth information
         // This will help preserve both indifference to vector ordering and specific details of the detector topology
         // The position in occupancyID must correspond to the histogram position in occupancy_vs_ieta

         // Save the string after "occupancy_vs_ieta_"
         
         std::string prefix = "occupancy_vs_ieta_";

         occupancy_vs_ietaID.push_back( hcalMEs[ih]->getName().substr(prefix.size()) );

         continue;
      }

      if( hcalMEs[ih]->getName().find("HcalRecHitTask_RecHit_StatusWord_H") != std::string::npos ){
         RecHit_StatusWord.push_back(hcalMEs[ih]);

         if(hcalMEs[ih]->getName().find("HB") != std::string::npos ){
            RecHit_StatusWord_Channels.push_back((float)nChannels_[1]);
         }else if(hcalMEs[ih]->getName().find("HE") != std::string::npos ){
            RecHit_StatusWord_Channels.push_back((float)nChannels_[2]);
         }else if(hcalMEs[ih]->getName().find("H0") != std::string::npos ){
            RecHit_StatusWord_Channels.push_back((float)nChannels_[3]);
         }else if(hcalMEs[ih]->getName().find("HF") != std::string::npos ){
            RecHit_StatusWord_Channels.push_back((float)nChannels_[4]);
         } else {
            RecHit_StatusWord_Channels.push_back(1.);
         }

         continue;
      }

      if( hcalMEs[ih]->getName().find("HcalRecHitTask_RecHit_Aux_StatusWord_H") != std::string::npos ){
         RecHit_Aux_StatusWord.push_back(hcalMEs[ih]);

         if(hcalMEs[ih]->getName().find("HB") != std::string::npos ){
            RecHit_Aux_StatusWord_Channels.push_back((float)nChannels_[1]);
         }else if(hcalMEs[ih]->getName().find("HE") != std::string::npos ){
            RecHit_Aux_StatusWord_Channels.push_back((float)nChannels_[2]);
         }else if(hcalMEs[ih]->getName().find("H0") != std::string::npos ){
            RecHit_Aux_StatusWord_Channels.push_back((float)nChannels_[3]);
         }else if(hcalMEs[ih]->getName().find("HF") != std::string::npos ){
            RecHit_Aux_StatusWord_Channels.push_back((float)nChannels_[4]);
         } else {
            RecHit_Aux_StatusWord_Channels.push_back(1.);
         }

         continue;
      }

   } 

   // mean energies and occupancies evaluation

   double nevtot = Nhf->getEntries(); // Use the number of entries in the Nhf histogram to give the total number of events

   if(verbose_) std::cout<<"nevtot : "<<nevtot<<std::endl;

   // emap histograms are scaled by the number of events
   float  fev           = float (nevtot);
   double scaleBynevtot = 1 / fev;

   // In this and the following histogram vectors, recognize that the for-loop index
   // does not have to correspond to any particular depth
   for(unsigned int depthIdx = 0; depthIdx < emap_depths.size(); depthIdx++){

      int nx = emap_depths[depthIdx]->getNbinsX();
      int ny = emap_depths[depthIdx]->getNbinsY();

      float cnorm;
      float enorm;

      for (int i = 1; i <= nx; i++) {      
         for (int j = 1; j <= ny; j++) {
        cnorm = emap_depths[depthIdx]->getBinContent(i,j) * scaleBynevtot;
        enorm = emap_depths[depthIdx]->getBinError(i,j) * scaleBynevtot;
            emap_depths[depthIdx]->setBinContent(i,j,cnorm);
            emap_depths[depthIdx]->setBinError(i,j,enorm);

         }
      }
   }

   // occupancy_maps & matched occupancy_vs_ieta

   bool omatched = false;

   for(unsigned int occupancyIdx = 0; occupancyIdx < occupancy_maps.size(); occupancyIdx++){

      int nx = occupancy_maps[occupancyIdx]->getNbinsX();
      int ny = occupancy_maps[occupancyIdx]->getNbinsY();

      float cnorm;
      float enorm;

      unsigned int vsIetaIdx = occupancy_vs_ieta.size();
      omatched = false;

      for(vsIetaIdx = 0; vsIetaIdx < occupancy_vs_ieta.size(); vsIetaIdx++){
         if(occupancyID[occupancyIdx] == occupancy_vs_ietaID[vsIetaIdx]){
            omatched = true;
            break;
         }
      }// match occupancy_vs_ieta histogram

      for (int i = 1; i <= nx; i++) {      
         for (int j = 1; j <= ny; j++) {
        cnorm = occupancy_maps[occupancyIdx]->getBinContent(i,j) * scaleBynevtot;
        enorm = occupancy_maps[occupancyIdx]->getBinError(i,j) * scaleBynevtot;
            occupancy_maps[occupancyIdx]->setBinContent(i,j,cnorm);
            occupancy_maps[occupancyIdx]->setBinError(i,j,enorm);

         }
      }

      //Fill occupancy_vs_ieta

      if(omatched){

         //We run over all of the ieta values
         for (int ieta = -41; ieta <= 41; ieta++) {
            float phi_factor = 1.;
            float sumphi = 0.;
        float sumphie = 0.;

            if(ieta == 0) continue; //ieta=0 is not defined

            phi_factor = phifactor(ieta);

            //the rechits occupancy map defines iphi as 0..71
            for (int iphi = 0; iphi <= 71; iphi++) {
               int binIeta = occupancy_maps[occupancyIdx]->getTH2F()->GetXaxis()->FindBin(float(ieta));
               int binIphi = occupancy_maps[occupancyIdx]->getTH2F()->GetYaxis()->FindBin(float(iphi));

               float content = occupancy_maps[occupancyIdx]->getBinContent(binIeta,binIphi);
           float econtent = occupancy_maps[occupancyIdx]->getBinError(binIeta,binIphi);

               sumphi += content;
           sumphie += econtent*econtent;
            }//for loop over phi

        int ietabin = occupancy_vs_ieta[vsIetaIdx]->getTH1F()->GetXaxis()->FindBin(float(ieta));

        

            // fill occupancies vs ieta
            cnorm = sumphi / phi_factor;
        enorm = sqrt(sumphie) / phi_factor;
            occupancy_vs_ieta[vsIetaIdx]->setBinContent(ietabin, cnorm);
        occupancy_vs_ieta[vsIetaIdx]->setBinError(ietabin,enorm);

         }//Fill occupancy_vs_ieta
      }//if omatched
   }

   // Status Word
   // Normalized by number of events and by number of channels per subdetector as well

   for(unsigned int StatusWordIdx = 0; StatusWordIdx < RecHit_StatusWord.size(); StatusWordIdx++){
         
      int nx = RecHit_StatusWord[StatusWordIdx]->getNbinsX();

      float cnorm;
      float enorm;

      for (int i = 1; i <= nx; i++) {      
         cnorm = RecHit_StatusWord[StatusWordIdx]->getBinContent(i) * scaleBynevtot / RecHit_StatusWord_Channels[StatusWordIdx];
         enorm = RecHit_StatusWord[StatusWordIdx]->getBinError(i) * scaleBynevtot / RecHit_StatusWord_Channels[StatusWordIdx];
         RecHit_StatusWord[StatusWordIdx]->setBinContent(i,cnorm);
         RecHit_StatusWord[StatusWordIdx]->setBinError(i,enorm);

      }

   }

   for(unsigned int AuxStatusWordIdx = 0; AuxStatusWordIdx < RecHit_Aux_StatusWord.size(); AuxStatusWordIdx++){
         
      int nx = RecHit_Aux_StatusWord[AuxStatusWordIdx]->getNbinsX();

      float cnorm;
      float enorm;

      for (int i = 1; i <= nx; i++) {      
         cnorm = RecHit_Aux_StatusWord[AuxStatusWordIdx]->getBinContent(i) * scaleBynevtot / RecHit_Aux_StatusWord_Channels[AuxStatusWordIdx];
         enorm = RecHit_Aux_StatusWord[AuxStatusWordIdx]->getBinError(i) * scaleBynevtot / RecHit_Aux_StatusWord_Channels[AuxStatusWordIdx];
         RecHit_Aux_StatusWord[AuxStatusWordIdx]->setBinContent(i,cnorm);
         RecHit_Aux_StatusWord[AuxStatusWordIdx]->setBinError(i,enorm);

      }


   }

   return 1;
}

float HcalRecHitsDQMClient::phifactor(int ieta){

   float phi_factor_;

   if(ieta >= -20 && ieta <= 20 ){
      phi_factor_ = 72.;
   } else {
      if(ieta >= 40 || ieta <= -40 ){
         phi_factor_ = 18.;
      } else {
         phi_factor_ = 36.;
      }
   }

   return phi_factor_;

}

DEFINE_FWK_MODULE(HcalRecHitsDQMClient);