RecAnalyzerHF.cc

Go to the documentation of this file.

// system include files
#include <memory>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <map>

// user include files
#include "CondFormats/DataRecord/interface/HcalRespCorrsRcd.h"
#include "CondFormats/HcalObjects/interface/HcalRespCorrs.h"
#include "FWCore/Common/interface/TriggerNames.h"
#include "FWCore/Framework/interface/one/EDAnalyzer.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CommonTools/UtilAlgos/interface/TFileService.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/HcalDetId/interface/HcalDetId.h"
#include "DataFormats/HcalDetId/interface/HcalSubdetector.h"
#include "DataFormats/HcalRecHit/interface/HcalRecHitCollections.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMap.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapRecord.h"
#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"

#include "Geometry/CaloTopology/interface/HcalTopology.h"

#include "TH1D.h"
#include "TTree.h"

//#define EDM_ML_DEBUG

// class declaration
class RecAnalyzerHF : public edm::one::EDAnalyzer<edm::one::SharedResources> {

public:
  explicit RecAnalyzerHF(const edm::ParameterSet&);
  ~RecAnalyzerHF() override;

  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);

private:
  void analyze(edm::Event const&, edm::EventSetup const&) override;
  void beginJob() override;
  void endJob() override;
    
private:
  void analyzeHcal(const HFPreRecHitCollection&, int, bool);

  // ----------member data ---------------------------
  edm::Service<TFileService> fs_;
  bool                                ignoreL1_, nzs_, noise_, ratio_,fillTree_;
  double                              eLowHF_, eHighHF_;
  std::vector<unsigned int>           hcalID_;
  TTree                              *myTree_;
  TH1D                               *hist_[2];
  std::vector<std::pair<TH1D*,TH1D*>> histo_;
  std::vector<int>                    trigbit_;
  double                              rnnum_;
  struct myInfo{
    double kount, f11, f12, f13, f14, f21, f22, f23, f24, runcheck;
    myInfo() {
      kount = f11 = f12 = f13 = f14 = f21 = f22 = f23 = f24 = runcheck = 0;
    }
  };
  // Root tree members
  double                     rnnumber;
  int                        mysubd, depth, iphi, ieta, cells, trigbit;
  float                      mom0_F1, mom1_F1, mom2_F1, mom3_F1, mom4_F1;
  float                      mom0_F2, mom1_F2, mom2_F2, mom3_F2, mom4_F2;
  std::map<std::pair<int,HcalDetId>,myInfo>        myMap_;
  edm::EDGetTokenT<HFPreRecHitCollection>          tok_hfreco_;
  edm::EDGetTokenT<L1GlobalTriggerObjectMapRecord> tok_hltL1GtMap_;
};

// constructors and destructor
  RecAnalyzerHF::RecAnalyzerHF(const edm::ParameterSet& iConfig) {

  usesResource("TFileService");
  // get name of output file with histogramms
  nzs_                  = iConfig.getParameter<bool>("RunNZS");
  noise_                = iConfig.getParameter<bool>("Noise");
  ratio_                = iConfig.getParameter<bool>("Ratio");
  eLowHF_               = iConfig.getParameter<double>("ELowHF");
  eHighHF_              = iConfig.getParameter<double>("EHighHF");
  trigbit_              = iConfig.getUntrackedParameter<std::vector<int>>("TriggerBits");
  ignoreL1_             = iConfig.getUntrackedParameter<bool>("IgnoreL1",false);
  fillTree_             = iConfig.getUntrackedParameter<bool>("FillTree",true);
  std::vector<int> ieta = iConfig.getUntrackedParameter<std::vector<int>>("HcalIeta");
  std::vector<int> iphi = iConfig.getUntrackedParameter<std::vector<int>>("HcalIphi");
  std::vector<int> depth= iConfig.getUntrackedParameter<std::vector<int>>("HcalDepth");

  // get token names of modules, producing object collections
  tok_hfreco_       = consumes<HFPreRecHitCollection>(iConfig.getParameter<edm::InputTag>("hfInput"));
  tok_hltL1GtMap_   = consumes<L1GlobalTriggerObjectMapRecord>(edm::InputTag("hltL1GtObjectMap"));

  edm::LogVerbatim("RecAnalyzer") << " Flags (IgnoreL1): " << ignoreL1_ 
                 << " (NZS) " << nzs_ << " (Noise) " << noise_ 
                 << " (Ratio) " << ratio_;
  edm::LogVerbatim("RecAnalyzer") << "Thresholds for HF " << eLowHF_ << ":" 
                 << eHighHF_;
  for (unsigned int k=0; k<ieta.size(); ++k) {
    if (std::abs(ieta[k]) >= 29) {
      unsigned int id = (HcalDetId(HcalForward,ieta[k],iphi[k],depth[k])).rawId();
      hcalID_.push_back(id);
      edm::LogVerbatim("RecAnalyzer") << "DetId[" << k << "] " << HcalDetId(id);
    }
  }
  edm::LogVerbatim("RecAnalyzer") << "Select on " << trigbit_.size() 
                 << " L1 Trigger selection";
  unsigned int k(0);
  for (auto trig : trigbit_) {
    edm::LogVerbatim("RecAnalyzer") << "Bit[" << k << "] " << trig; ++k;}
}
  
