Skip to content

Commit

Permalink
Merge pull request #37842 from fabiocos/fc-mtdpid
Browse files Browse the repository at this point in the history 
MTD validation: add histograms for particle identification monitoring
  • Loading branch information
@cmsbuild
cmsbuild committed May 11, 2022
2 parents 50201f2 + 4c1cd62 commit 6d18e41
Show file tree
Hide file tree
Showing 6 changed files with 933 additions and 273 deletions.
233 changes: 55 additions & 178 deletions Validation/MtdValidation/plugins/MtdTracksHarvester.cc
View file
Expand Up @@ -21,6 +21,8 @@ class MtdTracksHarvester : public DQMEDHarvester {
void dqmEndJob(DQMStore::IBooker&, DQMStore::IGetter&) override;

private:
void computeEfficiency1D(MonitorElement* num, MonitorElement* den, MonitorElement* result);

const std::string folder_;

// --- Histograms
Expand All @@ -42,6 +44,21 @@ MtdTracksHarvester::MtdTracksHarvester(const edm::ParameterSet& iConfig)

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);
}
}

// ------------ endjob tasks ----------------------------
void MtdTracksHarvester::dqmEndJob(DQMStore::IBooker& ibook, DQMStore::IGetter& igetter) {
// --- Get the monitoring histograms
Expand Down Expand Up @@ -88,68 +105,105 @@ void MtdTracksHarvester::dqmEndJob(DQMStore::IBooker& ibook, DQMStore::IGetter&
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]);

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_);

