d9/d3c/MtdTracksHarvester_8cc_source.html

 #include <string>

 #include "FWCore/Framework/interface/MakerMacros.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "FWCore/ServiceRegistry/interface/Service.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"

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

 #include "DataFormats/ForwardDetId/interface/ETLDetId.h"

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

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

 protected:
   void dqmEndJob(DQMStore::IBooker&, DQMStore::IGetter&) override;

 private:
   void computeEfficiency1D(MonitorElement* num, MonitorElement* den, MonitorElement* result);
   void normalize(MonitorElement* h, double scale);

   const std::string folder_;

   // --- Histograms
   MonitorElement* meBtlEtaEff_;
   MonitorElement* meBtlPhiEff_;
   MonitorElement* meBtlPtEff_;
   MonitorElement* meEtlEtaEff_[2];
   MonitorElement* meEtlPhiEff_[2];
   MonitorElement* meEtlPtEff_[2];
   MonitorElement* meEtlEtaEff2_[2];
   MonitorElement* meEtlPhiEff2_[2];
   MonitorElement* meEtlPtEff2_[2];
   MonitorElement* meMVAPtSelEff_;
   MonitorElement* meMVAEtaSelEff_;
   MonitorElement* meMVAPtMatchEff_;
   MonitorElement* meMVAEtaMatchEff_;
   MonitorElement* meTPPtSelEff_;
   MonitorElement* meTPEtaSelEff_;
   MonitorElement* meTPPtMatchEff_;
   MonitorElement* meTPEtaMatchEff_;
   MonitorElement* meTPPtMatchEtl2Eff_;
   MonitorElement* meTPEtaMatchEtl2Eff_;
   MonitorElement* meTPmtdPtSelEff_;
   MonitorElement* meTPmtdEtaSelEff_;
   MonitorElement* meTPmtdPtMatchEff_;
   MonitorElement* meTPmtdEtaMatchEff_;
   MonitorElement* meNoTimeFraction_;
   MonitorElement* meExtraPtEff_;
   MonitorElement* meExtraPtEtl2Eff_;
   MonitorElement* meExtraEtaEff_;
   MonitorElement* meExtraEtaEtl2Eff_;
   MonitorElement* meExtraPhiAtBTLEff_;
   MonitorElement* meExtraMTDfailExtenderEtaEff_;
   MonitorElement* meExtraMTDfailExtenderPtEff_;
 };

 // ------------ constructor and destructor --------------
 MtdTracksHarvester::MtdTracksHarvester(const edm::ParameterSet& iConfig)
     : folder_(iConfig.getParameter<std::string>("folder")) {}

 MtdTracksHarvester::~MtdTracksHarvester() {}

 // auxiliary method to compute efficiency from the ratio of two 1D MonitorElement
 void MtdTracksHarvester::computeEfficiency1D(MonitorElement* num, MonitorElement* den, MonitorElement* result) {
   for (int ibin = 1; ibin <= den->getNbinsX(); ibin++) {
     double eff = num->getBinContent(ibin) / den->getBinContent(ibin);
     double bin_err = sqrt((num->getBinContent(ibin) * (den->getBinContent(ibin) - num->getBinContent(ibin))) /
                           pow(den->getBinContent(ibin), 3));
     if (den->getBinContent(ibin) == 0) {
       eff = 0;
       bin_err = 0;
     }
     result->setBinContent(ibin, eff);
     result->setBinError(ibin, bin_err);
   }
 }

 void MtdTracksHarvester::normalize(MonitorElement* h, double scale) {
   double integral = h->getTH1F()->Integral();
   double norma = (integral > 0.) ? scale / integral : 0.;
   for (int ibin = 1; ibin <= h->getNbinsX(); ibin++) {
     double eff = h->getBinContent(ibin) * norma;
     double bin_err = h->getBinError(ibin) * norma;
     h->setBinContent(ibin, eff);
     h->setBinError(ibin, bin_err);
   }
 }

 // ------------ endjob tasks ----------------------------
 void MtdTracksHarvester::dqmEndJob(DQMStore::IBooker& ibook, DQMStore::IGetter& igetter) {
   // --- Get the monitoring histograms
   MonitorElement* meBTLTrackEffEtaTot = igetter.get(folder_ + "TrackBTLEffEtaTot");
   MonitorElement* meBTLTrackEffPhiTot = igetter.get(folder_ + "TrackBTLEffPhiTot");
   MonitorElement* meBTLTrackEffPtTot = igetter.get(folder_ + "TrackBTLEffPtTot");
   MonitorElement* meBTLTrackEffEtaMtd = igetter.get(folder_ + "TrackBTLEffEtaMtd");
   MonitorElement* meBTLTrackEffPhiMtd = igetter.get(folder_ + "TrackBTLEffPhiMtd");
   MonitorElement* meBTLTrackEffPtMtd = igetter.get(folder_ + "TrackBTLEffPtMtd");
   MonitorElement* meETLTrackEffEtaTotZneg = igetter.get(folder_ + "TrackETLEffEtaTotZneg");
   MonitorElement* meETLTrackEffPhiTotZneg = igetter.get(folder_ + "TrackETLEffPhiTotZneg");
   MonitorElement* meETLTrackEffPtTotZneg = igetter.get(folder_ + "TrackETLEffPtTotZneg");
   MonitorElement* meETLTrackEffEtaMtdZneg = igetter.get(folder_ + "TrackETLEffEtaMtdZneg");
   MonitorElement* meETLTrackEffPhiMtdZneg = igetter.get(folder_ + "TrackETLEffPhiMtdZneg");
   MonitorElement* meETLTrackEffPtMtdZneg = igetter.get(folder_ + "TrackETLEffPtMtdZneg");
   MonitorElement* meETLTrackEffEta2MtdZneg = igetter.get(folder_ + "TrackETLEffEta2MtdZneg");
   MonitorElement* meETLTrackEffPhi2MtdZneg = igetter.get(folder_ + "TrackETLEffPhi2MtdZneg");
   MonitorElement* meETLTrackEffPt2MtdZneg = igetter.get(folder_ + "TrackETLEffPt2MtdZneg");
   MonitorElement* meETLTrackEffEtaTotZpos = igetter.get(folder_ + "TrackETLEffEtaTotZpos");
   MonitorElement* meETLTrackEffPhiTotZpos = igetter.get(folder_ + "TrackETLEffPhiTotZpos");
   MonitorElement* meETLTrackEffPtTotZpos = igetter.get(folder_ + "TrackETLEffPtTotZpos");
   MonitorElement* meETLTrackEffEtaMtdZpos = igetter.get(folder_ + "TrackETLEffEtaMtdZpos");
   MonitorElement* meETLTrackEffPhiMtdZpos = igetter.get(folder_ + "TrackETLEffPhiMtdZpos");
   MonitorElement* meETLTrackEffPtMtdZpos = igetter.get(folder_ + "TrackETLEffPtMtdZpos");
   MonitorElement* meETLTrackEffEta2MtdZpos = igetter.get(folder_ + "TrackETLEffEta2MtdZpos");
   MonitorElement* meETLTrackEffPhi2MtdZpos = igetter.get(folder_ + "TrackETLEffPhi2MtdZpos");
   MonitorElement* meETLTrackEffPt2MtdZpos = igetter.get(folder_ + "TrackETLEffPt2MtdZpos");
   MonitorElement* meTrackPtTot = igetter.get(folder_ + "TrackPtTot");
   MonitorElement* meMVATrackEffPtTot = igetter.get(folder_ + "MVAEffPtTot");
   MonitorElement* meMVATrackMatchedEffPtTot = igetter.get(folder_ + "MVAMatchedEffPtTot");
   MonitorElement* meMVATrackMatchedEffPtMtd = igetter.get(folder_ + "MVAMatchedEffPtMtd");
   MonitorElement* meExtraPtMtd = igetter.get(folder_ + "ExtraPtMtd");
   MonitorElement* meExtraPtEtl2Mtd = igetter.get(folder_ + "ExtraPtEtl2Mtd");
   MonitorElement* meTrackMatchedTPEffPtTot = igetter.get(folder_ + "MatchedTPEffPtTot");
   MonitorElement* meTrackMatchedTPEffPtMtd = igetter.get(folder_ + "MatchedTPEffPtMtd");
   MonitorElement* meTrackMatchedTPEffPtEtl2Mtd = igetter.get(folder_ + "MatchedTPEffPtEtl2Mtd");
   MonitorElement* meTrackMatchedTPmtdEffPtTot = igetter.get(folder_ + "MatchedTPmtdEffPtTot");
   MonitorElement* meTrackMatchedTPmtdEffPtMtd = igetter.get(folder_ + "MatchedTPmtdEffPtMtd");
   MonitorElement* meTrackEtaTot = igetter.get(folder_ + "TrackEtaTot");
   MonitorElement* meMVATrackEffEtaTot = igetter.get(folder_ + "MVAEffEtaTot");
   MonitorElement* meMVATrackMatchedEffEtaTot = igetter.get(folder_ + "MVAMatchedEffEtaTot");
   MonitorElement* meMVATrackMatchedEffEtaMtd = igetter.get(folder_ + "MVAMatchedEffEtaMtd");
   MonitorElement* meExtraEtaMtd = igetter.get(folder_ + "ExtraEtaMtd");
   MonitorElement* meExtraEtaEtl2Mtd = igetter.get(folder_ + "ExtraEtaEtl2Mtd");
   MonitorElement* meTrackMatchedTPEffEtaTot = igetter.get(folder_ + "MatchedTPEffEtaTot");
   MonitorElement* meTrackMatchedTPEffEtaMtd = igetter.get(folder_ + "MatchedTPEffEtaMtd");
   MonitorElement* meTrackMatchedTPEffEtaEtl2Mtd = igetter.get(folder_ + "MatchedTPEffEtaEtl2Mtd");
   MonitorElement* meTrackMatchedTPmtdEffEtaTot = igetter.get(folder_ + "MatchedTPmtdEffEtaTot");
   MonitorElement* meTrackMatchedTPmtdEffEtaMtd = igetter.get(folder_ + "MatchedTPmtdEffEtaMtd");
   MonitorElement* meTrackNumHits = igetter.get(folder_ + "TrackNumHits");
   MonitorElement* meTrackNumHitsNT = igetter.get(folder_ + "TrackNumHitsNT");
   MonitorElement* meExtraPhiAtBTL = igetter.get(folder_ + "ExtraPhiAtBTL");
   MonitorElement* meExtraPhiAtBTLmatched = igetter.get(folder_ + "ExtraPhiAtBTLmatched");
   MonitorElement* meExtraBTLeneInCone = igetter.get(folder_ + "ExtraBTLeneInCone");
   MonitorElement* meExtraMTDfailExtenderEta = igetter.get(folder_ + "ExtraMTDfailExtenderEta");
   MonitorElement* meExtraMTDfailExtenderPt = igetter.get(folder_ + "ExtraMTDfailExtenderPt");

   if (!meBTLTrackEffEtaTot || !meBTLTrackEffPhiTot || !meBTLTrackEffPtTot || !meBTLTrackEffEtaMtd ||
       !meBTLTrackEffPhiMtd || !meBTLTrackEffPtMtd || !meETLTrackEffEtaTotZneg || !meETLTrackEffPhiTotZneg ||
       !meETLTrackEffPtTotZneg || !meETLTrackEffEtaMtdZneg || !meETLTrackEffPhiMtdZneg || !meETLTrackEffPtMtdZneg ||
       !meETLTrackEffEta2MtdZneg || !meETLTrackEffPhi2MtdZneg || !meETLTrackEffPt2MtdZneg || !meETLTrackEffEtaTotZpos ||
       !meETLTrackEffPhiTotZpos || !meETLTrackEffPtTotZpos || !meETLTrackEffEtaMtdZpos || !meETLTrackEffPhiMtdZpos ||
       !meETLTrackEffPtMtdZpos || !meETLTrackEffEta2MtdZpos || !meETLTrackEffPhi2MtdZpos || !meETLTrackEffPt2MtdZpos ||
       !meMVATrackEffPtTot || !meMVATrackMatchedEffPtTot || !meMVATrackMatchedEffPtMtd || !meMVATrackEffEtaTot ||
       !meMVATrackMatchedEffEtaTot || !meMVATrackMatchedEffEtaMtd || !meTrackMatchedTPEffPtTot ||
       !meTrackMatchedTPEffPtMtd || !meTrackMatchedTPEffPtEtl2Mtd || !meTrackMatchedTPmtdEffPtTot ||
       !meTrackMatchedTPmtdEffPtMtd || !meTrackMatchedTPEffEtaTot || !meTrackMatchedTPEffEtaMtd ||
       !meTrackMatchedTPEffEtaEtl2Mtd || !meTrackMatchedTPmtdEffEtaTot || !meTrackMatchedTPmtdEffEtaMtd ||
       !meTrackNumHits || !meTrackNumHitsNT || !meTrackPtTot || !meTrackEtaTot || !meExtraPtMtd || !meExtraPtEtl2Mtd ||
       !meExtraEtaMtd || !meExtraEtaEtl2Mtd || !meExtraPhiAtBTL || !meExtraPhiAtBTLmatched || !meExtraBTLeneInCone ||
       !meExtraMTDfailExtenderEta || !meExtraMTDfailExtenderPt) {
     edm::LogError("MtdTracksHarvester") << "Monitoring histograms not found!" << std::endl;
     return;
   }

   // --- Book  histograms
   ibook.cd(folder_);
   meBtlEtaEff_ = ibook.book1D("BtlEtaEff",
                               " Track Efficiency VS Eta;#eta;Efficiency",
                               meBTLTrackEffEtaTot->getNbinsX(),
                               meBTLTrackEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                               meBTLTrackEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meBtlEtaEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meBTLTrackEffEtaMtd, meBTLTrackEffEtaTot, meBtlEtaEff_);

   meBtlPhiEff_ = ibook.book1D("BtlPhiEff",
                               "Track Efficiency VS Phi;#phi [rad];Efficiency",
                               meBTLTrackEffPhiTot->getNbinsX(),
                               meBTLTrackEffPhiTot->getTH1()->GetXaxis()->GetXmin(),
                               meBTLTrackEffPhiTot->getTH1()->GetXaxis()->GetXmax());
   meBtlPhiEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meBTLTrackEffPhiMtd, meBTLTrackEffPhiTot, meBtlPhiEff_);

   meBtlPtEff_ = ibook.book1D("BtlPtEff",
                              "Track Efficiency VS Pt;Pt [GeV];Efficiency",
                              meBTLTrackEffPtTot->getNbinsX(),
                              meBTLTrackEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                              meBTLTrackEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meBtlPtEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meBTLTrackEffPtMtd, meBTLTrackEffPtTot, meBtlPtEff_);

   meEtlEtaEff_[0] = ibook.book1D("EtlEtaEffZneg",
                                  " Track Efficiency VS Eta (-Z);#eta;Efficiency",
                                  meETLTrackEffEtaTotZneg->getNbinsX(),
                                  meETLTrackEffEtaTotZneg->getTH1()->GetXaxis()->GetXmin(),
                                  meETLTrackEffEtaTotZneg->getTH1()->GetXaxis()->GetXmax());
   meEtlEtaEff_[0]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffEtaMtdZneg, meETLTrackEffEtaTotZneg, meEtlEtaEff_[0]);

   meEtlPhiEff_[0] = ibook.book1D("EtlPhiEffZneg",
                                  "Track Efficiency VS Phi (-Z);#phi [rad];Efficiency",
                                  meETLTrackEffPhiTotZneg->getNbinsX(),
                                  meETLTrackEffPhiTotZneg->getTH1()->GetXaxis()->GetXmin(),
                                  meETLTrackEffPhiTotZneg->getTH1()->GetXaxis()->GetXmax());
   meEtlPhiEff_[0]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPhiMtdZneg, meETLTrackEffPhiTotZneg, meEtlPhiEff_[0]);

   meEtlPtEff_[0] = ibook.book1D("EtlPtEffZneg",
                                 "Track Efficiency VS Pt (-Z);Pt [GeV];Efficiency",
                                 meETLTrackEffPtTotZneg->getNbinsX(),
                                 meETLTrackEffPtTotZneg->getTH1()->GetXaxis()->GetXmin(),
                                 meETLTrackEffPtTotZneg->getTH1()->GetXaxis()->GetXmax());
   meEtlPtEff_[0]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPtMtdZneg, meETLTrackEffPtTotZneg, meEtlPtEff_[0]);

   meEtlEtaEff_[1] = ibook.book1D("EtlEtaEffZpos",
                                  " Track Efficiency VS Eta (+Z);#eta;Efficiency",
                                  meETLTrackEffEtaTotZpos->getNbinsX(),
                                  meETLTrackEffEtaTotZpos->getTH1()->GetXaxis()->GetXmin(),
                                  meETLTrackEffEtaTotZpos->getTH1()->GetXaxis()->GetXmax());
   meEtlEtaEff_[1]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffEtaMtdZpos, meETLTrackEffEtaTotZpos, meEtlEtaEff_[1]);

   meEtlPhiEff_[1] = ibook.book1D("EtlPhiEffZpos",
                                  "Track Efficiency VS Phi (+Z);#phi [rad];Efficiency",
                                  meETLTrackEffPhiTotZpos->getNbinsX(),
                                  meETLTrackEffPhiTotZpos->getTH1()->GetXaxis()->GetXmin(),
                                  meETLTrackEffPhiTotZpos->getTH1()->GetXaxis()->GetXmax());
   meEtlPhiEff_[1]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPhiMtdZpos, meETLTrackEffPhiTotZpos, meEtlPhiEff_[1]);

   meEtlPtEff_[1] = ibook.book1D("EtlPtEffZpos",
                                 "Track Efficiency VS Pt (+Z);Pt [GeV];Efficiency",
                                 meETLTrackEffPtTotZpos->getNbinsX(),
                                 meETLTrackEffPtTotZpos->getTH1()->GetXaxis()->GetXmin(),
                                 meETLTrackEffPtTotZpos->getTH1()->GetXaxis()->GetXmax());
   meEtlPtEff_[1]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPtMtdZpos, meETLTrackEffPtTotZpos, meEtlPtEff_[1]);

   meEtlEtaEff2_[0] = ibook.book1D("EtlEtaEff2Zneg",
                                   " Track Efficiency VS Eta (-Z, 2 hit);#eta;Efficiency",
                                   meETLTrackEffEtaTotZneg->getNbinsX(),
                                   meETLTrackEffEtaTotZneg->getTH1()->GetXaxis()->GetXmin(),
                                   meETLTrackEffEtaTotZneg->getTH1()->GetXaxis()->GetXmax());
   meEtlEtaEff2_[0]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffEta2MtdZneg, meETLTrackEffEtaTotZneg, meEtlEtaEff2_[0]);

   meEtlPhiEff2_[0] = ibook.book1D("EtlPhiEff2Zneg",
                                   "Track Efficiency VS Phi (-Z, 2 hit);#phi [rad];Efficiency",
                                   meETLTrackEffPhiTotZneg->getNbinsX(),
                                   meETLTrackEffPhiTotZneg->getTH1()->GetXaxis()->GetXmin(),
                                   meETLTrackEffPhiTotZneg->getTH1()->GetXaxis()->GetXmax());
   meEtlPhiEff2_[0]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPhi2MtdZneg, meETLTrackEffPhiTotZneg, meEtlPhiEff2_[0]);

   meEtlPtEff2_[0] = ibook.book1D("EtlPtEff2Zneg",
                                  "Track Efficiency VS Pt (-Z, 2 hit);Pt [GeV];Efficiency",
                                  meETLTrackEffPtTotZneg->getNbinsX(),
                                  meETLTrackEffPtTotZneg->getTH1()->GetXaxis()->GetXmin(),
                                  meETLTrackEffPtTotZneg->getTH1()->GetXaxis()->GetXmax());
   meEtlPtEff2_[0]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPt2MtdZneg, meETLTrackEffPtTotZneg, meEtlPtEff2_[0]);

   meEtlEtaEff2_[1] = ibook.book1D("EtlEtaEff2Zpos",
                                   "Track Efficiency VS Eta (+Z, 2 hit);#eta;Efficiency",
                                   meETLTrackEffEtaTotZpos->getNbinsX(),
                                   meETLTrackEffEtaTotZpos->getTH1()->GetXaxis()->GetXmin(),
                                   meETLTrackEffEtaTotZpos->getTH1()->GetXaxis()->GetXmax());
   meEtlEtaEff2_[1]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffEta2MtdZpos, meETLTrackEffEtaTotZpos, meEtlEtaEff2_[1]);

   meEtlPhiEff2_[1] = ibook.book1D("EtlPhiEff2Zpos",
                                   "Track Efficiency VS Phi (+Z, 2 hit);#phi [rad];Efficiency",
                                   meETLTrackEffPhiTotZpos->getNbinsX(),
                                   meETLTrackEffPhiTotZpos->getTH1()->GetXaxis()->GetXmin(),
                                   meETLTrackEffPhiTotZpos->getTH1()->GetXaxis()->GetXmax());
   meEtlPhiEff2_[1]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPhi2MtdZpos, meETLTrackEffPhiTotZpos, meEtlPhiEff2_[1]);

   meEtlPtEff2_[1] = ibook.book1D("EtlPtEff2Zpos",
                                  "Track Efficiency VS Pt (+Z, 2 hit);Pt [GeV];Efficiency",
                                  meETLTrackEffPtTotZpos->getNbinsX(),
                                  meETLTrackEffPtTotZpos->getTH1()->GetXaxis()->GetXmin(),
                                  meETLTrackEffPtTotZpos->getTH1()->GetXaxis()->GetXmax());
   meEtlPtEff2_[1]->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meETLTrackEffPt2MtdZpos, meETLTrackEffPtTotZpos, meEtlPtEff2_[1]);

   meExtraPtEff_ = ibook.book1D("ExtraPtEff",
                                "MTD matching efficiency wrt extrapolated track VS Pt;Pt [GeV];Efficiency",
                                meMVATrackEffPtTot->getNbinsX(),
                                meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meExtraPtEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meExtraPtMtd, meTrackMatchedTPEffPtTot, meExtraPtEff_);

   meExtraPtEtl2Eff_ = ibook.book1D("ExtraPtEtl2Eff",
                                    "MTD matching efficiency (2 ETL) wrt extrapolated track VS Pt;Pt [GeV];Efficiency",
                                    meMVATrackEffPtTot->getNbinsX(),
                                    meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                    meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meExtraPtEtl2Eff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meExtraPtEtl2Mtd, meTrackMatchedTPEffPtTot, meExtraPtEtl2Eff_);

   meExtraEtaEff_ = ibook.book1D("ExtraEtaEff",
                                 "MTD matching efficiency wrt extrapolated track VS Eta;Eta;Efficiency",
                                 meMVATrackEffEtaTot->getNbinsX(),
                                 meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                 meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meExtraEtaEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meExtraEtaMtd, meTrackMatchedTPEffEtaTot, meExtraEtaEff_);

   meExtraEtaEtl2Eff_ = ibook.book1D("ExtraEtaEtl2Eff",
                                     "MTD matching efficiency (2 ETL) wrt extrapolated track VS Eta;Eta;Efficiency",
                                     meMVATrackEffEtaTot->getNbinsX(),
                                     meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                     meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meExtraEtaEtl2Eff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meExtraEtaEtl2Mtd, meTrackMatchedTPEffEtaTot, meExtraEtaEtl2Eff_);

   meMVAPtSelEff_ = ibook.book1D("MVAPtSelEff",
                                 "Track selected efficiency VS Pt;Pt [GeV];Efficiency",
                                 meMVATrackEffPtTot->getNbinsX(),
                                 meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                 meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meMVAPtSelEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meMVATrackMatchedEffPtTot, meMVATrackEffPtTot, meMVAPtSelEff_);

   meMVAEtaSelEff_ = ibook.book1D("MVAEtaSelEff",
                                  "Track selected efficiency VS Eta;Eta;Efficiency",
                                  meMVATrackEffEtaTot->getNbinsX(),
                                  meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                  meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meMVAEtaSelEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meMVATrackMatchedEffEtaTot, meMVATrackEffEtaTot, meMVAEtaSelEff_);

   meMVAPtMatchEff_ = ibook.book1D("MVAPtMatchEff",
                                   "Track matched to GEN efficiency VS Pt;Pt [GeV];Efficiency",
                                   meMVATrackMatchedEffPtTot->getNbinsX(),
                                   meMVATrackMatchedEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                   meMVATrackMatchedEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meMVAPtMatchEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meMVATrackMatchedEffPtMtd, meMVATrackMatchedEffPtTot, meMVAPtMatchEff_);

   meMVAEtaMatchEff_ = ibook.book1D("MVAEtaMatchEff",
                                    "Track matched to GEN efficiency VS Eta;Eta;Efficiency",
                                    meMVATrackMatchedEffEtaTot->getNbinsX(),
                                    meMVATrackMatchedEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                    meMVATrackMatchedEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meMVAEtaMatchEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meMVATrackMatchedEffEtaMtd, meMVATrackMatchedEffEtaTot, meMVAEtaMatchEff_);

   meTPPtSelEff_ = ibook.book1D("TPPtSelEff",
                                "Track selected efficiency TP VS Pt;Pt [GeV];Efficiency",
                                meMVATrackEffPtTot->getNbinsX(),
                                meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meTPPtSelEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPEffPtTot, meTrackPtTot, meTPPtSelEff_);

   meTPEtaSelEff_ = ibook.book1D("TPEtaSelEff",
                                 "Track selected efficiency TP VS Eta;Eta;Efficiency",
                                 meMVATrackEffEtaTot->getNbinsX(),
                                 meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                 meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meTPEtaSelEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPEffEtaTot, meTrackEtaTot, meTPEtaSelEff_);

   meTPPtMatchEff_ = ibook.book1D("TPPtMatchEff",
                                  "Track matched to TP efficiency VS Pt;Pt [GeV];Efficiency",
                                  meTrackMatchedTPEffPtTot->getNbinsX(),
                                  meTrackMatchedTPEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                  meTrackMatchedTPEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meTPPtMatchEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPEffPtMtd, meTrackMatchedTPEffPtTot, meTPPtMatchEff_);

   meTPEtaMatchEff_ = ibook.book1D("TPEtaMatchEff",
                                   "Track matched to TP efficiency VS Eta;Eta;Efficiency",
                                   meTrackMatchedTPEffEtaTot->getNbinsX(),
                                   meTrackMatchedTPEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                   meTrackMatchedTPEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meTPEtaMatchEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPEffEtaMtd, meTrackMatchedTPEffEtaTot, meTPEtaMatchEff_);

   meTPPtMatchEtl2Eff_ = ibook.book1D("TPPtMatchEtl2Eff",
                                      "Track matched to TP efficiency VS Pt, 2 ETL hits;Pt [GeV];Efficiency",
                                      meTrackMatchedTPEffPtTot->getNbinsX(),
                                      meTrackMatchedTPEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                      meTrackMatchedTPEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meTPPtMatchEtl2Eff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPEffPtEtl2Mtd, meTrackMatchedTPEffPtTot, meTPPtMatchEtl2Eff_);

   meTPEtaMatchEtl2Eff_ = ibook.book1D("TPEtaMatchEtl2Eff",
                                       "Track matched to TP efficiency VS Eta, 2 ETL hits;Eta;Efficiency",
                                       meTrackMatchedTPEffEtaTot->getNbinsX(),
                                       meTrackMatchedTPEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                       meTrackMatchedTPEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meTPEtaMatchEtl2Eff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPEffEtaEtl2Mtd, meTrackMatchedTPEffEtaTot, meTPEtaMatchEtl2Eff_);

   meTPmtdPtSelEff_ = ibook.book1D("TPmtdPtSelEff",
                                   "Track selected efficiency TP-mtd hit VS Pt;Pt [GeV];Efficiency",
                                   meMVATrackEffPtTot->getNbinsX(),
                                   meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                   meMVATrackEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meTPmtdPtSelEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPmtdEffPtTot, meTrackPtTot, meTPmtdPtSelEff_);

   meTPmtdEtaSelEff_ = ibook.book1D("TPmtdEtaSelEff",
                                    "Track selected efficiency TPmtd hit VS Eta;Eta;Efficiency",
                                    meMVATrackEffEtaTot->getNbinsX(),
                                    meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                    meMVATrackEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meTPmtdEtaSelEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPmtdEffEtaTot, meTrackEtaTot, meTPmtdEtaSelEff_);

   meTPmtdPtMatchEff_ = ibook.book1D("TPmtdPtMatchEff",
                                     "Track matched to TP-mtd hit efficiency VS Pt;Pt [GeV];Efficiency",
                                     meTrackMatchedTPmtdEffPtTot->getNbinsX(),
                                     meTrackMatchedTPmtdEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                                     meTrackMatchedTPmtdEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meTPmtdPtMatchEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPmtdEffPtMtd, meTrackMatchedTPmtdEffPtTot, meTPmtdPtMatchEff_);

   meTPmtdEtaMatchEff_ = ibook.book1D("TPmtdEtaMatchEff",
                                      "Track matched to TP-mtd hit efficiency VS Eta;Eta;Efficiency",
                                      meTrackMatchedTPmtdEffEtaTot->getNbinsX(),
                                      meTrackMatchedTPmtdEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                                      meTrackMatchedTPmtdEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meTPmtdEtaMatchEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackMatchedTPmtdEffEtaMtd, meTrackMatchedTPmtdEffEtaTot, meTPmtdEtaMatchEff_);

   meNoTimeFraction_ = ibook.book1D("NoTimeFraction",
                                    "Fraction of tracks with MTD hits and no time associated; Num. of hits",
                                    meTrackNumHits->getNbinsX(),
                                    meTrackNumHits->getTH1()->GetXaxis()->GetXmin(),
                                    meTrackNumHits->getTH1()->GetXaxis()->GetXmax());
   meNoTimeFraction_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meTrackNumHitsNT, meTrackNumHits, meNoTimeFraction_);

   meBtlEtaEff_->getTH1()->SetMinimum(0.);
   meBtlPhiEff_->getTH1()->SetMinimum(0.);
   meBtlPtEff_->getTH1()->SetMinimum(0.);
   for (int i = 0; i < 2; i++) {
     meEtlEtaEff_[i]->getTH1()->SetMinimum(0.);
     meEtlPhiEff_[i]->getTH1()->SetMinimum(0.);
     meEtlPtEff_[i]->getTH1()->SetMinimum(0.);
     meEtlEtaEff2_[i]->getTH1()->SetMinimum(0.);
     meEtlPhiEff2_[i]->getTH1()->SetMinimum(0.);
     meEtlPtEff2_[i]->getTH1()->SetMinimum(0.);
   }
   meMVAPtSelEff_->getTH1()->SetMinimum(0.);
   meMVAEtaSelEff_->getTH1()->SetMinimum(0.);
   meMVAPtMatchEff_->getTH1()->SetMinimum(0.);
   meMVAEtaMatchEff_->getTH1()->SetMinimum(0.);

   meExtraPhiAtBTLEff_ = ibook.book1D("ExtraPhiAtBTLEff",
                                      "Efficiency to match hits at BTL surface",
                                      meExtraPhiAtBTL->getNbinsX(),
                                      meExtraPhiAtBTL->getTH1()->GetXaxis()->GetXmin(),
                                      meExtraPhiAtBTL->getTH1()->GetXaxis()->GetXmax());
   meExtraPhiAtBTLEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meExtraPhiAtBTLmatched, meExtraPhiAtBTL, meExtraPhiAtBTLEff_);

   normalize(meExtraBTLeneInCone, 1.);

   meExtraMTDfailExtenderEtaEff_ =
       ibook.book1D("ExtraMTDfailExtenderEtaEff",
                    "Track extrapolated at MTD surface no extender efficiency VS Eta;Eta;Efficiency",
                    meTrackMatchedTPEffEtaTot->getNbinsX(),
                    meTrackMatchedTPEffEtaTot->getTH1()->GetXaxis()->GetXmin(),
                    meTrackMatchedTPEffEtaTot->getTH1()->GetXaxis()->GetXmax());
   meExtraMTDfailExtenderEtaEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meExtraMTDfailExtenderEta, meTrackMatchedTPEffEtaTot, meExtraMTDfailExtenderEtaEff_);

   meExtraMTDfailExtenderPtEff_ =
       ibook.book1D("ExtraMTDfailExtenderPtEff",
                    "Track extrapolated at MTD surface no extender efficiency VS Pt;Pt [GeV];Efficiency",
                    meTrackMatchedTPEffPtTot->getNbinsX(),
                    meTrackMatchedTPEffPtTot->getTH1()->GetXaxis()->GetXmin(),
                    meTrackMatchedTPEffPtTot->getTH1()->GetXaxis()->GetXmax());
   meExtraMTDfailExtenderPtEff_->getTH1()->SetMinimum(0.);
   computeEfficiency1D(meExtraMTDfailExtenderPt, meTrackMatchedTPEffPtTot, meExtraMTDfailExtenderPtEff_);
 }

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

   desc.add<std::string>("folder", "MTD/Tracks/");

   descriptions.add("MtdTracksPostProcessor", desc);
 }

 DEFINE_FWK_MODULE(MtdTracksHarvester);
