CbmLitTrackingQaReport.cxx

Go to the documentation of this file.

/* Copyright (C) 2011-2018 UGiessen/JINR-LIT, Giessen/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev, Semen Lebedev [committer] */
 
#include "CbmLitTrackingQaReport.h"
 
#include "CbmDrawHist.h"
#include "CbmHistManager.h"
#include "CbmReportElement.h"
#include "CbmUtils.h"
#include "TCanvas.h"
#include "TH1.h"
#include "TLine.h"
 
#include <boost/assign/list_of.hpp>
 
#include <set>
#include <vector>
 
using boost::assign::list_of;
using Cbm::FindAndReplace;
using Cbm::NumberToString;
using Cbm::Split;
using std::endl;
using std::make_pair;
using std::map;
using std::pair;
using std::set;
using std::vector;
 
string DefaultEfficiencyLabelFormatter(const string& histName, Double_t efficiency)
{
  vector<string> split = Split(histName, '_');
  return split[1] + ":" + split[3] + "(" + NumberToString<Double_t>(efficiency, 1) + ")";
}
 
string ElectronIdEfficiencyLabelFormatter(const string& histName, Double_t efficiency)
{
  vector<string> split = Split(histName, '_');
  return FindAndReplace(split[1], "Sts", "") + " (" + NumberToString<Double_t>(efficiency, 1) + ")";
}
 
string DefaultPionSuppressionLabelFormatter(const string& histName, Double_t efficiency)
{
  vector<string> split = Split(histName, '_');
  return split[1] + " (" + NumberToString<Double_t>(efficiency, 1) + ")";
}
 
CbmLitTrackingQaReport::CbmLitTrackingQaReport() : CbmSimulationReport(), fGlobalTrackVariants()
{
  SetReportName("tracking_qa");
}
 
CbmLitTrackingQaReport::~CbmLitTrackingQaReport() {}
 
void CbmLitTrackingQaReport::Create()
{
  Out().precision(3);
  Out() << R()->DocumentBegin();
  Out() << R()->Title(0, GetTitle());
 
  Out() << "Number of events: " << HM()->H1("hen_EventNo_TrackingQa")->GetEntries() << endl;
 
  Out() << PrintNofObjects();
  Out() << PrintTrackHits();
  Out() << PrintNofGhosts();
  Out() << PrintTrackingEfficiency(false, false);
  Out() << PrintTrackingEfficiency(true, false);
  Out() << PrintTrackingEfficiency(false, true);
  Out() << PrintTrackingEfficiency(true, true);
  Out() << PrintPionSuppression();
 
  PrintCanvases();
 
  Out() << R()->DocumentEnd();
}
 
string CbmLitTrackingQaReport::PrintNofObjects() const
{
  vector<TH1*> histos = HM()->H1Vector("hno_NofObjects_.+");
  Int_t nofHistos     = histos.size();
  string str          = R()->TableBegin("Number of objects per event", list_of("Name")("Value"));
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string cellName = Split(histos[iHist]->GetName(), '_')[2];
    str += R()->TableRow(list_of(cellName)(NumberToString<Int_t>(histos[iHist]->GetMean())));
  }
  str += R()->TableEnd();
  return str;
}
 
string CbmLitTrackingQaReport::PrintTrackHits() const
{
  vector<TH1*> histos = HM()->H1Vector("hth_.+_TrackHits_All");
  Int_t nofHistos     = histos.size();
  string str          = R()->TableBegin("Number of all, true and fake hits in tracks and rings",
                               list_of("")("all")("true")("fake")("true/all")("fake/all"));
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string name     = histos[iHist]->GetName();
    string cellName = Split(name, '_')[1];
    string all      = NumberToString<Double_t>(histos[iHist]->GetMean(), 2);
    string trueh    = NumberToString<Double_t>(HM()->H1(FindAndReplace(name, "_All", "_True"))->GetMean(), 2);
    string fakeh    = NumberToString<Double_t>(HM()->H1(FindAndReplace(name, "_All", "_Fake"))->GetMean(), 2);
    string toa      = NumberToString<Double_t>(HM()->H1(FindAndReplace(name, "_All", "_TrueOverAll"))->GetMean(), 2);
    string foa      = NumberToString<Double_t>(HM()->H1(FindAndReplace(name, "_All", "_FakeOverAll"))->GetMean(), 2);
    str += R()->TableRow(list_of(cellName)(all)(trueh)(fakeh)(toa)(foa));
  }
  str += R()->TableEnd();
  return str;
}
 