RecAnalyzerHF::~RecAnalyzerHF() {}

// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
void RecAnalyzerHF::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {

  edm::ParameterSetDescription desc;
  desc.add<bool>("RunNZS",true);
  desc.add<bool>("Noise",false);
  desc.add<bool>("Ratio",false);
  desc.add<double>("ELowHF",10);
  desc.add<double>("EHighHF",150);
  std::vector<int> idummy;
  desc.addUntracked<std::vector<int> >("TriggerBits",idummy);
  desc.addUntracked<bool>("IgnoreL1",false);
  desc.addUntracked<bool>("FillHisto",false);
  desc.addUntracked<std::vector<int> >("HcalIeta",idummy);
  desc.addUntracked<std::vector<int> >("HcalIphi",idummy);
  desc.addUntracked<std::vector<int> >("HcalDepth",idummy);
  desc.add<edm::InputTag>("hfInput",edm::InputTag("hfprereco"));
  descriptions.add("recAnalyzerHF",desc);
}
  
void RecAnalyzerHF::beginJob() {

  char        name[700], title[700];
  double      xmin(-10.0), xmax(90.0);
  if (ratio_) { xmin = -5.0; xmax = 5.0;}
  for (int i=0; i<2; ++i) {
    sprintf(name, "HF%d", i);
    sprintf (title, "The metric F%d for HF", i+1);
    hist_[i] = fs_->make<TH1D>(name,title,50,xmin,xmax);
  }

  for (const auto & id : hcalID_) {
    HcalDetId hid = HcalDetId(id);
    TH1D *h1(nullptr), *h2(nullptr);
    for (int i=0; i<2; ++i) {
      sprintf (name, "HF%d%d_%d_%d", i, hid.ieta(), hid.iphi(), hid.depth());
      sprintf (title, "The metric F%d for HF i#eta %d i#phi %d depth %d", 
           i+1, hid.ieta(), hid.iphi(), hid.depth());
      if (i == 0) h1 = fs_->make<TH1D>(name, title, 50, xmin, xmax);
      else        h2 = fs_->make<TH1D>(name, title, 50, xmin, xmax);
    }
    histo_.push_back(std::pair<TH1D*,TH1D*>(h1,h2));
  };

  if (fillTree_) {
    myTree_       = fs_->make<TTree>("RecJet","RecJet Tree");
    myTree_->Branch("cells",    &cells,    "cells/I");
    myTree_->Branch("mysubd",   &mysubd,   "mysubd/I");
    myTree_->Branch("depth",    &depth,    "depth/I");
    myTree_->Branch("ieta",     &ieta,     "ieta/I");
    myTree_->Branch("iphi",     &iphi,     "iphi/I");
    myTree_->Branch("mom0_F1",  &mom0_F1,  "mom0_F1/F");
    myTree_->Branch("mom1_F1",  &mom1_F1,  "mom1_F1/F");
    myTree_->Branch("mom2_F1",  &mom2_F1,  "mom2_F1/F");
    myTree_->Branch("mom3_F1",  &mom3_F1,  "mom3_F1/F");
    myTree_->Branch("mom4_F1",  &mom4_F1,  "mom4_F1/F");
    myTree_->Branch("mom0_F2",  &mom0_F2,  "mom0_F2/F");
    myTree_->Branch("mom1_F2",  &mom1_F2,  "mom1_F2/F");
    myTree_->Branch("mom2_F2",  &mom2_F2,  "mom2_F2/F");
    myTree_->Branch("mom3_F2",  &mom3_F2,  "mom3_F2/F");
    myTree_->Branch("mom4_F2",  &mom4_F2,  "mom4_F2/F");
    myTree_->Branch("trigbit",  &trigbit,  "trigbit/I");
    myTree_->Branch("rnnumber", &rnnumber, "rnnumber/D");
  }

  myMap_.clear();
}