MtdTracksHarvester::meExtraPtEff_
MonitorElement * meExtraPtEff_
Definition: MtdTracksHarvester.cc:54

MtdTracksHarvester::meTPEtaMatchEtl2Eff_
MonitorElement * meTPEtaMatchEtl2Eff_
Definition: MtdTracksHarvester.cc:48

MtdTracksHarvester::meExtraMTDfailExtenderPtEff_
MonitorElement * meExtraMTDfailExtenderPtEff_
Definition: MtdTracksHarvester.cc:60

mps_fire.i
i
Definition: mps_fire.py:429

MtdTracksHarvester::MtdTracksHarvester
MtdTracksHarvester(const edm::ParameterSet &iConfig)
Definition: MtdTracksHarvester.cc:64

MtdTracksHarvester::meTPEtaSelEff_
MonitorElement * meTPEtaSelEff_
Definition: MtdTracksHarvester.cc:44

folder_
std::string folder_
Definition: DQMEDAnalyzer.cc:60

ETLDetId.h

MessageLogger.h

mps_fire.result
result
Definition: mps_fire.py:311

dqm::implementation::NavigatorBase::cd
virtual void cd()
Definition: DQMStore.cc:33

MtdTracksHarvester::meEtlEtaEff2_
MonitorElement * meEtlEtaEff2_[2]
Definition: MtdTracksHarvester.cc:36