string CbmLitTrackingQaReport::PrintNofGhosts() const
{
  Double_t nofEvents  = HM()->H1("hen_EventNo_TrackingQa")->GetEntries();
  vector<TH1*> histos = HM()->H1Vector("hng_NofGhosts_.+");
  Int_t nofHistos     = histos.size();
  string str          = R()->TableBegin("Number of ghosts per event", list_of("Name")("Value"));
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string cellName = Split(histos[iHist]->GetName(), '_')[2];
    str += R()->TableRow(list_of(cellName)(NumberToString<Double_t>(histos[iHist]->GetEntries() / nofEvents, 2)));
  }
  str += R()->TableEnd();
  return str;
}
 
string CbmLitTrackingQaReport::PrintTrackingEfficiency(Bool_t includeRich, Bool_t isPidEfficiency) const
{
  // If includeRich == true than search for tracking efficiency histograms which contain "Rich"
  // otherwise search for tracking efficiency histograms excluding those which contain "Rich"
  string effRegex = "";
  if (!isPidEfficiency)
    effRegex = (includeRich) ? "hte_.*Rich.*_Eff_p" : "hte_((?!Rich).)*_Eff_p";
  else
    effRegex = (includeRich) ? "hpe_.*Rich.*_Eff_p" : "hpe_((?!Rich).)*_Eff_p";
 
  vector<TH1*> histos = HM()->H1Vector(effRegex);
  Int_t nofHistos     = histos.size();
  if (nofHistos == 0) return "";
 
  // Find track and ring categories from the histogram names
  map<string, Int_t> catToCell;
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string effName          = histos[iHist]->GetName();
    pair<string, Int_t> tmp = make_pair(Split(effName, '_')[3], catToCell.size());
    catToCell.insert(tmp);
  }
  Int_t nofCats = catToCell.size();
  Int_t nofRows = nofHistos / nofCats;
 
  vector<string> cat(nofCats);
  map<string, Int_t>::const_iterator it;
  for (it = catToCell.begin(); it != catToCell.end(); it++) {
    cat[(*it).second] = (*it).first;
  }
 
  Int_t nofEvents   = HM()->H1("hen_EventNo_TrackingQa")->GetEntries();
  string tableTitle = (isPidEfficiency) ? "PID efficiency" : "Tracking efficiency";
  if (includeRich)
    tableTitle += " (with RICH)";
  else
    tableTitle += " (without RICH)";
 
  string str        = R()->TableBegin(tableTitle, list_of(string("")).range(cat));
  Int_t histCounter = 0;
  for (Int_t iRow = 0; iRow < nofRows; iRow++) {
    vector<string> cells(nofCats);
    string rowName;
    for (Int_t iCat = 0; iCat < nofCats; iCat++) {
      string effName             = histos[histCounter]->GetName();
      string accName             = FindAndReplace(effName, "_Eff_", "_Acc_");
      string recName             = FindAndReplace(effName, "_Eff_", "_Rec_");
      Double_t acc               = HM()->H1(accName)->GetEntries() / nofEvents;
      Double_t rec               = HM()->H1(recName)->GetEntries() / nofEvents;
      Double_t eff               = (acc != 0.) ? 100. * rec / acc : 0.;
      string accStr              = NumberToString<Double_t>(acc, 2);
      string recStr              = NumberToString<Double_t>(rec, 2);
      string effStr              = NumberToString<Double_t>(eff);
      vector<string> split       = Split(effName, '_');
      cells[catToCell[split[3]]] = effStr + "(" + recStr + "/" + accStr + ")";
      histCounter++;
      rowName = split[1] + " (" + split[2] + ")";
    }
    str += R()->TableRow(list_of(rowName).range(cells));
  }
  str += R()->TableEnd();
  return str;
}
 