meBtlEtaEff_->getTH1()->SetMinimum(0.);
meBtlPhiEff_->getTH1()->SetMinimum(0.);
meBtlPtEff_->getTH1()->SetMinimum(0.);
for (int i = 0; i < 2; i++) {
Expand All @@ -161,183 +215,6 @@ void MtdTracksHarvester::dqmEndJob(DQMStore::IBooker& ibook, DQMStore::IGetter&
meMVAEtaSelEff_->getTH1()->SetMinimum(0.);
meMVAPtMatchEff_->getTH1()->SetMinimum(0.);
meMVAEtaMatchEff_->getTH1()->SetMinimum(0.);

// --- Calculate efficiency BTL
for (int ibin = 1; ibin <= meBTLTrackEffEtaTot->getNbinsX(); ibin++) {
double eff = meBTLTrackEffEtaMtd->getBinContent(ibin) / meBTLTrackEffEtaTot->getBinContent(ibin);
double bin_err = sqrt((meBTLTrackEffEtaMtd->getBinContent(ibin) *
(meBTLTrackEffEtaTot->getBinContent(ibin) - meBTLTrackEffEtaMtd->getBinContent(ibin))) /
pow(meBTLTrackEffEtaTot->getBinContent(ibin), 3));
if (meBTLTrackEffEtaTot->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meBtlEtaEff_->setBinContent(ibin, eff);
meBtlEtaEff_->setBinError(ibin, bin_err);
}
for (int ibin = 1; ibin <= meBTLTrackEffPhiTot->getNbinsX(); ibin++) {
double eff = meBTLTrackEffPhiMtd->getBinContent(ibin) / meBTLTrackEffPhiTot->getBinContent(ibin);
double bin_err = sqrt((meBTLTrackEffPhiMtd->getBinContent(ibin) *
(meBTLTrackEffPhiTot->getBinContent(ibin) - meBTLTrackEffPhiMtd->getBinContent(ibin))) /
pow(meBTLTrackEffPhiTot->getBinContent(ibin), 3));
if (meBTLTrackEffPhiTot->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meBtlPhiEff_->setBinContent(ibin, eff);
meBtlPhiEff_->setBinError(ibin, bin_err);
}
for (int ibin = 1; ibin <= meBTLTrackEffPtTot->getNbinsX(); ibin++) {
double eff = meBTLTrackEffPtMtd->getBinContent(ibin) / meBTLTrackEffPtTot->getBinContent(ibin);
double bin_err = sqrt((meBTLTrackEffPtMtd->getBinContent(ibin) *
(meBTLTrackEffPtTot->getBinContent(ibin) - meBTLTrackEffPtMtd->getBinContent(ibin))) /
pow(meBTLTrackEffPtTot->getBinContent(ibin), 3));
if (meBTLTrackEffPtTot->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meBtlPtEff_->setBinContent(ibin, eff);
meBtlPtEff_->setBinError(ibin, bin_err);
}
// --- Calculate efficiency ETL
for (int ibin = 1; ibin <= meETLTrackEffEtaTotZneg->getNbinsX(); ibin++) {
double eff = meETLTrackEffEtaMtdZneg->getBinContent(ibin) / meETLTrackEffEtaTotZneg->getBinContent(ibin);
double bin_err =
sqrt((meETLTrackEffEtaMtdZneg->getBinContent(ibin) *
(meETLTrackEffEtaTotZneg->getBinContent(ibin) - meETLTrackEffEtaMtdZneg->getBinContent(ibin))) /
pow(meETLTrackEffEtaTotZneg->getBinContent(ibin), 3));
if (meETLTrackEffEtaTotZneg->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meEtlEtaEff_[0]->setBinContent(ibin, eff);
meEtlEtaEff_[0]->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meETLTrackEffEtaTotZpos->getNbinsX(); ibin++) {
double eff = meETLTrackEffEtaMtdZpos->getBinContent(ibin) / meETLTrackEffEtaTotZpos->getBinContent(ibin);
double bin_err =
sqrt((meETLTrackEffEtaMtdZpos->getBinContent(ibin) *
(meETLTrackEffEtaTotZpos->getBinContent(ibin) - meETLTrackEffEtaMtdZpos->getBinContent(ibin))) /
pow(meETLTrackEffEtaTotZpos->getBinContent(ibin), 3));
if (meETLTrackEffEtaTotZpos->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meEtlEtaEff_[1]->setBinContent(ibin, eff);
meEtlEtaEff_[1]->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meETLTrackEffPhiTotZneg->getNbinsX(); ibin++) {
double eff = meETLTrackEffPhiMtdZneg->getBinContent(ibin) / meETLTrackEffPhiTotZneg->getBinContent(ibin);
double bin_err =
sqrt((meETLTrackEffPhiMtdZneg->getBinContent(ibin) *
(meETLTrackEffPhiTotZneg->getBinContent(ibin) - meETLTrackEffPhiMtdZneg->getBinContent(ibin))) /
pow(meETLTrackEffPhiTotZneg->getBinContent(ibin), 3));
if (meETLTrackEffPhiTotZneg->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meEtlPhiEff_[0]->setBinContent(ibin, eff);
meEtlPhiEff_[0]->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meETLTrackEffPhiTotZpos->getNbinsX(); ibin++) {
double eff = meETLTrackEffPhiMtdZpos->getBinContent(ibin) / meETLTrackEffPhiTotZpos->getBinContent(ibin);
double bin_err =
sqrt((meETLTrackEffPhiMtdZpos->getBinContent(ibin) *
(meETLTrackEffPhiTotZpos->getBinContent(ibin) - meETLTrackEffPhiMtdZpos->getBinContent(ibin))) /
pow(meETLTrackEffPhiTotZpos->getBinContent(ibin), 3));
if (meETLTrackEffPhiTotZpos->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meEtlPhiEff_[1]->setBinContent(ibin, eff);
meEtlPhiEff_[1]->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meETLTrackEffPtTotZneg->getNbinsX(); ibin++) {
double eff = meETLTrackEffPtMtdZneg->getBinContent(ibin) / meETLTrackEffPtTotZneg->getBinContent(ibin);
double bin_err =
sqrt((meETLTrackEffPtMtdZneg->getBinContent(ibin) *
(meETLTrackEffPtTotZneg->getBinContent(ibin) - meETLTrackEffPtMtdZneg->getBinContent(ibin))) /
pow(meETLTrackEffPtTotZneg->getBinContent(ibin), 3));
if (meETLTrackEffPtTotZneg->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meEtlPtEff_[0]->setBinContent(ibin, eff);
meEtlPtEff_[0]->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meETLTrackEffPtTotZpos->getNbinsX(); ibin++) {
double eff = meETLTrackEffPtMtdZpos->getBinContent(ibin) / meETLTrackEffPtTotZpos->getBinContent(ibin);
double bin_err =
sqrt((meETLTrackEffPtMtdZpos->getBinContent(ibin) *
(meETLTrackEffPtTotZpos->getBinContent(ibin) - meETLTrackEffPtMtdZpos->getBinContent(ibin))) /
pow(meETLTrackEffPtTotZpos->getBinContent(ibin), 3));
if (meETLTrackEffPtTotZpos->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meEtlPtEff_[1]->setBinContent(ibin, eff);
meEtlPtEff_[1]->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meMVATrackEffPtTot->getNbinsX(); ibin++) {
double eff = meMVATrackMatchedEffPtTot->getBinContent(ibin) / meMVATrackEffPtTot->getBinContent(ibin);
double bin_err = sqrt((meMVATrackMatchedEffPtTot->getBinContent(ibin) *
(meMVATrackEffPtTot->getBinContent(ibin) - meMVATrackMatchedEffPtTot->getBinContent(ibin))) /
pow(meMVATrackEffPtTot->getBinContent(ibin), 3));
if (meMVATrackEffPtTot->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meMVAPtSelEff_->setBinContent(ibin, eff);
meMVAPtSelEff_->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meMVATrackEffEtaTot->getNbinsX(); ibin++) {
double eff = meMVATrackMatchedEffEtaTot->getBinContent(ibin) / meMVATrackEffEtaTot->getBinContent(ibin);
double bin_err =
sqrt((meMVATrackMatchedEffEtaTot->getBinContent(ibin) *
(meMVATrackEffEtaTot->getBinContent(ibin) - meMVATrackMatchedEffEtaTot->getBinContent(ibin))) /
pow(meMVATrackEffEtaTot->getBinContent(ibin), 3));
if (meMVATrackEffEtaTot->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meMVAEtaSelEff_->setBinContent(ibin, eff);
meMVAEtaSelEff_->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meMVATrackMatchedEffPtTot->getNbinsX(); ibin++) {
double eff = meMVATrackMatchedEffPtMtd->getBinContent(ibin) / meMVATrackMatchedEffPtTot->getBinContent(ibin);
double bin_err =
sqrt((meMVATrackMatchedEffPtMtd->getBinContent(ibin) *
(meMVATrackMatchedEffPtTot->getBinContent(ibin) - meMVATrackMatchedEffPtMtd->getBinContent(ibin))) /
pow(meMVATrackMatchedEffPtTot->getBinContent(ibin), 3));
if (meMVATrackMatchedEffPtTot->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meMVAPtMatchEff_->setBinContent(ibin, eff);
meMVAPtMatchEff_->setBinError(ibin, bin_err);
}

for (int ibin = 1; ibin <= meMVATrackMatchedEffEtaTot->getNbinsX(); ibin++) {
double eff = meMVATrackMatchedEffEtaMtd->getBinContent(ibin) / meMVATrackMatchedEffEtaTot->getBinContent(ibin);
double bin_err =
sqrt((meMVATrackMatchedEffEtaMtd->getBinContent(ibin) *
(meMVATrackMatchedEffEtaTot->getBinContent(ibin) - meMVATrackMatchedEffEtaMtd->getBinContent(ibin))) /
pow(meMVATrackMatchedEffEtaTot->getBinContent(ibin), 3));
if (meMVATrackMatchedEffEtaTot->getBinContent(ibin) == 0) {
eff = 0;
bin_err = 0;
}
meMVAEtaMatchEff_->setBinContent(ibin, eff);
meMVAEtaMatchEff_->setBinError(ibin, bin_err);
}
}

// ------------ method fills 'descriptions' with the allowed parameters for the module ----------
Expand Down

0 comments on commit 6d18e41

Please sign in to comment.