MtdTracksHarvester::meTPEtaMatchEff_
MonitorElement * meTPEtaMatchEff_
Definition: MtdTracksHarvester.cc:46

MtdTracksHarvester::meExtraEtaEtl2Eff_
MonitorElement * meExtraEtaEtl2Eff_
Definition: MtdTracksHarvester.cc:57

MtdTracksHarvester::meMVAEtaMatchEff_
MonitorElement * meMVAEtaMatchEff_
Definition: MtdTracksHarvester.cc:42

MtdTracksHarvester::meExtraPhiAtBTLEff_
MonitorElement * meExtraPhiAtBTLEff_
Definition: MtdTracksHarvester.cc:58

std
Definition: JetResolutionObject.h:76

DQMEDHarvester.h

edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:129

MtdTracksHarvester::meTPmtdEtaMatchEff_
MonitorElement * meTPmtdEtaMatchEff_
Definition: MtdTracksHarvester.cc:52

dqm::implementation::IGetter
Definition: DQMStore.h:562

AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256

edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52

MtdTracksHarvester::meTPPtSelEff_
MonitorElement * meTPPtSelEff_
Definition: MtdTracksHarvester.cc:43

MtdTracksHarvester
Definition: MtdTracksHarvester.cc:13

ParameterSet.h

