PFJetDQMPostProcessor.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    Validation/RecoParticleFlow
// Class:      PFJetDQMPostProcessor.cc
//
// Main Developer:   "Juska Pekkanen"
// Original Author:  "Kenichi Hatakeyama"
//

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

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

#include "TCanvas.h"

//
// class declaration
//

class PFJetDQMPostProcessor : public DQMEDHarvester {
public:
  explicit PFJetDQMPostProcessor(const edm::ParameterSet&);
  ~PFJetDQMPostProcessor() override;

private:
  void dqmEndJob(DQMStore::IBooker&, DQMStore::IGetter&) override;
  void fitResponse(TH1F* hreso,
                   TH1F* h_genjet_pt,
                   int ptbinlow,
                   int ietahigh,
                   double recoptcut,
                   double& resp,
                   double& resp_err,
                   double& reso,
                   double& reso_err);
  double getRespUnc(double width, double width_err, double mean, double mean_err);

  std::string jetResponseDir;
  std::string genjetDir;
  std::vector<double> ptBins;
  std::vector<double> etaBins;

  double recoptcut;

  bool debug = false;

  std::string seta(double eta) {
    std::string seta = std::to_string(int(eta * 10.));
    if (seta.length() < 2)
      seta = "0" + seta;
    return seta;
  }

  std::string spt(double ptmin, double ptmax) {
    std::string spt = std::to_string(int(ptmin)) + "_" + std::to_string(int(ptmax));
    return spt;
  }
};

// Some switches
//
// constuctors and destructor
//
PFJetDQMPostProcessor::PFJetDQMPostProcessor(const edm::ParameterSet& iConfig) {
  jetResponseDir = iConfig.getParameter<std::string>("jetResponseDir");
  genjetDir = iConfig.getParameter<std::string>("genjetDir");
  ptBins = iConfig.getParameter<std::vector<double> >("ptBins");
  etaBins = iConfig.getParameter<std::vector<double> >("etaBins");
  recoptcut = iConfig.getParameter<double>("recoPtCut");
}

PFJetDQMPostProcessor::~PFJetDQMPostProcessor() {}