void RecAnalyzerHF::endJob() {

  if (fillTree_) {
    cells = 0;
    for (const auto & itr : myMap_) {
      edm::LogVerbatim("RecAnalyzer") << "Fired trigger bit number "
                      << itr.first.first;
      myInfo info = itr.second;
      if (info.kount > 0) { 
    mom0_F1  = info.kount;
    mom1_F1  = info.f11;
    mom2_F1  = info.f12;
    mom3_F1  = info.f13;
    mom4_F1  = info.f14;
    mom0_F2  = info.kount;
    mom1_F2  = info.f21;
    mom2_F2  = info.f22;
    mom3_F2  = info.f23;
    mom4_F2  = info.f24;
    rnnumber = info.runcheck;
    trigbit  = itr.first.first;
    mysubd   = itr.first.second.subdet();
    depth    = itr.first.second.depth();
    iphi     = itr.first.second.iphi();
    ieta     = itr.first.second.ieta();
    edm::LogVerbatim("RecAnalyzer") << " Result=  " << trigbit << " " 
                    << mysubd << " " << ieta << " " << iphi
                    << " F1:mom0  " << mom0_F1 << " mom1 " 
                    << mom1_F1 << " mom2 " << mom2_F1 
                    << " mom3 " << mom3_F1 << " mom4 " 
                    << mom4_F1 << " F2:mom0 " << mom0_F2
                    << " mom1 " << mom1_F2 << " mom2 " 
                    << mom2_F2 << " mom3 " << mom3_F2 
                    << " mom4 " << mom4_F2;
    myTree_->Fill();
    cells++;
      }
    }
    edm::LogVerbatim("RecAnalyzer") << "cells" << " " << cells;
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("RecAnalyzer") << "Exiting from RecAnalyzerHF::endjob";
#endif
}

//
// member functions
//
// ------------ method called to produce the data  ------------
  
void RecAnalyzerHF::analyze(const edm::Event& iEvent, const edm::EventSetup&) {

  rnnum_ = (double)iEvent.run(); 
    
  edm::Handle<HFPreRecHitCollection> hf;
  iEvent.getByToken(tok_hfreco_, hf);
  if (!hf.isValid()) {
    edm::LogWarning("RecAnalyzer") << "HcalCalibAlgos: Error! can't get hf product!";
    return;
  }
  const HFPreRecHitCollection Hithf = *(hf.product());
  edm::LogVerbatim("RecAnalyzer") << "HF MB size of collection " 
                  << Hithf.size();
  if (Hithf.size() < 1700 && nzs_) {
    edm::LogWarning("RecAnalyzer") << "HF problem " << rnnum_ << " size "
                  << Hithf.size();
  }

  bool select(false);
  if (!trigbit_.empty()) {
    edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
    iEvent.getByToken(tok_hltL1GtMap_, gtObjectMapRecord);
    if (gtObjectMapRecord.isValid()) {
      const std::vector<L1GlobalTriggerObjectMap>& objMapVec = gtObjectMapRecord->gtObjectMap();
      for (std::vector<L1GlobalTriggerObjectMap>::const_iterator itMap = objMapVec.begin();
           itMap != objMapVec.end(); ++itMap) {
        bool resultGt = (*itMap).algoGtlResult();
        if (resultGt) {
          int algoBit = (*itMap).algoBitNumber();
          if (std::find(trigbit_.begin(),trigbit_.end(),algoBit) != 
          trigbit_.end()) {
            select = true;
            break;
          }
        }
      }
    }
  }

  //event weight for FLAT sample and PU information

  if (ignoreL1_ || (!trigbit_.empty() && select)) {
    analyzeHcal(Hithf, 1, true);
  } else if ((!ignoreL1_) && (trigbit_.empty())) {
    edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
    iEvent.getByToken(tok_hltL1GtMap_, gtObjectMapRecord);
    if (gtObjectMapRecord.isValid()) {
      const std::vector<L1GlobalTriggerObjectMap>& objMapVec = gtObjectMapRecord->gtObjectMap();
      bool ok(false);
      for (std::vector<L1GlobalTriggerObjectMap>::const_iterator itMap = objMapVec.begin();
       itMap != objMapVec.end(); ++itMap) {
    bool resultGt = (*itMap).algoGtlResult();
    if (resultGt) {
      int algoBit = (*itMap).algoBitNumber();
      analyzeHcal(Hithf, algoBit, (!ok));
      ok          = true;
    } 
      }
      if (!ok) {
    edm::LogVerbatim("RecAnalyzer") << "No passed L1 Trigger found";
      }
    }
  }
}

void RecAnalyzerHF::analyzeHcal(const HFPreRecHitCollection & Hithf,
                int algoBit, bool fill) {
#ifdef EDM_ML_DEBUG 
  edm::LogVerbatim("RecAnalyzer") << "Enter analyzeHcal for bit " << algoBit
                  << " Fill " << fill << " Collection size "
                  << Hithf.size();
#endif
  // Signal part for HF
  for (const auto & hfItr : Hithf) {
    HcalDetId hid = hfItr.id(); 
    double e0     = (hfItr.getHFQIE10Info(0)==nullptr) ? 0 : hfItr.getHFQIE10Info(0)->energy();
    double e1     = (hfItr.getHFQIE10Info(1)==nullptr) ? 0 : hfItr.getHFQIE10Info(1)->energy();
    double energy = e0+e1;
    if (std::abs(energy) < 1e-6) energy = (energy > 0) ? 1e-6 : -1e-6;
    double f1(e0), f2(e1);
    if (ratio_) {
      f1         /= energy;
      f2         /= energy;
    }
#ifdef EDM_ML_DEBUG 
    edm::LogVerbatim("RecAnalyzer") << hid << " E " << e0 << ":" << e1 
                    << " F " << f1 << ":" << f2;
#endif
    if (fill) {
      for (unsigned int i = 0; i < hcalID_.size(); i++) {
    if (hcalID_[i] == hid.rawId()) {
      histo_[i].first->Fill(f1);
      histo_[i].second->Fill(f2);
      break;
    }
      }
      hist_[0]->Fill(f1);
      hist_[1]->Fill(f2);
    }

    //
    // Remove PMT hits
    //
    if (((noise_ || nzs_) && fabs(energy) <= 40.) || 
    (energy >= eLowHF_ && energy <= eHighHF_)) {
      std::map<std::pair<int,HcalDetId>,myInfo>::iterator itr1 = myMap_.find(std::pair<int,HcalDetId>(algoBit,hid));
      if (itr1 == myMap_.end()) {
    myInfo info;
    myMap_[std::pair<int,HcalDetId>(algoBit,hid)] = info;
    itr1 = myMap_.find(std::pair<int,HcalDetId>(algoBit,hid));
      }
      itr1->second.kount   += 1.0;
      itr1->second.f11     += (f1);
      itr1->second.f12     += (f1*f1);
      itr1->second.f13     += (f1*f1*f1);
      itr1->second.f14     += (f1*f1*f1*f1);
      itr1->second.f21     += (f2);
      itr1->second.f22     += (f2*f2);
      itr1->second.f23     += (f2*f2*f2);
      itr1->second.f24     += (f2*f2*f2*f2);
      itr1->second.runcheck = rnnum_;
    }
  }
}

//define this as a plug-in                                                      
#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(RecAnalyzerHF);