MtdTracksHarvester::meEtlPhiEff2_
MonitorElement * meEtlPhiEff2_[2]
Definition: MtdTracksHarvester.cc:37

dqm::implementation::IBooker
Definition: DQMStore.h:43

MtdTracksHarvester::computeEfficiency1D
void computeEfficiency1D(MonitorElement *num, MonitorElement *den, MonitorElement *result)
Definition: MtdTracksHarvester.cc:70

MtdTracksHarvester::dqmEndJob
void dqmEndJob(DQMStore::IBooker &, DQMStore::IGetter &) override
Definition: MtdTracksHarvester.cc:96

MtdTracksHarvester::meMVAPtSelEff_
MonitorElement * meMVAPtSelEff_
Definition: MtdTracksHarvester.cc:39

DQMStore.h

mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19

submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251

dqm::legacy::MonitorElement
Definition: MonitorElement.h:466

MtdTracksHarvester::meEtlPhiEff_
MonitorElement * meEtlPhiEff_[2]
Definition: MtdTracksHarvester.cc:34

MtdTracksHarvester::meTPPtMatchEtl2Eff_
MonitorElement * meTPPtMatchEtl2Eff_
Definition: MtdTracksHarvester.cc:47

Service.h

MtdTracksHarvester::meMVAPtMatchEff_
MonitorElement * meMVAPtMatchEff_
Definition: MtdTracksHarvester.cc:41

DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16

MtdTracksHarvester::meEtlPtEff_
MonitorElement * meEtlPtEff_[2]
Definition: MtdTracksHarvester.cc:35

MtdTracksHarvester::folder_
const std::string folder_
Definition: MtdTracksHarvester.cc:27

MtdTracksHarvester::meBtlPtEff_
MonitorElement * meBtlPtEff_
Definition: MtdTracksHarvester.cc:32

funct::integral
Integral< F, X >::type integral(const F &f)
Definition: Integral.h:70

MtdTracksHarvester::meTPmtdEtaSelEff_
MonitorElement * meTPmtdEtaSelEff_
Definition: MtdTracksHarvester.cc:50

MtdTracksHarvester::normalize
void normalize(MonitorElement *h, double scale)
Definition: MtdTracksHarvester.cc:84

MtdTracksHarvester::meTPPtMatchEff_
MonitorElement * meTPPtMatchEff_
Definition: MtdTracksHarvester.cc:45

EgammaValidation_cff.num
num
Definition: EgammaValidation_cff.py:33

MtdTracksHarvester::meEtlPtEff2_
MonitorElement * meEtlPtEff2_[2]
Definition: MtdTracksHarvester.cc:38

MtdTracksHarvester::meExtraPtEtl2Eff_
MonitorElement * meExtraPtEtl2Eff_
Definition: MtdTracksHarvester.cc:55