// ------------ method called right after a run ends ------------
void PFJetDQMPostProcessor::dqmEndJob(DQMStore::IBooker& ibook_, DQMStore::IGetter& iget_) {
  //
  iget_.setCurrentFolder(genjetDir);
  std::vector<std::string> sME_genjets = iget_.getMEs();
  std::for_each(sME_genjets.begin(), sME_genjets.end(), [&](auto& s) { s.insert(0, genjetDir.c_str()); });
  //for (unsigned int i=0; i<sME_genjets.size(); i++) std::cout << sME_genjets[i] << std::endl;

  iget_.setCurrentFolder(jetResponseDir);
  std::vector<std::string> sME_response = iget_.getMEs();
  std::for_each(sME_response.begin(), sME_response.end(), [&](auto& s) { s.insert(0, jetResponseDir); });
  //for (unsigned int i=0; i<sME_response.size(); i++) std::cout << sME_response[i] << std::endl;

  iget_.setCurrentFolder(jetResponseDir);

  double ptBinsArray[ptBins.size()];
  unsigned int nPtBins = ptBins.size() - 1;
  std::copy(ptBins.begin(), ptBins.end(), ptBinsArray);
  //for(unsigned int ipt = 0; ipt < ptBins.size(); ++ipt) std::cout << ptBins[ipt] << std::endl;

  std::string stitle;
  char ctitle[50];
  std::vector<MonitorElement*> vME_presponse;
  std::vector<MonitorElement*> vME_preso;
  std::vector<MonitorElement*> vME_preso_rms;

  MonitorElement* me;
  TH1F* h_resp;
  TH1F* h_genjet_pt;

  //
  // Response distributions
  //
  for (unsigned int ieta = 1; ieta < etaBins.size(); ++ieta) {
    stitle = genjetDir + "genjet_pt" + "_eta" + seta(etaBins[ieta]);
    //std::cout << ieta << " " << stitle << std::endl;
    std::vector<std::string>::const_iterator it = std::find(sME_genjets.begin(), sME_genjets.end(), stitle);
    if (it == sME_genjets.end())
      continue;
    me = iget_.get(stitle);
    h_genjet_pt = (TH1F*)me->getTH1F();

    stitle = "presponse_eta" + seta(etaBins[ieta]);
    sprintf(ctitle, "Jet pT response, %4.1f<|#eta|<%4.1f", etaBins[ieta - 1], etaBins[ieta]);
    TH1F* h_presponse = new TH1F(stitle.c_str(), ctitle, nPtBins, ptBinsArray);

    stitle = "preso_eta" + seta(etaBins[ieta]);
    sprintf(ctitle, "Jet pT resolution, %4.1f<|#eta|<%4.1f", etaBins[ieta - 1], etaBins[ieta]);
    TH1F* h_preso = new TH1F(stitle.c_str(), ctitle, nPtBins, ptBinsArray);

    stitle = "preso_eta" + seta(etaBins[ieta]) + "_rms";
    sprintf(ctitle, "Jet pT resolution using RMS, %4.1f<|#eta|<%4.1f", etaBins[ieta - 1], etaBins[ieta]);
    TH1F* h_preso_rms = new TH1F(stitle.c_str(), ctitle, nPtBins, ptBinsArray);

    for (unsigned int ipt = 0; ipt < ptBins.size() - 1; ++ipt) {
      stitle = jetResponseDir + "reso_dist_" + spt(ptBins[ipt], ptBins[ipt + 1]) + "_eta" + seta(etaBins[ieta]);
      std::vector<std::string>::const_iterator it = std::find(sME_response.begin(), sME_response.end(), stitle);
      if (it == sME_response.end())
        continue;
      me = iget_.get(stitle);
      h_resp = (TH1F*)me->getTH1F();

      // Fit-based
      double resp = 1.0, resp_err = 0.0, reso = 0.0, reso_err = 0.0;
      fitResponse(h_resp, h_genjet_pt, ipt, ieta, recoptcut, resp, resp_err, reso, reso_err);

      h_presponse->SetBinContent(ipt + 1, resp);
      h_presponse->SetBinError(ipt + 1, resp_err);
      h_preso->SetBinContent(ipt + 1, reso);
      h_preso->SetBinError(ipt + 1, reso_err);

      // RMS-based
      double std = h_resp->GetStdDev();
      double std_error = h_resp->GetStdDevError();

      // Scale each bin with mean response
      double mean = 1.0;
      double mean_error = 0.0;
      double err = 0.0;
      if (h_resp->GetMean() > 0) {
        mean = h_resp->GetMean();
        mean_error = h_resp->GetMeanError();

        // Scale resolution by response.
        std /= mean;
        std_error /= mean;

        err = getRespUnc(std, std_error, mean, mean_error);
      }

      h_preso_rms->SetBinContent(ipt + 1, std);
      h_preso_rms->SetBinError(ipt + 1, err);

    }  // ipt

    stitle = "presponse_eta" + seta(etaBins[ieta]);
    me = ibook_.book1D(stitle.c_str(), h_presponse);
    vME_presponse.push_back(me);

    stitle = "preso_eta" + seta(etaBins[ieta]);
    me = ibook_.book1D(stitle.c_str(), h_preso);
    vME_preso.push_back(me);

    stitle = "preso_eta" + seta(etaBins[ieta]) + "_rms";
    me = ibook_.book1D(stitle.c_str(), h_preso_rms);
    vME_preso_rms.push_back(me);

  }  // ieta

  //
  // Checks
  //
  if (debug) {
    for (std::vector<MonitorElement*>::const_iterator i = vME_presponse.begin(); i != vME_presponse.end(); ++i)
      (*i)->getTH1F()->Print();
    for (std::vector<MonitorElement*>::const_iterator i = vME_preso.begin(); i != vME_preso.end(); ++i)
      (*i)->getTH1F()->Print();
    for (std::vector<MonitorElement*>::const_iterator i = vME_preso_rms.begin(); i != vME_preso_rms.end(); ++i)
      (*i)->getTH1F()->Print();
  }
}