string CbmLitTrackingQaReport::PrintPionSuppression() const
{
  vector<TH1*> histos = HM()->H1Vector("hps_.*_PionSup_p");
  Int_t nofHistos     = histos.size();
  if (nofHistos == 0) return "";
 
  Int_t nofEvents = HM()->H1("hen_EventNo_TrackingQa")->GetEntries();
  string str      = R()->TableBegin("Pion suppression", list_of(string(""))("Pion suppression"));
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string psName       = histos[iHist]->GetName();
    string recName      = FindAndReplace(psName, "_PionSup_", "_Rec_");
    string recPionsName = FindAndReplace(psName, "_PionSup_", "_RecPions_");
    Double_t rec        = HM()->H1(recName)->GetEntries() / nofEvents;
    Double_t recPions   = HM()->H1(recPionsName)->GetEntries() / nofEvents;
    Double_t pionSup    = (rec != 0.) ? recPions / rec : 0.;
    string pionSupStr   = NumberToString<Double_t>(pionSup) + " (" + NumberToString<Double_t>(recPions) + "/"
                        + NumberToString<Double_t>(rec) + ")";
    vector<string> split = Split(psName, '_');
    string rowName       = split[1];
    string category      = split[2];
    str += R()->TableRow(list_of(rowName + " - " + category)(pionSupStr));
  }
  str += R()->TableEnd();
  return str;
}
 
 
void CbmLitTrackingQaReport::Draw()
{
  CalculateEfficiencyHistos();
  CalculatePionSuppressionHistos();
  FillGlobalTrackVariants();
  SetDefaultDrawStyle();
  DrawEfficiencyHistos();
  DrawYPtHistos();
  DrawHitsHistos();
}
 