MtdTracksHarvester::meExtraEtaEff_
MonitorElement * meExtraEtaEff_
Definition: MtdTracksHarvester.cc:56

edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57

MtdTracksHarvester::meBtlEtaEff_
MonitorElement * meBtlEtaEff_
Definition: MtdTracksHarvester.cc:30

dqm::implementation::IGetter::get
virtual MonitorElement * get(std::string const &fullpath) const
Definition: DQMStore.cc:712

DQMEDHarvester
Definition: DQMEDHarvester.py:1

dqm::legacy::MonitorElement::getTH1
virtual TH1 * getTH1() const
Definition: MonitorElement.h:479

MtdTracksHarvester::~MtdTracksHarvester
~MtdTracksHarvester() override
Definition: MtdTracksHarvester.cc:67

MtdTracksHarvester::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: MtdTracksHarvester.cc:490

pfClustersFromCombinedCaloHF_cfi.scale
scale
Definition: pfClustersFromCombinedCaloHF_cfi.py:51

MtdTracksHarvester::meBtlPhiEff_
MonitorElement * meBtlPhiEff_
Definition: MtdTracksHarvester.cc:31

dqm::impl::MonitorElement::getNbinsX
virtual int getNbinsX() const
get # of bins in X-axis
Definition: MonitorElement.cc:575