void PFJetDQMPostProcessor::fitResponse(TH1F* hreso,
                                        TH1F* h_genjet_pt,
                                        int ptbinlow,
                                        int ietahigh,
                                        double recoptcut,
                                        double& resp,
                                        double& resp_err,
                                        double& reso,
                                        double& reso_err) {
  // This 'smartfitter' is converted from the original Python smart_fit() -function
  // implemented in test/helperFunctions.py. See that file for more commentary.
  // Juska 23 May 2019

  // Only do plots if needed for debugging
  // NOTE a directory called 'debug' must exist in the working directory
  //
  bool doPlots = false;

  double ptlow = ptBins[ptbinlow];
  double pthigh = ptBins[ptbinlow + 1];

  // Take range by Mikko's advice: -1.5 and + 1.5 * RMS width

  double rmswidth = hreso->GetStdDev();
  double rmsmean = hreso->GetMean();
  double fitlow = rmsmean - 1.5 * rmswidth;
  fitlow = TMath::Max(recoptcut / ptlow, fitlow);
  double fithigh = rmsmean + 1.5 * rmswidth;

  TF1* fg = new TF1("mygaus", "gaus", fitlow, fithigh);
  TF1* fg2 = new TF1("fg2", "TMath::Gaus(x,[0],[1],true)*[2]", fitlow, fithigh);

  hreso->Fit("mygaus", "RQN");

  fg2->SetParameter(0, fg->GetParameter(1));
  fg2->SetParameter(1, fg->GetParameter(2));

  // Extract ngenjet in the current pT bin from the genjet histo
  float ngenjet = h_genjet_pt->GetBinContent(ptbinlow + 1);

  // Here the fit is forced to take the area of ngenjets.
  // The area is further normalized for the response histogram x-axis length
  // (3) and number of bins (100)
  fg2->FixParameter(2, ngenjet * 3. / 100.);

  hreso->Fit("fg2", "RQN");

  fitlow = fg2->GetParameter(0) - 1.5 * fg2->GetParameter(1);
  fitlow = TMath::Max(15. / ptlow, fitlow);
  fithigh = fg2->GetParameter(0) + 1.5 * fg2->GetParameter(1);

  fg2->SetRange(fitlow, fithigh);

  hreso->Fit("fg2", "RQ");

  fg->SetRange(0, 3);
  fg2->SetRange(0, 3);
  fg->SetLineWidth(2);
  fg2->SetLineColor(kGreen + 2);

  hreso->GetXaxis()->SetRangeUser(0, 2);

  // Save plots to a subdirectory if asked (debug-directory must exist!)
  if (doPlots & (hreso->GetEntries() > 0)) {
    TCanvas* cfit = new TCanvas(Form("respofit_%i", int(ptlow)), "respofit", 600, 600);
    hreso->Draw("ehist");
    fg->Draw("same");
    fg2->Draw("same");
    cfit->SaveAs(
        Form("debug/respo_smartfit_%04d_%i_eta%s.pdf", (int)ptlow, (int)pthigh, seta(etaBins[ietahigh]).c_str()));
  }

  resp = fg2->GetParameter(0);
  resp_err = fg2->GetParError(0);

  // Scale resolution by response. Avoid division by zero.
  if (0 == resp)
    reso = 0;
  else
    reso = fg2->GetParameter(1) / resp;
  reso_err = fg2->GetParError(1) / resp;

  reso_err = getRespUnc(reso, reso_err, resp, resp_err);
}

// Calculate resolution uncertainty
double PFJetDQMPostProcessor::getRespUnc(double width, double width_err, double mean, double mean_err) {
  if (0 == width || 0 == mean)
    return 0;
  return TMath::Sqrt(pow(width_err, 2) / pow(width, 2) + pow(mean_err, 2) / pow(mean, 2)) * width;
}

#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE(PFJetDQMPostProcessor);