void CbmLitTrackingQaReport::DrawEfficiencyHistos()
{
  // Draw global tracking efficiency
  for (UInt_t i = 0; i < fGlobalTrackVariants.size(); i++) {
    string variant = fGlobalTrackVariants[i];
    DrawEfficiency("tracking_qa_global_tracking_efficiency_all_" + variant + "_p",
                   "hte_Sts.*_" + variant + "_All_Eff_p", DefaultEfficiencyLabelFormatter);
    DrawEfficiency("tracking_qa_global_tracking_efficiency_muon_" + variant + "_p",
                   "hte_Sts.*_" + variant + "_Muon_Eff_p", DefaultEfficiencyLabelFormatter);
    DrawEfficiency("tracking_qa_global_tracking_efficiency_electron_" + variant + "_p",
                   "hte_Sts.*_" + variant + "_Electron_Eff_p", DefaultEfficiencyLabelFormatter);
    DrawEfficiency("tracking_qa_pid_efficiency_electron_" + variant + "_p",
                   "hpe_((?!Sts_))Sts.*_" + variant + "_Electron_Eff_p", ElectronIdEfficiencyLabelFormatter);
    //DrawEfficiency("tracking_qa_global_tracking_efficiency_" + variant + "_pt", "hte_Sts.*_" + variant + "_All_Eff_pt");
    //DrawEfficiency("tracking_qa_global_tracking_efficiency_" + variant + "_y", "hte_Sts.*_" + variant + "_All_Eff_y");
    DrawEfficiency("tracking_qa_global_tracking_efficiency_" + variant + "_angle",
                   "hte_Sts.*_" + variant + "_All_Eff_Angle", DefaultEfficiencyLabelFormatter);
    if (variant.find("Rich") != string::npos) {
      DrawEfficiency("tracking_qa_global_tracking_efficiency_electron_" + variant + "_RingXc",
                     "hte_Sts.*_" + variant + "_Electron_Eff_RingXc", DefaultEfficiencyLabelFormatter);
      DrawEfficiency("tracking_qa_global_tracking_efficiency_electron_" + variant + "_RingYc",
                     "hte_Sts.*_" + variant + "_Electron_Eff_RingYc", DefaultEfficiencyLabelFormatter);
    }
  }
 
  // Draw local tracking efficiency
  vector<string> localTrackVariants = list_of("Sts")("Trd")("Much")("Rich")("Tof");
  for (UInt_t i = 0; i < localTrackVariants.size(); i++) {
    string variant = localTrackVariants[i];
    string re =
      (variant == "Sts") ? "hte_Sts_Sts_(All|Muon|Electron)_Eff" : "hte_" + variant + "_.*_(All|Muon|Electron)_Eff";
    if (variant == "Rich") re = "hte_" + variant + "_.*_(Electron|ElectronReference)_Eff";
    DrawEfficiency("tracking_qa_local_tracking_efficiency_" + variant + "_p", re + "_p",
                   DefaultEfficiencyLabelFormatter);
    //DrawEfficiency("tracking_qa_local_tracking_efficiency_" + variant + "_pt", re + "_pt");
    //DrawEfficiency("tracking_qa_local_tracking_efficiency_" + variant + "_y", "hte_" + variant + "_.*" + variant + ".*_(All|Electron)_Eff_y");
 
    string re2 = (variant == "Sts") ? "hte_Sts_Sts_All_Eff" : "hte_" + variant + "_.*_All_Eff";
    DrawEfficiency("tracking_qa_local_tracking_efficiency_" + variant + "_angle", re2 + "_Angle",
                   DefaultEfficiencyLabelFormatter);
  }
 
  // Draw RICH efficiency in dependence on different parameters
  DrawEfficiency("tracking_qa_local_tracking_efficiency_Rich_RingNh", "hte_Rich_Rich_Electron_Eff_RingNh",
                 DefaultEfficiencyLabelFormatter);
  DrawEfficiency("tracking_qa_local_tracking_efficiency_Rich_BoA", "hte_Rich_Rich_Electron_Eff_BoA",
                 DefaultEfficiencyLabelFormatter);
  DrawEfficiency("tracking_qa_local_tracking_efficiency_Rich_RingXc", "hte_Rich_Rich_Electron_Eff_RingXc",
                 DefaultEfficiencyLabelFormatter);
  DrawEfficiency("tracking_qa_local_tracking_efficiency_Rich_RingYc", "hte_Rich_Rich_Electron_Eff_RingYc",
                 DefaultEfficiencyLabelFormatter);
  DrawYPt("tracking_qa_Rich_Rich_Electron_Eff_RingXcYc", "hte_Rich_Rich_Electron_Eff_RingXcYc", true);
 
  // Draw local accepted and reconstructed tracks vs number of points
  HM()->ShrinkEmptyBinsH1ByPattern("hte_.+_.+_.+_.+_Np");
  vector<string> accRecTracks = list_of("Sts")("Trd")("Much")("Tof");
  for (UInt_t i = 0; i < accRecTracks.size(); i++) {
    string variant = accRecTracks[i];
 
    string re = (variant == "Sts") ? "hte_Sts_Sts_(All|Muon|Electron)_(Acc|Rec)_Np"
                                   : "hte_" + variant + "_.*_(All|Muon|Electron)_(Acc|Rec)_Np";
    DrawAccAndRec("tracking_qa_local_acc_and_rec_" + variant + "_Np", re);
 
    re = (variant == "Sts") ? "hte_Sts_Sts_(All)_(Acc|Rec)_p" : "hte_" + variant + "_.*_(All)_(Acc|Rec)_p";
    DrawAccAndRec("tracking_qa_local_acc_and_rec_" + variant + "_All_p", re);
 
    re = (variant == "Sts") ? "hte_Sts_Sts_(Muon|Electron)_(Acc|Rec)_p"
                            : "hte_" + variant + "_.*_(Muon|Electron)_(Acc|Rec)_p";
    DrawAccAndRec("tracking_qa_local_acc_and_rec_" + variant + "_ElectronMuon_p", re);
  }
 
  //
  DrawPionSuppression("tracking_qa_pion_suppression_wo_Rich_p", "hps_((?!Rich)).*All_PionSup_p",
                      DefaultPionSuppressionLabelFormatter);
  DrawPionSuppression("tracking_qa_pion_suppression_with_rich_p", "hps_Rich.*All_PionSup_p",
                      DefaultPionSuppressionLabelFormatter);
 
 
  // Draw ghost RICH rings vs position on photodetector plane
  if (HM()->Exists("hng_NofGhosts_Rich_RingXcYc")) {
    CreateCanvas("tracking_qa_hng_NofGhosts_Rich_RingXcYc", "tracking_qa_hng_NofGhosts_Rich_RingXcYc", 800, 800);
    Int_t nofEvents = HM()->H1("hen_EventNo_TrackingQa")->GetEntries();
    HM()->H2("hng_NofGhosts_Rich_RingXcYc")->Scale(1. / nofEvents);
    DrawH2(HM()->H2("hng_NofGhosts_Rich_RingXcYc"));
  }
}
 