edm::ParameterSet
Definition: ParameterSet.h:48

MtdTracksHarvester::meNoTimeFraction_
MonitorElement * meNoTimeFraction_
Definition: MtdTracksHarvester.cc:53

dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98

MtdTracksHarvester::meMVAEtaSelEff_
MonitorElement * meMVAEtaSelEff_
Definition: MtdTracksHarvester.cc:40

h
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4

MtdTracksHarvester::meEtlEtaEff_
MonitorElement * meEtlEtaEff_[2]
Definition: MtdTracksHarvester.cc:33

MakerMacros.h

MtdTracksHarvester::meTPmtdPtSelEff_
MonitorElement * meTPmtdPtSelEff_
Definition: MtdTracksHarvester.cc:49

MtdTracksHarvester::meExtraMTDfailExtenderEtaEff_
MonitorElement * meExtraMTDfailExtenderEtaEff_
Definition: MtdTracksHarvester.cc:59

funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29

MtdTracksHarvester::meTPmtdPtMatchEff_
MonitorElement * meTPmtdPtMatchEff_
Definition: MtdTracksHarvester.cc:51

edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28

dqm::impl::MonitorElement::getBinContent
virtual double getBinContent(int binx) const
get content of bin (1-D)
Definition: MonitorElement.cc:593