void CbmLitTrackingQaReport::DrawEfficiency(const string& canvasName, const string& histNamePattern,
                                            string (*labelFormatter)(const string&, Double_t))
{
  vector<TH1*> histos = HM()->H1Vector(histNamePattern);
  if (histos.size() == 0) return;
 
  TCanvas* canvas = CreateCanvas(canvasName.c_str(), canvasName.c_str(), 600, 500);
  canvas->SetGrid();
  canvas->cd();
 
  Int_t nofHistos = histos.size();
  vector<string> labels(nofHistos);
  vector<Double_t> efficiencies(nofHistos);
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string name         = histos[iHist]->GetName();
    efficiencies[iHist] = CalcEfficiency(HM()->H1(FindAndReplace(name, "_Eff_", "_Rec_")),
                                         HM()->H1(FindAndReplace(name, "_Eff_", "_Acc_")), 100.);
    labels[iHist]       = labelFormatter(name, efficiencies[iHist]);
  }
 
  DrawH1(histos, labels, kLinear, kLinear, true, 0.50, 0.78, 0.99, 0.99, "PE1");
  DrawMeanEfficiencyLines(histos, efficiencies);
}
 
void CbmLitTrackingQaReport::DrawPionSuppression(const string& canvasName, const string& histNamePattern,
                                                 string (*labelFormatter)(const string&, Double_t))
{
  vector<TH1*> histos = HM()->H1Vector(histNamePattern);
  if (histos.size() == 0) return;
 
  TCanvas* canvas = CreateCanvas(canvasName.c_str(), canvasName.c_str(), 600, 500);
  canvas->SetGrid();
  canvas->cd();
 
  Int_t nofHistos = histos.size();
  vector<string> labels(nofHistos);
  vector<Double_t> ps(nofHistos);
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string name   = histos[iHist]->GetName();
    ps[iHist]     = CalcEfficiency(HM()->H1(FindAndReplace(name, "_PionSup_", "_RecPions_")),
                               HM()->H1(FindAndReplace(name, "_PionSup_", "_Rec_")), 1.);
    labels[iHist] = labelFormatter(name, ps[iHist]);
  }
 
  DrawH1(histos, labels, kLinear, kLog, true, 0.50, 0.78, 0.99, 0.99, "PE1");
  DrawMeanEfficiencyLines(histos, ps);
}
 
void CbmLitTrackingQaReport::DrawMeanEfficiencyLines(const vector<TH1*>& histos, const vector<Double_t>& efficiencies)
{
  assert(histos.size() != 0 && efficiencies.size() == histos.size());
 
  Double_t minX   = histos[0]->GetXaxis()->GetXmin();
  Double_t maxX   = histos[0]->GetXaxis()->GetXmax();
  Int_t nofHistos = histos.size();
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    TLine* line = new TLine(minX, efficiencies[iHist], maxX, efficiencies[iHist]);
    line->SetLineWidth(1);
    line->SetLineColor(histos[iHist]->GetLineColor());
    line->Draw();
  }
}
 
void CbmLitTrackingQaReport::DrawAccAndRec(const string& canvasName, const string& histNamePattern)
{
  vector<TH1*> histos = HM()->H1Vector(histNamePattern);
  if (histos.size() == 0) return;
 
  TCanvas* canvas = CreateCanvas(canvasName.c_str(), canvasName.c_str(), 600, 500);
  canvas->SetGrid();
  canvas->cd();
 
  Int_t nofEvents = HM()->H1("hen_EventNo_TrackingQa")->GetEntries();
  Int_t nofHistos = histos.size();
  vector<string> labels(nofHistos);
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    TH1* hist = histos[iHist];
    hist->Scale(1. / nofEvents);
    string name          = hist->GetName();
    vector<string> split = Split(name, '_');
    labels[iHist] = split[4] + ":" + split[3] + "(" + NumberToString<Double_t>(hist->GetEntries() / nofEvents, 2) + ")";
  }
 
  DrawH1(histos, labels, kLinear, kLinear, true, 0.50, 0.78, 0.99, 0.99);
}
 
void CbmLitTrackingQaReport::DrawYPtHistos()
{
  // Draw global tracking efficiency
  for (UInt_t i = 0; i < fGlobalTrackVariants.size(); i++) {
    string variant     = fGlobalTrackVariants[i];
    string effHistName = "hte_" + variant + "_" + variant;
    DrawYPt("tracking_qa_" + variant + "_all_ypt", effHistName + "_All_Eff_YPt");
    DrawYPt("tracking_qa_" + variant + "_proton_ypt", effHistName + "_Proton_Eff_YPt");
    DrawYPt("tracking_qa_" + variant + "_pion_plus_ypt", effHistName + "_PionPlus_Eff_YPt");
    DrawYPt("tracking_qa_" + variant + "_pion_minus_ypt", effHistName + "_PionMinus_Eff_YPt");
    DrawYPt("tracking_qa_" + variant + "_kaon_plus_ypt", effHistName + "_KaonPlus_Eff_YPt");
    DrawYPt("tracking_qa_" + variant + "_kaon_minus_ypt", effHistName + "_KaonMinus_Eff_YPt");
  }
}
 
void CbmLitTrackingQaReport::DrawYPt(const string& canvasName, const string& effHistName, Bool_t drawOnlyEfficiency)
{
  string accHistName = FindAndReplace(effHistName, "_Eff_", "_Acc_");
  string recHistName = FindAndReplace(effHistName, "_Eff_", "_Rec_");
 
  if (!(HM()->Exists(effHistName) && HM()->Exists(accHistName) && HM()->Exists(recHistName))) return;
 
  TH2* accHist = HM()->H2(accHistName);
  TH2* recHist = HM()->H2(recHistName);
  TH2* effHist = HM()->H2(effHistName);
 
  if (drawOnlyEfficiency) {
    CreateCanvas(canvasName.c_str(), canvasName.c_str(), 800, 800);
    //canvas->SetGrid();
    DrawH2(effHist);
  }
  else {
    TCanvas* canvas = CreateCanvas(canvasName.c_str(), canvasName.c_str(), 1800, 600);
    canvas->Divide(3, 1);
    canvas->SetGrid();
    canvas->cd(1);
    DrawH2(accHist);
 
    canvas->cd(2);
    DrawH2(recHist);
 
    canvas->cd(3);
    DrawH2(effHist);
  }
}
 
void CbmLitTrackingQaReport::DrawHitsHistos()
{
  HM()->ShrinkEmptyBinsH1ByPattern("hth_.*(_All|_True|_Fake)");
  DrawHitsHistos("tracking_qa_mvd_hits", "hth_Mvd_TrackHits");
  DrawHitsHistos("tracking_qa_sts_hits", "hth_Sts_TrackHits");
  DrawHitsHistos("tracking_qa_trd_hits", "hth_Trd_TrackHits");
  DrawHitsHistos("tracking_qa_much_hits", "hth_Much_TrackHits");
  DrawHitsHistos("tracking_qa_rich_hits", "hth_Rich_TrackHits");
}
 
void CbmLitTrackingQaReport::DrawHitsHistos(const string& canvasName, const string& hist)
{
  if (!(HM()->Exists(hist + "_All") && HM()->Exists(hist + "_True") && HM()->Exists(hist + "_Fake")
        && HM()->Exists(hist + "_TrueOverAll") && HM()->Exists(hist + "_FakeOverAll")))
    return;
 
  TCanvas* canvas = CreateCanvas(canvasName.c_str(), canvasName.c_str(), 1200, 600);
  canvas->Divide(2, 1);
  canvas->SetGrid();
 
  canvas->cd(1);
  TH1* hAll  = HM()->H1(hist + "_All");
  TH1* hTrue = HM()->H1(hist + "_True");
  TH1* hFake = HM()->H1(hist + "_Fake");
  DrawH1(list_of(hAll)(hTrue)(hFake),
         list_of("all: " + NumberToString<Double_t>(hAll->GetMean(), 1))(
           "true: " + NumberToString<Double_t>(hTrue->GetMean(), 1))("fake: "
                                                                     + NumberToString<Double_t>(hFake->GetMean(), 1)),
         kLinear, kLog, true, 0.50, 0.78, 0.99, 0.99);
 
  canvas->cd(2);
  TH1* hTrueOverAll = HM()->H1(hist + "_TrueOverAll");
  TH1* hFakeOverAll = HM()->H1(hist + "_FakeOverAll");
  DrawH1(list_of(hTrueOverAll)(hFakeOverAll),
         list_of("true/all: " + NumberToString<Double_t>(hTrueOverAll->GetMean()))(
           "fake/all: " + NumberToString<Double_t>(hFakeOverAll->GetMean())),
         kLinear, kLog, true, 0.50, 0.78, 0.99, 0.99);
}
 
Double_t CbmLitTrackingQaReport::CalcEfficiency(const TH1* histRec, const TH1* histAcc, Double_t scale) const
{
  if (histAcc->Integral() == 0 || histRec->Integral() == 0) {
    return 0.;
  }
  else {
    return scale * Double_t(histRec->Integral()) / Double_t(histAcc->Integral());
  }
}
 
void CbmLitTrackingQaReport::FillGlobalTrackVariants()
{
  fGlobalTrackVariants.clear();
  vector<TH1*> histos = HM()->H1Vector("hte_.*_Eff_p");
  Int_t nofHistos     = histos.size();
  set<string> variants;
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    string effName = histos[iHist]->GetName();
    variants.insert(Split(effName, '_')[2]);
  }
  fGlobalTrackVariants.assign(variants.begin(), variants.end());
}
 
void CbmLitTrackingQaReport::DivideHistos(TH1* histo1, TH1* histo2, TH1* histo3, Double_t scale)
{
  histo1->Sumw2();
  histo2->Sumw2();
  histo3->Sumw2();
  histo3->Divide(histo1, histo2, 1., 1., "B");
  histo3->Scale(scale);
}
 
void CbmLitTrackingQaReport::CalculateEfficiencyHistos()
{
  vector<TH1*> effHistos = HM()->H1Vector("(hte|hpe)_.+_Eff_.+");
  Int_t nofEffHistos     = effHistos.size();
  for (Int_t iHist = 0; iHist < nofEffHistos; iHist++) {
    TH1* effHist       = effHistos[iHist];
    string effHistName = effHist->GetName();
    string accHistName = FindAndReplace(effHistName, "_Eff_", "_Acc_");
    string recHistName = FindAndReplace(effHistName, "_Eff_", "_Rec_");
    DivideHistos(HM()->H1(recHistName), HM()->H1(accHistName), effHist, 100.);
    effHist->SetMinimum(0.);
    effHist->SetMaximum(100.);
  }
}
 
void CbmLitTrackingQaReport::CalculatePionSuppressionHistos()
{
  vector<TH1*> histos = HM()->H1Vector("hps_.+_PionSup_.+");
  Int_t nofHistos     = histos.size();
  for (Int_t iHist = 0; iHist < nofHistos; iHist++) {
    TH1* psHist            = histos[iHist];
    string psHistName      = psHist->GetName();
    string recHistName     = FindAndReplace(psHistName, "_PionSup_", "_Rec_");
    string pionRecHistName = FindAndReplace(psHistName, "_PionSup_", "_RecPions_");
    DivideHistos(HM()->H1(pionRecHistName), HM()->H1(recHistName), psHist, 1.);
    psHist->SetMinimum(10.);
    psHist->SetMaximum(2e5);
  }
}
 
ClassImp(CbmLitTrackingQaReport)