LmvmDrawAll.cxx

Go to the documentation of this file.

/* Copyright (C) 2011-2021 UGiessen, JINR-LIT
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Elena Lebedeva, Andrey Lebedev, Semen Lebedev [committer], Cornelius Feier-Riesen */
 
#include "LmvmDrawAll.h"
 
#include "CbmDrawHist.h"
#include "CbmHistManager.h"
#include "CbmUtils.h"
#include "LmvmDef.h"
#include "LmvmTask.h"
#include "LmvmUtils.h"
#include "Logger.h"
#include "TCanvas.h"
#include "TClass.h"
#include "TCutG.h"
#include "TEllipse.h"
#include "TF1.h"
#include "TFile.h"
#include "TGraphErrors.h"
#include "TH1.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TKey.h"
#include "TLatex.h"
#include "TLine.h"
#include "TLorentzVector.h"
#include "TMath.h"
#include "TStopwatch.h"
#include "TStyle.h"
#include "TSystem.h"
#include "TText.h"
 
#include <TLegend.h>
 
#include <iomanip>
#include <iostream>
#include <string>
 
using namespace std;
using namespace Cbm;
 
LmvmHist* LmvmDrawAll::H(ELmvmSignal signal) { return fH[static_cast<int>(signal)]; }
 
void LmvmDrawAll::DrawHistFromFile(const string& fileInmed, const string& fileQgp, const string& fileOmega,
                                   const string& filePhi, const string& fileOmegaD, const string& dataDir, bool useMvd)
{
  SetDefaultDrawStyle();
  fDataDir   = dataDir;
  fOutputDir = dataDir + "results/all/";
  fFileName  = fOutputDir + "draw_all_hist.root";
  fUseMvd    = useMvd;
  fRebinMinv = fHMean.fRebinMinv;
 
  // order in vector is important, see ELmvmSignal enum.
  vector<string> fileNames{fileInmed, fileQgp, fileOmega, filePhi, fileOmegaD};
 
  TFile* oldFile     = gFile;
  TDirectory* oldDir = gDirectory;
 
  // Load histograms from LmvmTask
  fH.resize(fHMean.fNofSignals);
  fNofSimEvents = 0;
  for (size_t i = 0; i < fH.size(); i++) {
    fH[i]       = new LmvmHist();
    TFile* file = new TFile(fileNames[i].c_str());
    fH[i]->fHM.ReadFromFile(file);
    double nofEventsSig = (double) fH[i]->H1("hEventNumber")->GetEntries();
    fNofSimEvents += nofEventsSig;
    LOG(info) << "Signal:" << fHMean.fSignalNames[i] << " nofEvents:" << nofEventsSig << endl;
  }
  CreateMeanHistAll();
 
  // Calculate Combinatorial BG, Signal and FastSim yields
  LoadFastSimHistos();      // load histograms provided by LmvmFastSim
  CalculateCombBGHistos();  // data provided by LmvmEventMix
  CalculateSignal();        // from FastSim and CB
  CalculateCBFromFastSimEvents();
 
  // Draw
  DrawElidCuts();
  DrawMinvAll();
  DrawNumbers();
  DrawSignal();
  DrawBackground();
  DrawCombinatorialBackground();
  DrawFastSimHistos();
  DrawTemperature();
  if (fDoParticleBased) DrawFastSimHistosParticleBased();
  DrawMinvOfficialStyle();
  DrawMomentum();
  DrawSBgVsMinv();
  DrawSuppression();
  //ChargeSymmetry(); // Impact of asymmetry onto agreement between Calc. CB and BRE
  DrawEfficiencyCorrection();
  DrawEfficiency();
  DrawPurity();
  DrawRapidity();
  DrawMinvScaleValues();
  DrawPtY();
  DrawMomRecoPrecision();
  CalcCutEffRange(0.0, 0.2);
  CalcCutEffRange(0.2, 0.6);
  CalcCutEffRange(0.6, 1.2);
  SBgRangeAll();
  DrawMinvPtAll();
  DrawSBgResults();
  DrawSignificancesAll();
  DrawGTrackVertex();
  DrawNofHits();
  DrawCandProperties();
  DrawRichProperties();
  DrawStudies();
  CheckVaryBinWidth();
  DrawTofM2();
  //InvestigateMisid();
  //DrawLikeSignCorrelations();
  //DrawBetaMomSpectra();
  //DrawSystematicErrorFsSignal(); // occupies a lot of memory
  //CheckoutAddFunction();
  //CheckoutAddFunction2();
  SaveHist();
  SaveCanvasToImage();
  CheckMemory("CreateMeanHistAll(): After all");

  gFile      = oldFile;
  gDirectory = oldDir;
}
 
template<class T>
void LmvmDrawAll::CreateMeanHist(const string& name, int nofRebins)
{
  for (ELmvmSignal sig : fHMean.fSignals) {
    if (static_cast<int>(sig) == 0)
      fHMean.fHM.Add(name, static_cast<T*>(H(sig)->GetObject(name)->Clone()));
    else
      static_cast<T*>(fHMean.GetObject(name))->Add(static_cast<T*>(H(sig)->GetObject(name)->Clone()));
  }
  static_cast<T*>(fHMean.GetObject(name))->Scale(1. / (double) fNofSimEvents);
  if (nofRebins > 0) {
    static_cast<T*>(fHMean.GetObject(name))->Rebin(nofRebins);
    double binWidth = static_cast<T*>(fHMean.GetObject(name))->GetBinWidth(1);
    static_cast<T*>(fHMean.GetObject(name))->Scale(1. / binWidth);
  }
}
 
template<class T>
void LmvmDrawAll::CreateMeanHistSparse(const string& name)
{
  for (ELmvmSignal sig : fHMean.fSignals) {
    if (static_cast<int>(sig) == 0)
      fHMean.fHM.Add(name, static_cast<T*>(H(sig)->GetObject(name)->Clone()));
    else
      static_cast<T*>(fHMean.GetObject(name))->Add(static_cast<T*>(H(sig)->GetObject(name)->Clone()));
  }
}
 
void LmvmDrawAll::CreateMeanHistAll()
{
  LOG(info) << "Nof simulated Events:" << fNofSimEvents << endl;
 
  CreateMeanHist<TH1D>("hNofMcTracks");
  CreateMeanHist<TH1D>("hNofGTracks");
  CreateMeanHist<TH1D>("hNofBgTracks");
  CreateMeanHist<TH1D>("hNofRichHits");
  CreateMeanHist<TH1D>("hNofRichRings");
  CreateMeanHist<TH2D>("hRecoPrec_Minv");
  CreateMeanHist<TH2D>("hVertexGTrackRZ");
 
  for (const string ptcl : {"pion", "proton"}) {
    for (const string step : {"mc", "reco", "acc", "elid", "ttcut", "ptcut"}) {  // TODO: why does "reco" not work??
      //for (const string step : {"mc", "acc", "elid", "ttcut", "ptcut"}) {
      CreateMeanHist<TH1D>("hSuppression_" + ptcl + "_" + step);
    }
  }
 
  for (const string det : {"rich", "trd", "tof"}) {
    CreateMeanHist<TH1D>("hMatch_" + det);
  }
 
  for (const string comb : {"PM", "PP", "MM"}) {
    for (const string ev : {"sameEv", "mixedEv"}) {
      CreateMeanHist<TH1D>("hMinv" + comb + "_" + ev, fRebinMinv);
    }
    for (const string cat : {"", "_mother"}) {
      CreateMeanHist<TH2D>("hMinvComb" + comb + "_px" + cat);
      CreateMeanHist<TH2D>("hMinvComb" + comb + "_py" + cat);
      CreateMeanHist<TH2D>("hMinvComb" + comb + "_R" + cat);
    }
    for (int i = 0; i <= 24; i++) {
      for (const string type : {"pMc", "pRec"}) {
        string hName = "hBgPairPdg" + comb + "_" + type + "_" + Cbm::NumberToString(i, 0);
        CreateMeanHist<TH2D>(hName);
      }
    }
    CreateMeanHist<TH1D>("hMinvComb" + comb + "_theta-minv");
  }
 
  for (const string suff : {"+", "-"}) {
    CreateMeanHist<TH2D>("hCandPdgVsMom" + suff);
    CreateMeanHist<TH1D>("hMom" + suff + "_trueEl_bg_elid");
  }
 
  for (const string cat : {"tt", "tm", "mt", "mm"}) {
    CreateMeanHist<TH1D>("hMinv_" + cat, fRebinMinv);
    CreateMeanHist<TH1D>("hMinvCombPM_same_" + cat, fRebinMinv);
  }
 
  for (const string cat : {"true", "misid"}) {
    CreateMeanHist<TH2D>("hRecoPrec_Mom_ID_" + cat);
    for (size_t iP = 4; iP < fHMean.fCandNames.size(); iP++) {
      CreateMeanHist<TH1D>("hMom_" + fHMean.fCandNames[iP] + "_" + cat);
      CreateMeanHist<TH1D>("hPtY_" + fHMean.fCandNames[iP] + "_" + cat);
      CreateMeanHist<TH1D>("hTofM2_" + fHMean.fCandNames[iP] + "_" + cat);
    }
  }
  for (const string det : {"rich", "trd", "tof"}) {
    for (const string cat : {"rec", "acc", "chi2prim"}) {
      CreateMeanHist<TH2D>("hPdgVsMom_" + det + "_" + cat);
    }
  }
 
  // Global Track Loop
  for (const string& ptcl : fHMean.fGTrackNames) {
    //CreateMeanHist<TH2D>("hMatchId_gTracks_" + ptcl);
    //CreateMeanHist<TH1D>("hNofMismatches_gTracks_" + ptcl);
    //CreateMeanHist<TH1D>("hNofMismatchedTrackSegments_" + ptcl);
 
    for (const string det : {"sts", "rich", "trd", "tof"}) {
      CreateMeanHist<TH2D>("hNofHitsVsMom_" + det + "_" + ptcl);
      for (const string match : {"truematch", "mismatch"}) {
        if (det != "sts") CreateMeanHist<TH1D>("hChi2_" + match + "_" + det + "_" + ptcl);
      }
    }
  }  // fGTrackNames
 
  // Candidate Loop
  for (const string& ptcl : fHMean.fCandNames) {
    CreateMeanHist<TH2D>("hTofM2_truematch_" + ptcl);
    CreateMeanHist<TH2D>("hTofM2_mismatch_" + ptcl);
    CreateMeanHist<TH2D>("hTofDist_truematch_" + ptcl);
    CreateMeanHist<TH2D>("hTofDist_mismatch_" + ptcl);
 
    for (auto step : fHMean.fAnaSteps) {
      CreateMeanHist<TH1D>(fHMean.GetName("hMom_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hELossSts_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hRichAnn_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hTrdElLike_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hTofM2_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hTofDist_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hMomPt_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hPtY_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hRecoPrec_Mom_" + ptcl, step));
      CreateMeanHist<TH1D>(fHMean.GetName("hRichRingTrackDist_" + ptcl, step));
      CreateMeanHist<TH2D>(fHMean.GetName("hRichRingTrackDistVsMom_" + ptcl, step));
      for (const string det : {"sts", "rich", "trd", "tof"}) {
        CreateMeanHist<TH2D>(fHMean.GetName("hChi2Dets_" + det + "_" + ptcl, step));
      }
    }  // steps
 
    // Number of indices in TOF
    for (const string nInd : {"1", "2", "3+"}) {
      CreateMeanHist<TH2D>("hTofM2_woDoubleIndex_" + nInd + "_" + ptcl);
    }
 
    // TOF-m2 in dependance on position
    for (int pos : {50, 100, 150, 200, 300, 400, 500}) {
      for (const string step : {"chi2prim", "elid"}) {
        CreateMeanHist<TH2D>("hTofM2_" + step + "_" + Cbm::NumberToString(pos, 0) + "_" + ptcl);
      }
    }
 
    // STS-E-Loss vs. TOF-m2 in dependance on position and momentum
    for (const string cat : {"Seg1Mom1", "Seg1Mom2", "Seg2Mom1", "Seg2Mom2"}) {
      CreateMeanHist<TH2D>("hElossTime_chi2prim_" + cat + "_" + ptcl);
      CreateMeanHist<TH2D>("hElossTime_elid_" + cat + "_" + ptcl);
    }
 
    //CreateMeanHist<TH1D>("hBetaMom_" + ptcl);
 
    for (const string det : {"StsRich", "StsTrd", "RichTrd"}) {
      CreateMeanHist<TH2D>("hChi2Comb_" + det + "_" + ptcl);
    }
 
    for (int i = 1; i <= 11; i++) {
      string pRange = Cbm::NumberToString(i, 0);
      CreateMeanHist<TH2D>("hCandProperties_" + pRange + "_" + ptcl);
    }
 
    for (const string step : {"all", "elid"}) {
      //CreateMeanHist<TH2D>("hTofChi2_"+ step + "_" + ptcl);
      for (const string neighbour : {"next", "secondnext"}) {
        CreateMeanHist<TH2D>("RichRingNeighbour_" + step + "_" + neighbour + "_" + ptcl);
      }
    }
 
 
  }  // fCandNames
 
  // Step Loop
  for (auto step : fHMean.fAnaSteps) {
    CreateMeanHist<TH1D>(fHMean.GetName("hRichRingBoA", step));
    CreateMeanHist<TH1D>(fHMean.GetName("hVertexXZ_misidTof", step));
    CreateMeanHist<TH1D>(fHMean.GetName("hVertexYZ_misidTof", step));
    CreateMeanHist<TH1D>(fHMean.GetName("hVertexXY_misidTof", step));
    CreateMeanHist<TH1D>(fHMean.GetName("hVertexRZ_misidTof", step));
    CreateMeanHist<TH1D>(fHMean.GetName("hLikeSignCorr", step));
    CreateMeanHist<TH2D>(fHMean.GetName("hCandPdg", step));
    CreateMeanHist<TH2D>(fHMean.GetName("hCandPdgVsMom", step));
 
    for (auto src : {ELmvmSrc::Bg, ELmvmSrc::Eta, ELmvmSrc::Pi0, ELmvmSrc::Gamma}) {
      for (const string cat : {"", "_trueEl", "_urqmdEl", "_urqmdAll"}) {
        CreateMeanHist<TH1D>(fHMean.GetName("hMinv" + cat, src, step), fRebinMinv);
      }
      CreateMeanHist<TH2D>(fHMean.GetName("hMinvPt", src, step));
      for (const string suff : {"+", "-"}) {
        CreateMeanHist<TH1D>(fHMean.GetName("hRapidity" + suff, src, step));
      }
    }
    for (const string& src : fHMean.fSrcNames) {
      for (const string suff : {"", "+", "-"}) {
        CreateMeanHist<TH1D>(fHMean.GetName("hMom" + suff + "_" + src, step));
        if (suff == "") continue;
        for (const string pi : {"Px", "Py", "Pz"}) {
          CreateMeanHist<TH1D>(fHMean.GetName("hMom" + pi + suff + "_" + src, step));
        }
      }
    }
 
    string hBgSrc = "hMinvBgSource2_" + fHMean.fAnaStepNames[static_cast<int>(step)] + "_";
    for (const string pair : {"gg", "pipi", "pi0pi0", "oo", "gpi", "gpi0", "go", "pipi0", "pio", "pi0o"}) {
      string hFullName = hBgSrc + pair;
      CreateMeanHist<TH1D>(hFullName, fRebinMinv);
    }
  }  // steps
}
 
TH1D* LmvmDrawAll::GetCocktailMinvH1(const string& name, ELmvmAnaStep step, bool scaleAll)
{
  return GetCocktailMinv<TH1D>(name, step, scaleAll);
}
 
void LmvmDrawAll::CalculateHistErrors(TH1D* h, double nofEvents)
{
  for (int iB = 1; iB <= h->GetNbinsX(); iB++) {
    double bW  = h->GetBinWidth(iB);
    double N   = h->GetBinContent(iB) * nofEvents * bW;
    double err = std::sqrt(N) / (bW * nofEvents);
    h->SetBinError(iB, err);
  }
}
 
TH1D* LmvmDrawAll::CalculateHistRatioWithErrors(TH1D* h1, TH1D* h2, double nEv1, double nEv2)
{
  if (h1->GetNbinsX() != h2->GetNbinsX())
    LOG(error) << "LmvmDrawAll::CalculateHistRatioWithErrors: Histograms don't have same number of bins.";
  TH1D* hRatio = (TH1D*) h1->Clone();
  hRatio->Divide(h2);
  double a = nEv2 / nEv1;
  cout << "a = " << a << endl;
  for (int iB = 1; iB <= h1->GetNbinsX(); iB++) {
    double bw = h1->GetBinWidth(iB);
    if (h2->GetBinWidth(iB) != bw)
      LOG(error) << "LmvmDrawAll::CalculateHistRatioWithErrors: Histograms '" << h1->GetName() << "' and '"
                 << h2->GetName() << "': Bin widths of bin " << iB << " of both histograms are not the same.";
    double c1 = h1->GetBinContent(iB);
    double c2 = h2->GetBinContent(iB);
    double n1 = c1 * bw * nEv1;
    double n2 = c2 * bw * nEv2;
    double D1 = std::sqrt(n1 / (bw * nEv1));
    double D2 = std::sqrt(n2 / (bw * nEv2));
 
    // f = n1/n2
    double dfdx1 = 1 / n2;
    double dfdx2 = -n1 / (n2 * n2);
    double f1    = dfdx1 * D1;
    double f2    = dfdx2 * D2;
    double error = std::sqrt(f1 * f1 + f2 * f2);
    cout << "iB = " << iB << ", bW = " << bw << endl;
    cout << "   c1 = " << c1 << ", n1 = " << n1 << ", D1 = " << D1 << ", f1 = " << f1 << endl;
    cout << "   c2 = " << c2 << ", n2 = " << n2 << ", D2 = " << D2 << ", f2 = " << f2 << endl;
    cout << "   -> error = " << error << endl;
    hRatio->SetBinError(iB, error);
  }
  return hRatio;
}
 
void LmvmDrawAll::CheckoutAddFunction()
{
  TH1D* h = new TH1D("hCheckoutAddFunc", "hCheckoutAddFunction", 10., 0., 10.);
  //fHMean.CreateHByClone(h, "hCheckoutAdd");
  for (int iB = 1; iB <= h->GetNbinsX(); iB++) {
    h->SetBinContent(iB, iB);
    double c = h->GetBinContent(iB);
    double e = iB / 10.;
    h->SetBinError(iB, e);
    LOG(info) << "CheckoutAddFunction: hist: iB = " << iB << ", c = " << c << ", e = " << e;
  }
  fHMean.CreateHByClone(h, "hCheckoutAdd");
}
void LmvmDrawAll::CheckoutAddFunction2()
{
  TH1D* h2 = fHMean.H1Clone("hCheckoutAdd");
  for (int iB = 1; iB <= h2->GetNbinsX(); iB++) {
    double c = h2->GetBinContent(iB);
    double e = h2->GetBinError(iB);
    LOG(info) << "CheckoutAddFunction2: check hist: iB = " << iB << ", c = " << c << ", e = " << e;
  }
}
 
TH1D* LmvmDrawAll::GetSignal(
  ELmvmAnaStep step, vector<pair<double, double>> bwvar)  // Mind: For now only available for ElId step and cat = ""
{
  TH1D* bre = VaryBinWidth("mean", "hfsc_MinvBg", step, bwvar);
  TH1D* bcb = VaryBinWidth("mean", fHMean.GetName("hCbBg", step), bwvar);
  TH1D* coc = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", bwvar);
  TH1D* sig = (TH1D*) bre->Clone();
  sig->Add(coc);
  sig->Add(bcb, -1.);
 
  // For error contribution from CB
  TH1D* h_s_pp = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPP_sameEv", step), bwvar);
  TH1D* h_s_mm = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvMM_sameEv", step), bwvar);
  TH1D* h_m_pp = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPP_mixedEv", step), bwvar);
  TH1D* h_m_mm = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvMM_mixedEv", step), bwvar);
 
  for (int iB = 1; iB <= bre->GetNbinsX(); iB++) {
    double bW = bre->GetBinWidth(iB);
 
    // Number of entries
    double N_bre  = bre->GetBinContent(iB) * bW * fNofFastSimEvents;
    double N_s_pp = h_s_pp->GetBinContent(iB) * bW * fNofEvMixEvents;
    double N_s_mm = h_s_mm->GetBinContent(iB) * bW * fNofEvMixEvents;
    double N_m_pp = h_m_pp->GetBinContent(iB) * bW * fNofEvMixEvents * fEvMixDepth;
    double N_m_mm = h_m_mm->GetBinContent(iB) * bW * fNofEvMixEvents * fEvMixDepth;
 
    // Errors
    double D_bcb1 = std::sqrt(N_s_mm + N_s_pp) / (bW * fNofEvMixEvents);
    double D_bcb2 = std::sqrt(N_m_pp + N_m_mm)
                    / (bW * fNofEvMixEvents * fEvMixDepth * fCbNormFactor[static_cast<int>(ELmvmAnaStep::ElId)]);
    double D_bcb  = (bre->GetBinCenter(iB) <= fCbChange) ? D_bcb1 : D_bcb2;
    double D_bre  = std::sqrt(N_bre) / (bW * fNofFastSimEvents);
    double D_dNdM = std::sqrt(D_bre * D_bre + D_bcb * D_bcb);
 
    sig->SetBinError(iB, D_dNdM);
  }
  return sig;
}
 
void LmvmDrawAll::CalculateSignal()
{
  // Signal = B_{FS} + Cocktail - CB_{calc}
  for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
    string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
    for (const string cat : {"", "_trueEl"}) {
      // Standard Signal (FastSim will be used for minv > fCbChange)
      TH1D* sig =
        fHMean.CreateHByClone(fHMean.H1Clone("hfsc_MinvBg" + cat, step), fHMean.GetName("hSignal" + cat, step));
      TH1D* sigred = fHMean.CreateHByClone(fHFastSim.H1Clone("hfsc_MinvBg" + cat, step),
                                           fHMean.GetName("hSignalReduced" + cat, step));
      TH1D* reBg   = fHFastSim.H1Clone("hfsc_MinvBg" + cat, step);
      TH1D* mcBg   = fHMean.H1Clone("hMinv", ELmvmSrc::Bg, step);
      //TH1D* mcBg = fHMean.H1Clone("hMinvPM_sameEv");
      TH1D* cbc     = fHMean.H1Clone("hCbBg" + cat, step);
      TH1D* coc     = GetCocktailMinvH1("hMinv" + cat, step, false);
      double bW     = sig->GetBinWidth(1);
      int ChangeBin = sig->FindBin(0.4);
      for (int iB = 1; iB <= sig->GetNbinsX(); iB++) {
        double vMcBg = mcBg->GetBinContent(iB);
        double vReBg = reBg->GetBinContent(iB);
        double vCbBg = cbc->GetBinContent(iB);
        double vCoc  = coc->GetBinContent(iB);
        double vSig  = (iB < ChangeBin) ? vMcBg + vCoc - vCbBg : vReBg + vCoc - vCbBg;
        sig->SetBinContent(iB, vSig);
        sigred->SetBinContent(iB, vSig);
      }
 
      // Reduced Signal
      TH1D* inmed       = H(ELmvmSignal::Inmed)->H1Clone("hMinv", ELmvmSrc::Signal, step);
      TH1D* qgp         = H(ELmvmSignal::Qgp)->H1Clone("hMinv", ELmvmSrc::Signal, step);
      TH1D* omega       = H(ELmvmSignal::Omega)->H1Clone("hMinv", ELmvmSrc::Signal, step);
      TH1D* omegadalitz = H(ELmvmSignal::OmegaD)->H1Clone("hMinv", ELmvmSrc::Signal, step);
      TH1D* phi         = H(ELmvmSignal::Phi)->H1Clone("hMinv", ELmvmSrc::Signal, step);
      TH1D* pi0         = fHMean.H1Clone("hMinv", ELmvmSrc::Pi0, step);
      TH1D* eta         = fHMean.H1Clone("hMinv", ELmvmSrc::Eta, step);
      inmed->Scale(1. / (H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries() * bW));
      qgp->Scale(1. / (H(ELmvmSignal::Qgp)->H1("hEventNumber")->GetEntries() * bW));
      omega->Scale(1. / (H(ELmvmSignal::Omega)->H1("hEventNumber")->GetEntries() * bW));
      omegadalitz->Scale(1. / (H(ELmvmSignal::OmegaD)->H1("hEventNumber")->GetEntries() * bW));
      phi->Scale(1. / (H(ELmvmSignal::Phi)->H1("hEventNumber")->GetEntries() * bW));
      sigred->Add(omega, -1.);
      sigred->Add(omegadalitz, -1.);
      sigred->Add(phi, -1.);
      sigred->Add(pi0, -1.);
      sigred->Add(eta, -1.);
 
      // Errors for signal histograms with varied bin widths
      for (auto bwv : fBwVarAll) {
        string tag = "";
        if (bwv == fBwVarOrig)
          tag = fBwVarAllTags[0];
        else if (bwv == fBwVarReg)
          tag = fBwVarAllTags[1];
        else if (bwv == fBwVarBg)
          tag = fBwVarAllTags[2];
        else if (bwv == fBwVarSig)
          tag = fBwVarAllTags[3];
        else if (bwv == fBwVarSig2)
          tag = fBwVarAllTags[4];
        else if (bwv == fBwVarSig3)
          tag = fBwVarAllTags[5];
        else
          LOG(error) << "LmvmDrawAll::CalculateSignal: Check bwVar-tag assignment!";
        TH1D* sigV    = VaryBinWidth(sig, bwv);
        TH1D* sigredV = VaryBinWidth(sigred, bwv);
        TH1D* bre     = VaryBinWidth("mean", "hfsc_MinvBg" + cat, step, bwv);
 
        // Histograms for errors
        TH1D* errSig = (TH1D*) sigV->Clone();
        TH1D* errBre = (TH1D*) sigV->Clone();
        TH1D* errBcb = (TH1D*) sigV->Clone();
        errSig->Reset();
        errBre->Reset();
        errBcb->Reset();
 
        // For error contribution from CB
        TH1D* h_s_pp = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPP" + cat + "_sameEv", step), bwv);
        TH1D* h_s_mm = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvMM" + cat + "_sameEv", step), bwv);
        TH1D* h_m_pp = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPP" + cat + "_mixedEv", step), bwv);
        TH1D* h_m_mm = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvMM" + cat + "_mixedEv", step), bwv);
 
        for (int iB = 1; iB <= bre->GetNbinsX(); iB++) {
          double bW2 = bre->GetBinWidth(iB);
 
          // Number of entries
          double N_bre  = bre->GetBinContent(iB) * bW2 * fNofFastSimEvents;
          double N_s_pp = h_s_pp->GetBinContent(iB) * bW2 * fNofEvMixEvents;
          double N_s_mm = h_s_mm->GetBinContent(iB) * bW2 * fNofEvMixEvents;
          double N_m_pp = h_m_pp->GetBinContent(iB) * bW2 * fNofEvMixEvents * fEvMixDepth;
          double N_m_mm = h_m_mm->GetBinContent(iB) * bW2 * fNofEvMixEvents * fEvMixDepth;
 
          // Errors
          double D_bcb1 = std::sqrt(N_s_mm + N_s_pp) / (bW2 * fNofEvMixEvents);
          double D_bcb2 =
            std::sqrt(N_m_pp + N_m_mm) / (bW2 * fNofEvMixEvents * fEvMixDepth * fCbNormFactor[static_cast<int>(step)]);
          double D_bcb  = (bre->GetBinCenter(iB) <= fCbChange) ? D_bcb1 : D_bcb2;
          double D_bre  = std::sqrt(N_bre) / (bW2 * fNofFastSimEvents);
          double D_dNdM = std::sqrt(D_bre * D_bre + D_bcb * D_bcb);
 
          sigV->SetBinError(iB, D_dNdM);
          sigredV->SetBinError(iB, D_dNdM);
 
          errSig->SetBinContent(iB, D_dNdM);
          errBre->SetBinContent(iB, D_bre);
          errBcb->SetBinContent(iB, D_bcb);
        }
        fHMean.CreateHByClone(sigV, fHMean.GetName("hSignal" + cat + "_" + tag, step));
        fHMean.CreateHByClone(sigredV, fHMean.GetName("hSignalReduced" + cat + "_" + tag, step));
 
        if (cat != "") continue;
        // Draw Histograms as standards for later checking
        sigV->GetYaxis()->SetRangeUser(1e-9, 2e-1);
        string cNameSig = "Signal/Standard/" + tag + "_" + stepname;
        string cNameErr = "Signal/Standard/Error/" + tag + "_" + stepname;
        fHMean.fHM.CreateCanvas(cNameSig, cNameSig, 800, 800);
        DrawH1(sigV, kLinear, kLog, "p");
        DrawTextOnPad("Signal (elid)", 0.35, 0.9, 0.65, 0.99);
        fHMean.fHM.CreateCanvas(cNameErr, cNameErr, 800, 800);
        errSig->GetYaxis()->SetRangeUser(1e-10, 5e-2);
        DrawH1({errSig, errBre, errBcb}, {"S = B_{FS} - B_{CB}", "B_{FS}", "CB_{calc}"}, kLinear, kLog, true, 0.65, 0.7,
               0.91, 0.9, "p");
        DrawTextOnPad("Errors", 0.4, 0.9, 0.6, 0.99);
      }  // ..bWidths
    }    // ..cats
  }      // ..steps
 
  // Check Errors
  /*{
    TH1D* sig  = fHMean.H1Clone("hSignal_bwvOrig_elid");
    TH1D* sig2 = fHMean.H1Clone("hSignal_bwvSig_elid");
    cout << endl << "Signal Histogram original:" << endl;
    for (int iB = 1; iB <= sig->GetNbinsX(); iB++) {
      double bW2 = sig->GetBinWidth(iB);
      double nSigNorm = sig->GetBinContent(iB);
      double nSig = sig->GetBinContent(iB) * bW2 * fNofFastSimEvents;
      double errSig = sig->GetBinError(iB);
      LOG(info) << "Errors2 (CalcSignal): iB = " << iB << ": bW = " << bW2 << ", nSigN = " << nSigNorm << ", nSig = " << nSig << ", errSig = " << errSig;
    }
    cout << endl << "Signal Histogram varied bin width:" << endl;
    for (int iB = 1; iB <= sig2->GetNbinsX(); iB++) {
      double bW2 = sig2->GetBinWidth(iB);
      double nSigNorm = sig2->GetBinContent(iB);
      double nSig = sig2->GetBinContent(iB) * bW2 * fNofFastSimEvents;
      double errSig = sig2->GetBinError(iB);
      LOG(info) << "Errors2 (CalcSignal): iB = " << iB << ": bW = " << bW2 << ", nSigN = " << nSigNorm << ", nSig = " << nSig << ", errSig = " << errSig;
    }
  }*/
}
 
void LmvmDrawAll::DrawSignal()
{
  DrawSignalCBNormRangeDependent("hfsc_MinvBg", "Signal/", ELmvmAnaStep::ElId);
  DrawSignalCBNormRangeDependent("hfsp_MinvBg", "Signal/", ELmvmAnaStep::ElId);
 
  // Draw Signal from particle-based FastSim
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    string stepname   = fHMean.fAnaStepNames[static_cast<int>(step)];
    TH1D* bre         = fHFastSim.H1Clone("hfsp_MinvBg", step);
    TH1D* cbc         = fHMean.H1Clone("hCbBg", step);
    TH1D* coc         = GetCocktailMinvH1("hMinv", step, false);
    TH1D* sig         = (TH1D*) bre->Clone();
    sig->Add(coc);
    sig->Add(cbc, -1.);
    TH1D* bre2 = VaryBinWidth(bre, fNofFastSimEvents, fBwVarBg);
    TH1D* cbc2 = VaryBinWidth(cbc, fNofFastSimEvents, fBwVarBg);
    TH1D* coc2 = VaryBinWidth(coc, fNofFastSimEvents, fBwVarSig);
    TH1D* sig2 = VaryBinWidth(sig, fNofFastSimEvents, fBwVarSig);
    sig2->GetYaxis()->SetRangeUser(5e-9, 5e-2);
    TCanvas* c = fHMean.fHM.CreateCanvas("Signal/Particle-based/Standard", "Signal/Particle-based/Standard", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({bre2, cbc2}, {"B_{FS}", "CB_{calc}"}, kLinear, kLog, true, 0.75, 0.78, 0.91, 0.91, "pe");
    c->cd(2);
    DrawH1({sig2, coc2}, {"Signal", "Cocktail"}, kLinear, kLog, true, 0.75, 0.78, 0.91, 0.91, "pe");
 
    // Text to compare Rebin with VaryBinWidth (seems good!)
    TH1D* sig5  = (TH1D*) sig->Clone();
    TH1D* sig10 = (TH1D*) sig->Clone();
    TH1D* sig50 = (TH1D*) sig->Clone();
    TH1D* coc5  = (TH1D*) coc->Clone();
    TH1D* coc10 = (TH1D*) coc->Clone();
    TH1D* coc50 = (TH1D*) coc->Clone();
    sig5->Rebin(5);
    sig10->Rebin(10);
    sig50->Rebin(50);
    coc5->Rebin(5);
    coc10->Rebin(10);
    coc50->Rebin(50);
    sig5->Scale(1. / 5.);
    sig10->Scale(1. / 10.);
    sig50->Scale(1. / 50.);
    coc5->Scale(1. / 5.);
    coc10->Scale(1. / 10.);
    coc50->Scale(1. / 50.);
    TCanvas* ct =
      fHMean.fHM.CreateCanvas("Signal/Particle-based/Standard_test", "Signal/Particle-based/Standard_test", 2400, 800);
    ct->Divide(3, 1);
    ct->cd(1);
    DrawH1({sig5, coc5}, {"Signal", "Cocktail"}, kLinear, kLog, true, 0.75, 0.78, 0.91, 0.91, "p");
    DrawTextOnPad("Rebin 5", 0.26, 0.9, 0.74, 0.99);
    ct->cd(2);
    DrawH1({sig10, coc10}, {"Signal", "Cocktail"}, kLinear, kLog, true, 0.75, 0.78, 0.91, 0.91, "p");
    DrawTextOnPad("Rebin 10", 0.25, 0.9, 0.75, 0.99);
    ct->cd(3);
    DrawH1({sig50, coc50}, {"Signal", "Cocktail"}, kLinear, kLog, true, 0.75, 0.78, 0.91, 0.91, "p");
    DrawTextOnPad("Rebin 50", 0.25, 0.9, 0.75, 0.99);
  }
 
  for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
    string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
    // Draw common and reduced signal
    {
      for (auto bwv : {fBwVarSig3}) {
        string tag = "";
        if (bwv == fBwVarOrig)
          tag = fBwVarAllTags[0];
        else if (bwv == fBwVarReg)
          tag = fBwVarAllTags[1];
        else if (bwv == fBwVarBg)
          tag = fBwVarAllTags[2];
        else if (bwv == fBwVarSig)
          tag = fBwVarAllTags[3];
        else if (bwv == fBwVarSig2)
          tag = fBwVarAllTags[4];
        else if (bwv == fBwVarSig3)
          tag = fBwVarAllTags[5];
        for (const string cat : {""}) {  //}, "_trueEl", "_urqmdAll", "_urqmdEl"}) {
          TH1D* sig    = fHMean.H1Clone(fHMean.GetName("hSignal" + cat + "_" + tag, step));
          TH1D* sigred = fHMean.H1Clone(fHMean.GetName("hSignalReduced" + cat + "_" + tag, step));
          TH1D* coc    = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", bwv);
          TH1D* inmed  = VaryBinWidth("inmed", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), bwv);
          TH1D* qgp    = VaryBinWidth("qgp", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), bwv);
          inmed->Scale(1. / H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries());
          qgp->Scale(1. / H(ELmvmSignal::Qgp)->H1("hEventNumber")->GetEntries());
          TH1D* cocred = (TH1D*) inmed->Clone();
          cocred->Add(qgp);
          for (int iB = 1; iB <= cocred->GetNbinsX(); iB++) {
            cocred->SetBinError(iB, 0.);
          }
          sig->GetYaxis()->SetRangeUser(1e-9, 3e-2);
          sigred->GetYaxis()->SetRangeUser(1e-10, 5e-2);
          fHMean.fHM.CreateCanvas("Signal/Signal" + cat + "_" + tag + "_" + stepname,
                                  "Signal/Signal" + cat + "_" + tag + "_" + stepname, 800, 800);
          DrawH1({sig, coc}, {"Signal", "MC Cocktail"}, kLinear, kLog, true, 0.65, 0.78, 0.91, 0.91, "p");
          fHMean.fHM.CreateCanvas("Signal/ReducedSignal" + cat + "_" + tag + "_" + stepname,
                                  "Signal/ReducedSignal" + cat + "_" + tag + "_" + stepname, 800, 800);
          DrawH1({sigred, cocred}, {"Signal - #pi^{0} - #eta - #omega - #omega_{D} - #phi", "#rho_{i.m.} + QGP"},
                 kLinear, kLog, true, 0.4, 0.78, 0.91, 0.91, "p");
        }
      }
    }
  }
 
  // Signal with single components
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TH1D* bre         = fHFastSim.H1Clone("hfsc_MinvBg", step);
    TH1D* cb          = fHMean.H1Clone("hCbBg", step);
    TH1D* coc         = GetCocktailMinvH1("hMinv", step, false);
    TH1D* sig         = (TH1D*) bre->Clone();
    sig->Add(coc);
    sig->Add(cb, -1.);
    TCanvas* c = fHMean.fHM.CreateCanvas("Signal/Components", "Signal/Components", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1(sig, kLinear, kLog, "hist");
    fHMean.DrawAnaStepOnPad(step);
    c->cd(2);
    bre->GetYaxis()->SetRangeUser(1e-10, 1e-1);
    DrawH1({bre, cb, coc}, {"B_{FS}", "CB_{calc}", "Cocktail"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.91, "hist");
    fHMean.DrawAnaStepOnPad(step);
  }
}
 
void LmvmDrawAll::CheckoutTemperatureInitParams()
{
  vector<double> paramsA = {5e-5, 1e-4, 5e-4, 1e-3, 2e-3, 5e-3, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.};
  vector<double> paramsB = {0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1., 2., 5., 10., 20., 50., 100.};
 
  string h2descr = "hTempVsInitParams; Parameter #it{a}; Parameter #it{b}; T [MeV]";
  TH2D* h2 = new TH2D("hTempVsInitParams", h2descr.c_str(), paramsA.size(), paramsA[0], paramsA[paramsA.size() - 1],
                      paramsB.size(), paramsB[0], paramsB[paramsB.size() - 1]);
  for (size_t iX = 0; iX < paramsA.size(); iX++) {
    string startstr = Cbm::NumberToString(paramsA[iX], 2);
    h2->GetXaxis()->SetBinLabel(iX + 1, startstr.c_str());
  }
  for (size_t iY = 0; iY < paramsB.size(); iY++) {
    string endstr = Cbm::NumberToString(paramsB[iY], 2);
    h2->GetYaxis()->SetBinLabel(iY + 1, endstr.c_str());
  }
 
  for (size_t iA = 0; iA < paramsA.size(); iA++) {
    for (size_t iB = 0; iB < paramsB.size(); iB++) {
 
      // Get Parameter 'b' (is needed later to calculate appropriate x-Position of large bins for Temperature Fit)
      TH1D* h      = VaryBinWidth("cocktail_elid", "", fBwVarReg);
      TF1* TFitCoc = new TF1("TFitCoc", "[0]*TMath::Exp(-[1]*x)", 1.1, 2.5);
      TFitCoc->SetParameters(paramsA[iA], paramsB[iB]);
      string cNameInit = "Temperature/CheckoutInitParams/Init_" + Cbm::NumberToString(paramsA[iA], 2) + "_"
                         + Cbm::NumberToString(paramsB[iB], 2);
      fHMean.fHM.CreateCanvas(cNameInit, cNameInit, 1600, 1100);
      DrawH1(h, kLinear, kLog, "p");
      h->Fit("TFitCoc", "QR");
      double b = TFitCoc->GetParameter(1);
      DrawTextOnPad("Parameter #it{b} = " + Cbm::NumberToString(b, 2), 0.12, 0.12, 0.5, 0.25);
      DrawTextOnPad("Fit: #it{a#upointe^{-bx}}", 0.6, 0.76, 0.8, 0.81);
 
      // Calculate Temperature with current Parameter b
      TF1* funcInit = new TF1("TFuncTestInitParams", "[0]*TMath::Power(x*[1], 3./2.)*TMath::Exp(-x/[1])", 1.1, 2.5);
      funcInit->SetParameters(0.02, 0.15);
      string cName = "Temperature/CheckoutInitParams/Temp_" + Cbm::NumberToString(paramsA[iA], 2) + "_"
                     + Cbm::NumberToString(paramsB[iB], 2);
      fHMean.fHM.CreateCanvas(cName, cName, 800, 800);
      int nBins = h->GetNbinsX();
      double x[nBins], y[nBins], ex[nBins], ey[nBins];
      for (int iBin = 1; iBin <= nBins; iBin++) {
        double bW    = h->GetBinWidth(iBin);
        double x1    = h->GetBinLowEdge(iBin);
        x[iBin - 1]  = x1 + (TMath::Log(b * bW) - TMath::Log(1 - TMath::Exp(-b * bW))) / b;
        y[iBin - 1]  = h->GetBinContent(iBin);
        ex[iBin - 1] = 0.;
        ey[iBin - 1] = h->GetBinError(iBin);
      }
      auto graph = new TGraphErrors(nBins, x, y, ex, ey);
      graph->SetTitle("Temperature; M_{ee} [GeV/c^{2}]; dN/dM [Gev/c^{2}]^{-1}");
      graph->GetXaxis()->SetRangeUser(0., 2.5);
      graph->GetYaxis()->SetRangeUser(1e-10, 1e-1);
      graph->SetMarkerStyle(21);
      graph->Draw("AP");
      gPad->SetLogy(true);
      graph->Fit("TFuncTestInitParams", "QR");
      double T    = 1000. * funcInit->GetParameter(1);
      double TErr = T * funcInit->GetParError(1) / funcInit->GetParameter(1);
      DrawTextOnPad("T = (" + Cbm::NumberToString(T, 1) + " #pm " + Cbm::NumberToString(TErr, 1) + ") MeV", 0.35, 0.1,
                    0.75, 0.3);
      DrawTextOnPad("a = " + Cbm::NumberToString(paramsA[iA], 2) + ", b = " + Cbm::NumberToString(paramsB[iB], 2), 0.12,
                    0.12, 0.5, 0.22);
      h2->SetBinContent(iA + 1, iB + 1, T);
    }
  }
  h2->GetZaxis()->SetRangeUser(163.5, 164.5);
  string cNameAll = "Temperature/CheckoutInitParams/All";
  fHMean.fHM.CreateCanvas(cNameAll, cNameAll, 1200, 800);
  DrawH2(h2, kLinear, kLinear, kLinear, "colz");
  DrawTextOnPad("Temperature in Dependance on Choice Start Params of Fit", 0.0, 0.9, 0.85, 0.99);
}
 
void LmvmDrawAll::CheckoutTemperatureParamB()
{
  TH1D* h = VaryBinWidth("cocktail_elid", "", fBwVarSig);
  vector<double> params;
  double param = 4.5;
  for (int i = 1; i <= 30; i++) {
    params.push_back(param);
    param += 0.05;
  }
  string hdescr = "hTempVsParamB; Parameter #it{b}; T [MeV]";
  TH1D* h1      = new TH1D("hTempVsParamB", hdescr.c_str(), params.size(), params[0], params[params.size() - 1]);
  for (size_t iX = 0; iX < params.size(); iX++) {
    string startstr = Cbm::NumberToString(params[iX], 2);
    h1->GetXaxis()->SetBinLabel(iX + 1, startstr.c_str());
  }
 
  for (size_t iP = 0; iP < params.size(); iP++) {
    double b  = params[iP];
    TF1* func = new TF1("TFuncTestParamB", "[0]*TMath::Power(x*[1], 3./2.)*TMath::Exp(-x/[1])", 1.1, 2.5);
    func->SetParameters(0.005, 0.15);
    string cName = "Temperature/CheckoutParamB/" + Cbm::NumberToString(b, 2);
    fHMean.fHM.CreateCanvas(cName, cName, 800, 800);
    int nBins = h->GetNbinsX();
    double x[nBins], y[nBins], ex[nBins], ey[nBins];
    for (int iB = 1; iB <= nBins; iB++) {
      double bW  = h->GetBinWidth(iB);
      double x1  = h->GetBinLowEdge(iB);
      x[iB - 1]  = x1 + (TMath::Log(b * bW) - TMath::Log(1 - TMath::Exp(-b * bW))) / b;
      y[iB - 1]  = h->GetBinContent(iB);
      ex[iB - 1] = 0.;
      ey[iB - 1] = h->GetBinError(iB);
    }
    auto graph = new TGraphErrors(nBins, x, y, ex, ey);
    graph->SetTitle("Temperature; M_{ee} [GeV/c^{2}]; dN/dM [Gev/c^{2}]^{-1}");
    graph->GetXaxis()->SetRangeUser(0., 2.5);
    graph->GetYaxis()->SetRangeUser(1e-10, 1e-1);
    graph->SetMarkerStyle(21);
    graph->Draw("AP");
    gPad->SetLogy(true);
    graph->Fit("TFuncTestParamB", "QR");
    double T    = 1000. * func->GetParameter(1);
    double TErr = T * func->GetParError(1) / func->GetParameter(1);
    DrawTextOnPad("T = (" + Cbm::NumberToString(T, 1) + " #pm " + Cbm::NumberToString(TErr, 1) + ") MeV", 0.35, 0.1,
                  0.75, 0.3);
    DrawTextOnPad("#it{b} = " + Cbm::NumberToString(b, 2), 0.12, 0.12, 0.3, 0.22);
    h1->SetBinContent(iP + 1, T);
  }
  h1->GetYaxis()->SetRangeUser(160., 180.);
  string cNameAll = "Temperature/CheckoutParamB/All";
  fHMean.fHM.CreateCanvas(cNameAll, cNameAll, 1800, 800);
  DrawH1(h1, kLinear, kLinear, "colz");
  DrawTextOnPad("Temperature in Dependance on Parameter #it{b}", 0.0, 0.9, 0.85, 0.99);
}
 
void LmvmDrawAll::CheckoutTemperatureParams()
{
  double b = fParamB[static_cast<int>(ELmvmAnaStep::ElId)];
  TH1D* h  = VaryBinWidth("cocktail_elid", "", fBwVarOrig);
 
  vector<double> params1 = {0.0001, 0.001, 0.005, 0.01, 0.02, 0.04, 0.1, 0.15, 0.2, 0.4, 1., 2., 5.};
  vector<double> params2 = {0.001, 0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.4, 0.6, 1., 1.5, 2., 5., 10.};
 
  string h2descr = "hTempVsParams; Parameter 1; Parameter 2; T [MeV]";
  TH2D* h2       = new TH2D("hTempVsParams", h2descr.c_str(), params1.size(), params1[0], params1[params1.size() - 1],
                      params2.size(), params2[0], params2[params2.size() - 1]);
  for (size_t iX = 0; iX < params1.size(); iX++) {
    string startstr = Cbm::NumberToString(params1[iX], 2);
    h2->GetXaxis()->SetBinLabel(iX + 1, startstr.c_str());
  }
  for (size_t iY = 0; iY < params2.size(); iY++) {
    string endstr = Cbm::NumberToString(params2[iY], 2);
    h2->GetYaxis()->SetBinLabel(iY + 1, endstr.c_str());
  }
 
  for (size_t iP1 = 0; iP1 < params1.size(); iP1++) {
    for (size_t iP2 = 0; iP2 < params2.size(); iP2++) {
      TF1* func = new TF1("TFuncTestParams", "[0]*TMath::Power(x*[1], 3./2.)*TMath::Exp(-x/[1])", 1.1, 2.5);
      func->SetParameters(params1[iP1], params2[iP2]);
      string cName = "Temperature/CheckoutParams/" + Cbm::NumberToString(params1[iP1], 2) + "_"
                     + Cbm::NumberToString(params2[iP2], 2);
      fHMean.fHM.CreateCanvas(cName, cName, 800, 800);
      int nBins = h->GetNbinsX();
      double x[nBins], y[nBins], ex[nBins], ey[nBins];
      for (int iB = 1; iB <= nBins; iB++) {
        double bW  = h->GetBinWidth(iB);
        double x1  = h->GetBinLowEdge(iB);
        x[iB - 1]  = x1 + (TMath::Log(b * bW) - TMath::Log(1 - TMath::Exp(-b * bW))) / b;
        y[iB - 1]  = h->GetBinContent(iB);
        ex[iB - 1] = 0.;
        ey[iB - 1] = h->GetBinError(iB);
      }
      auto graph = new TGraphErrors(nBins, x, y, ex, ey);
      graph->SetTitle("Temperature; M_{ee} [GeV/c^{2}]; dN/dM [Gev/c^{2}]^{-1}");
      graph->GetXaxis()->SetRangeUser(0., 2.5);
      graph->GetYaxis()->SetRangeUser(1e-10, 1e-1);
      graph->SetMarkerStyle(21);
      graph->Draw("AP");
      gPad->SetLogy(true);
      graph->Fit("TFuncTestParams", "QR");
      double T    = 1000. * func->GetParameter(1);
      double TErr = T * func->GetParError(1) / func->GetParameter(1);
      DrawTextOnPad("T = (" + Cbm::NumberToString(T, 1) + " #pm " + Cbm::NumberToString(TErr, 1) + ") MeV", 0.35, 0.1,
                    0.75, 0.3);
      DrawTextOnPad("p1 = " + Cbm::NumberToString(params1[iP1], 2) + ", p2 = " + Cbm::NumberToString(params2[iP2], 2),
                    0.12, 0.12, 0.5, 0.22);
      h2->SetBinContent(iP1 + 1, iP2 + 1, T);
    }
  }
  h2->GetZaxis()->SetRangeUser(163.5, 164.5);
  string cNameAll = "Temperature/CheckoutParams/All";
  fHMean.fHM.CreateCanvas(cNameAll, cNameAll, 1200, 800);
  DrawH2(h2, kLinear, kLinear, kLinear, "colz");
  DrawTextOnPad("Temperature in Dependance on Start Params of Fit", 0.0, 0.9, 0.85, 0.99);
}
 
void LmvmDrawAll::CheckoutTemperatureFitRangeAll()
{
  ELmvmAnaStep step = ELmvmAnaStep::ElId;
  TH1D* coc         = VaryBinWidth("cocktail_elid", "", fBwVarReg);
  TH1D* inmed       = VaryBinWidth("inmed", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), fBwVarReg);
  TH1D* qgp         = VaryBinWidth("qgp", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), fBwVarReg);
  inmed->Scale(1. / H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries());
  qgp->Scale(1. / H(ELmvmSignal::Qgp)->H1("hEventNumber")->GetEntries());
  TH1D* redcoc = (TH1D*) inmed->Clone();
  redcoc->Add(qgp);
  CheckoutTemperatureFitRange(coc, "cocktail");
  CheckoutTemperatureFitRange(redcoc, "reduced cocktail");
}
 
void LmvmDrawAll::CheckoutTemperatureFitRange(TH1D* h, string name)
{
  double b              = fParamB[static_cast<int>(ELmvmAnaStep::ElId)];
  vector<double> vStart = {0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5};
  vector<double> vEnd   = {1.8, 1.9, 2., 2.1, 2.2, 2.3, 2.4, 2.5};
 
  string hName   = "hTempVsFitRange_" + name;
  string h2descr = hName + "; #it{m}_{start} [GeV]; #it{m}_{end} [GeV]; T [MeV]";
  TH2D* h2 = new TH2D(hName.c_str(), h2descr.c_str(), vStart.size(), vStart[0], vStart[vStart.size() - 1], vEnd.size(),
                      vEnd[0], vEnd[vEnd.size() - 1]);
  for (size_t iX = 0; iX < vStart.size(); iX++) {
    string startstr = Cbm::NumberToString(vStart[iX], 2);
    h2->GetXaxis()->SetBinLabel(iX + 1, startstr.c_str());
  }
  for (size_t iY = 0; iY < vEnd.size(); iY++) {
    string endstr = Cbm::NumberToString(vEnd[iY], 2);
    h2->GetYaxis()->SetBinLabel(iY + 1, endstr.c_str());
  }
 
  for (size_t iStart = 0; iStart < vStart.size(); iStart++) {
    for (size_t iEnd = 0; iEnd < vEnd.size(); iEnd++) {
      TF1* func = new TF1("TFuncCheckoutFitRange", "[0]*TMath::Power(x*[1], 3./2.)*TMath::Exp(-x/[1])", vStart[iStart],
                          vEnd[iEnd]);
      func->SetParameters(0.005, 0.16);
      string cName = "Temperature/CheckoutFitRange/" + name + "/" + Cbm::NumberToString(vStart[iStart], 2) + "_"
                     + Cbm::NumberToString(vEnd[iEnd], 2);
      fHMean.fHM.CreateCanvas(cName, cName, 1100, 800);
      int nBins = h->GetNbinsX();
      double x[nBins], y[nBins], ex[nBins], ey[nBins];
      for (int iB = 1; iB <= nBins; iB++) {
        double bW  = h->GetBinWidth(iB);
        double x1  = h->GetBinLowEdge(iB);
        x[iB - 1]  = x1 + (TMath::Log(b * bW) - TMath::Log(1 - TMath::Exp(-b * bW))) / b;
        y[iB - 1]  = h->GetBinContent(iB);
        ex[iB - 1] = 0.;
        ey[iB - 1] = h->GetBinError(iB);
      }
      auto graph = new TGraphErrors(nBins, x, y, ex, ey);
      graph->SetTitle("Temperature; M_{ee} [GeV/c^{2}]; dN/dM [Gev/c^{2}]^{-1}");
      graph->GetXaxis()->SetRangeUser(0., 2.5);
      graph->GetYaxis()->SetRangeUser(1e-10, 1e-1);
      graph->SetMarkerStyle(21);
      graph->Draw("AP");
      gPad->SetLogy(true);
      graph->Fit("TFuncCheckoutFitRange", "QR");
      double T    = 1000. * func->GetParameter(1);
      double TErr = T * func->GetParError(1) / func->GetParameter(1);
      DrawTextOnPad("T = (" + Cbm::NumberToString(T, 1) + " #pm " + Cbm::NumberToString(TErr, 1) + ") MeV", 0.35, 0.1,
                    0.75, 0.3);
      DrawTextOnPad("FitRange: x_{start} = " + Cbm::NumberToString(vStart[iStart], 2)
                      + ", x_{end} = " + Cbm::NumberToString(vEnd[iEnd], 2),
                    0.02, 0.05, 0.44, 0.25);
      h2->SetBinContent(iStart + 1, iEnd + 1, T);
    }
  }
  h2->GetZaxis()->SetRangeUser(109., 180.);
  string cNameAll = "Temperature/CheckoutFitRange/" + name + "/All";
  fHMean.fHM.CreateCanvas(cNameAll, cNameAll, 1530, 800);
  DrawH2(h2, kLinear, kLinear, kLinear, "colz");
  DrawTextOnPad("Temperature in Dependance on Fit Range (" + name + ")", 0.0, 0.9, 0.8, 0.99);
}
 
void LmvmDrawAll::DrawTemperatureGraph(
  TH1D* h, ELmvmAnaStep step, double startfit,
  double endfit)  // TODO: merge these two methods if bool 'DoCorrectX' is not needed anymore
{
  DrawTemperatureGraph(h, step, startfit, endfit, true);
}
 
void LmvmDrawAll::DrawTemperatureGraph(TH1D* h, ELmvmAnaStep step, double startfit, double endfit,
                                       bool DoCorrectX)  // TODO: delete bool etc.;
{
  fTempGraphCounter++;
  string cstring = Cbm::NumberToString(fTempGraphCounter, 0);
  // Functions
  TF1* TFunc =
    new TF1(("TFunc" + cstring).c_str(), "[0]*TMath::Power(x*[1], 3./2.)*TMath::Exp(-x/[1])", startfit, endfit);
  TFunc->SetParameters(0.01, 0.15);
 
  double b = fParamB[static_cast<int>(step)];
 
  int nBins = h->GetNbinsX();
  double x[nBins], y[nBins], ex[nBins], ey[nBins];
  for (int iB = 1; iB <= nBins; iB++) {
    double bW = h->GetBinWidth(iB);
    double x1 = h->GetBinLowEdge(iB);
    x[iB - 1] =
      (DoCorrectX) ? x1 + (TMath::Log(b * bW) - TMath::Log(1 - TMath::Exp(-b * bW))) / b : h->GetBinCenter(iB);
    y[iB - 1]  = h->GetBinContent(iB);
    ex[iB - 1] = 0.;
    ey[iB - 1] = h->GetBinError(iB);
  }
  auto graph = new TGraphErrors(nBins, x, y, ex, ey);
  graph->SetTitle("Temperature; M_{ee} [GeV/c^{2}]; dN/dM_{ee} [Gev/c^{2}]^{-1}");
  graph->GetXaxis()->SetRangeUser(0., 2.5);
  graph->GetYaxis()->SetRangeUser(1e-9, 3e-2);
  graph->GetXaxis()->SetNdivisions(505, true);
  graph->GetYaxis()->SetNdivisions(510, true);
  graph->GetXaxis()->SetLabelSize(0.06);
  graph->GetYaxis()->SetLabelSize(0.06);
  graph->GetXaxis()->SetTitleSize(0.06);
  graph->GetYaxis()->SetTitleSize(0.06);
  graph->GetXaxis()->SetTitleOffset(1.0);
  graph->GetYaxis()->SetTitleOffset(1.3);
  graph->SetMarkerStyle(25);
  graph->SetMarkerSize(1.2);
  graph->SetMarkerColor(2);
  graph->SetLineColor(2);
  gPad->SetLeftMargin(0.2);  //0.17
  gPad->SetBottomMargin(0.15);
  gPad->SetGrid(1, 1);
  graph->Draw("AP");
  //graph->Fit(("TFunc" + cstring).c_str(), "QR");
  //double T = 1000. * TFunc->GetParameter(1);
  //double TErr = T * TFunc->GetParError(1)/TFunc->GetParameter(1);
  //DrawTextOnPad("T = (" + Cbm::NumberToString(T, 1) + " #pm " + Cbm::NumberToString(TErr, 1) + ") MeV", 0.35, 0.1, 0.75, 0.3);
  gPad->SetLogy(true);
}
 
void LmvmDrawAll::DrawTemperature(TH1D* h, double startfit, double endfit)
{
  TF1* TFunc = new TF1("TFunc", "[0]*TMath::Power(x*[1], 3./2.)*TMath::Exp(-x/[1])", startfit, endfit);
  TFunc->SetParameters(0.02, 0.15);
  DrawH1(h, kLinear, kLog, "p");
  h->Fit("TFunc", "QR");
  double T    = 1000. * TFunc->GetParameter(1);
  double TErr = T * TFunc->GetParError(1) / TFunc->GetParameter(1);
  DrawTextOnPad("T = (" + Cbm::NumberToString(T, 1) + " #pm " + Cbm::NumberToString(TErr, 1) + ") MeV", 0.45, 0.1, 0.85,
                0.3);
}
 
void LmvmDrawAll::InitialiseCocktailFitParams()
{
  fParamB.resize(fHMean.fNofAnaSteps);
  for (auto step : fHMean.fAnaSteps) {
    TH1D* coc    = GetCocktailMinvH1("hMinv", step, false);  // "hMinv" + cat,
    TF1* TFitCoc = new TF1("TFitCoc", "[0]*TMath::Exp(-[1]*x)", 1.1, 2.5);
    TFitCoc->SetParameters(0.01, 5.);
    string cName = "Temperature/ParamB/" + fHMean.fAnaStepNames[static_cast<int>(step)];
    fHMean.fHM.CreateCanvas(cName, cName, 1600, 1100);
    DrawH1(coc, kLinear, kLog, "p");
    coc->Fit("TFitCoc", "QR");
    double a                        = TFitCoc->GetParameter(0);
    double b                        = TFitCoc->GetParameter(1);
    fParamB[static_cast<int>(step)] = b;
    DrawTextOnPad("Parameters: #it{a} = " + Cbm::NumberToString(a, 2) + ", #it{b} = " + Cbm::NumberToString(b, 2), 0.12,
                  0.12, 0.65, 0.25);
    DrawTextOnPad("Fit: #it{a#upointe^{-bx}}", 0.6, 0.76, 0.8, 0.81);
    fHMean.DrawAnaStepOnPad(step);
  }
  // Check Values
  /*LOG(info) << "Check Params B:";
  for (size_t i = 0; i < fParamB.size(); i++) {
    cout << "        Step " << fHMean.fAnaStepNames[i] << ": b = " << fParamB[i] << endl;
  }*/
}
 
void LmvmDrawAll::DrawTemperature()
{
  ELmvmAnaStep step = ELmvmAnaStep::ElId;
  string cName      = "Temperature/";
  InitialiseCocktailFitParams();
 
  // Estimate Systematic Error of Temperature Calculation
  //CheckoutTemperatureParamB();
  //CheckoutTemperatureInitParams();
  //CheckoutTemperatureParams();
  //CheckoutTemperatureFitRangeAll();
 
  // Draw Temperature related Functions
  {
    fHMean.fHM.CreateCanvas(cName + "Functions", cName + "Functions", 950, 800);
    TF1* cocfit  = new TF1("cocfit", "0.000177 * TMath::Exp(-5.25 * x)", 1.1, 2.5);
    TF1* tempfit = new TF1("tempfit", "0.005255 * TMath::Power(0.1641 * x, 3./2.) * TMath::Exp(-x/0.1641)", 1.1, 2.5);
    cocfit->SetTitle("TempFuncs;M_{ee} [GeV/c^{2}];dN/dM [GeV/c^{2}]^{-1}");
    tempfit->SetLineColor(4);
    cocfit->Draw();
    tempfit->Draw("same");
    gPad->SetLogy(true);
    gPad->RangeAxis(0., 1e-10, 2.5, 1e-2);
    TLegend* legend = new TLegend(0.55, 0.75, 0.88, 0.88);
    legend->AddEntry(cocfit, "a #upoint e^{-bx}", "l");
    legend->AddEntry(tempfit, "p_{1} #upoint (T #upoint x)^{3/2} #upoint e^{-x/T}", "l");
    legend->Draw();
  }
 
  // Temperature of Signal vs. Cocktail
  {
    vector<pair<double, double>> varbin = fBwVarSig3;
    TH1D* sig                           = GetSignal(step, varbin);
    //TH1D* sig = VaryBinWidth("mean", "hSignal", step, varbin);
    TH1D* coc = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, varbin);
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "SignalVsCocktail", cName + "SignalVsCocktail", 2100, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawTemperatureGraph(coc, step, 1.1, 2.5, true);
    DrawTextOnPad("Cocktail", 0.25, 0.9, 0.7, 0.99);
    c->cd(2);
    DrawTemperatureGraph(sig, step, 1.1, 2.5, true);
    DrawTextOnPad("Signal", 0.25, 0.9, 0.65, 0.99);
  }
 
  // Temperature of Cocktail with different bin width variations
  {
    TH1D* cocO =
      VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarOrig);
    TH1D* cocR =
      VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarReg);
    TH1D* cocS =
      VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarSig);
    TH1D* cocO2 =
      VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarOrig);
    TH1D* cocR2 =
      VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarReg);
    TH1D* cocS2 =
      VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarSig);
 
    TCanvas* c =
      fHMean.fHM.CreateCanvas(cName + "Cocktail/CheckCorrections", cName + "Cocktail/CheckCorrections", 3800, 1600);
    c->Divide(3, 2);
    c->SetGrid();
    c->cd(1);
    DrawTemperatureGraph(cocO, ELmvmAnaStep::ElId, 1.1, 2.5, false);
    DrawTextOnPad("Cocktail (#it{X} uncorrected)", 0.1, 0.9, 0.7, 0.99);
    c->cd(2);
    DrawTemperatureGraph(cocR, ELmvmAnaStep::ElId, 1.1, 2.5, false);
    DrawTextOnPad("Cocktail (#it{X} uncorrected)", 0.1, 0.9, 0.7, 0.99);
    c->cd(3);
    DrawTemperatureGraph(cocS, ELmvmAnaStep::ElId, 1.1, 2.5, false);
    DrawTextOnPad("Cocktail (#it{X} uncorrected)", 0.1, 0.9, 0.7, 0.99);
    c->cd(4);
    DrawTemperatureGraph(cocO2, ELmvmAnaStep::ElId, 1.1, 2.5, true);
    DrawTextOnPad("Cocktail (#it{X} corrected)", 0.11, 0.9, 0.69, 0.99);
    c->cd(5);
    DrawTemperatureGraph(cocR2, ELmvmAnaStep::ElId, 1.1, 2.5, true);
    DrawTextOnPad("Cocktail (#it{X} corrected)", 0.11, 0.9, 0.69, 0.99);
    c->cd(6);
    DrawTemperatureGraph(cocS2, ELmvmAnaStep::ElId, 1.1, 2.5, true);
    DrawTextOnPad("Cocktail (#it{X} corrected)", 0.11, 0.9, 0.69, 0.99);
  }
 
  // Variation of Temperature in dep. on different Slopes (Cocktail)
  {
    TH1D* coc   = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fBwVarOrig);
    TH1D* coc2  = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fBwVarOrig);
    TH1D* coc5  = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fBwVarOrig);
    TH1D* coc20 = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fBwVarOrig);
    coc->GetXaxis()->SetRangeUser(1e-10, 1e-1);
    coc2->GetXaxis()->SetRangeUser(1e-10, 1e-1);
    coc5->GetXaxis()->SetRangeUser(1e-10, 1e-1);
    coc20->GetXaxis()->SetRangeUser(1e-10, 1e-1);
    for (int iB = 1; iB <= coc->GetNbinsX(); iB++) {
      double m   = coc->GetBinCenter(iB);
      double y0  = coc->GetBinContent(iB);
      double y2  = y0 * (1 + (2 - 1) * (m - 0.) / (2.5 - 0.));
      double y5  = y0 * (1 + (5 - 1) * (m - 0.) / (2.5 - 0.));
      double y20 = y0 * (1 + (20 - 1) * (m - 0.) / (2.5 - 0.));
      coc2->SetBinContent(iB, y2);
      coc5->SetBinContent(iB, y5);
      coc20->SetBinContent(iB, y20);
    }
    string cNameFull = cName + "Cocktail/" + "TempVsSlope";
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 2200, 1600);
    c->Divide(2, 2);
    c->cd(1);
    gPad->SetGrid();
    DrawTemperatureGraph(coc, step, 1.3, 2.5);
    DrawTextOnPad("orig.", 0.67, 0.4, 0.85, 0.5);
    c->cd(2);
    gPad->SetGrid();
    DrawTemperatureGraph(coc2, step, 1.3, 2.5);
    DrawTextOnPad("f = 2", 0.67, 0.4, 0.85, 0.5);
    c->cd(3);
    gPad->SetGrid();
    DrawTemperatureGraph(coc5, step, 1.3, 2.5);
    DrawTextOnPad("f = 5", 0.67, 0.4, 0.85, 0.5);
    c->cd(4);
    gPad->SetGrid();
    DrawTemperatureGraph(coc20, step, 1.3, 2.5);
    DrawTextOnPad("f = 20", 0.67, 0.4, 0.87, 0.5);
  }
 
  // Temperature for full and reduced Signal (with different fit ranges)
  {
    TH1D* hFull = fHMean.H1Clone("hSignal_bwvSig3_elid");
    TH1D* hRed  = fHMean.H1Clone("hSignalReduced_bwvSig3_elid");
    TH1D* hRed2 = fHMean.H1Clone("hSignalReduced_bwvSig3_elid");
    hFull->GetYaxis()->SetRangeUser(1e-10, 5e-2);
    hRed->GetYaxis()->SetRangeUser(1e-10, 5e-2);
    hRed2->GetYaxis()->SetRangeUser(1e-10, 5e-2);
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Signal/Signal", cName + "Signal/Signal", 3300, 800);
    c->Divide(3, 1);
    c->cd(1);
    DrawTemperatureGraph(hFull, step, 1.15, 2.5);
    DrawTextOnPad("Signal", 0.35, 0.9, 0.53, 0.99);
    c->cd(2);
    DrawTemperatureGraph(hRed, step, 1.15, 2.5);
    DrawTextOnPad("Reduced Signal", 0.28, 0.9, 0.6, 0.99);
    c->cd(3);
    DrawTemperatureGraph(hRed2, step, 1.05, 2.5);
    DrawTextOnPad("Reduced Signal", 0.28, 0.9, 0.6, 0.99);
  }
 
  // Temperature for Signal histograms with different binnings (compared to Cocktail)
  {
    vector<pair<double, double>> bwv0 = {make_pair(1.1, 0.1), make_pair(1.5, 0.4), make_pair(2.5, 1.0)};
    vector<pair<double, double>> bwv1 = {make_pair(1.1, 0.1), make_pair(1.5, 0.2), make_pair(2.5, 1.0)};
    vector<pair<double, double>> bwv2 = {make_pair(1.1, 0.1), make_pair(1.5, 0.4), make_pair(2.5, 0.5)};
    vector<pair<double, double>> bwv3 = {make_pair(1.1, 0.1), make_pair(1.5, 0.2), make_pair(2.5, 0.5)};
    vector<pair<double, double>> bwv4 = {make_pair(1.1, 0.1), make_pair(1.5, 0.2), make_pair(2.0, 0.25),
                                         make_pair(2.5, 0.5)};
    vector<pair<double, double>> bwv5 = {make_pair(1.1, 0.1), make_pair(1.5, 0.2), make_pair(2.0, 0.25),
                                         make_pair(2.5, 0.25)};
    vector<pair<double, double>> bwv6 = {make_pair(1.1, 0.1), make_pair(1.5, 0.2), make_pair(2.0, 0.25),
                                         make_pair(2.5, 0.1)};
    TCanvas* c =
      fHMean.fHM.CreateCanvas("Temperature/Signal_bwVariations", "Temperature/Signal_bwVariations", 1900, 800);
    c->Divide(3, 2);
    int iC = 1;
    for (vector<pair<double, double>> bwv : {bwv1, bwv2, bwv3, bwv4, bwv5, bwv6}) {
      c->cd(iC++);
      TH1D* sig = GetSignal(step, bwv);
      DrawTemperatureGraph(sig, step, 1.1, 2.0);
      DrawTextOnPad("Signal", 0.38, 0.9, 0.62, 0.99);
    }
  }
 
  // Draw Temperature for Signal with un-/corrected x-values
  {
    TH1D* h    = fHMean.H1Clone("hSignal_bwvSig_elid");
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Signal/BinCorrection", cName + "Signal/BinCorrection", 2100, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawTemperatureGraph(h, ELmvmAnaStep::ElId, 1.1, 2.5, false);
    DrawTextOnPad("Signal (uncorrected in #it{X})", 0.1, 0.9, 0.64, 0.99);
    c->cd(2);
    DrawTemperatureGraph(h, ELmvmAnaStep::ElId, 1.1, 2.5, true);
    DrawTextOnPad("Signal (corrected in #it{X})", 0.11, 0.9, 0.62, 0.99);
  }
 
  // Plot phi to choose starting point for fitting range
  {
    TH1D* phiAcc   = H(ELmvmSignal::Phi)->H1Clone("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::Acc);
    TH1D* phiElid  = H(ELmvmSignal::Phi)->H1Clone("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId);
    TH1D* phiElid2 = (TH1D*) phiElid->Clone();
    phiElid2->GetXaxis()->SetRangeUser(1.0, 1.2);
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Phi", cName + "Phi", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({phiElid, phiAcc}, {"El-ID", "Acc"}, kLinear, kLog, true, 0.75, 0.78, 0.9, 0.9, "hist");
    c->cd(2);
    DrawH1({phiElid2}, {"El-ID zoom"}, kLinear, kLog, true, 0.67, 0.82, 0.9, 0.9, "hist");
  }
}
 
void LmvmDrawAll::ChargeSymmetry()
{
  string cName = "ChargeSymmetry/";
 
  // Master
  {
    ELmvmAnaStep step                   = ELmvmAnaStep::ElId;
    vector<pair<double, double>> varbin = {make_pair(2.5, 0.05)};
    TCanvas* c                          = fHMean.fHM.CreateCanvas(cName + "master", cName + "master", 1600, 2400);
    c->Divide(2, 3);
    int iC = 1;
    for (const string type : {"hmx", "hfsc"}) {
      for (const string ev : {"sameEv", "mixedEv"}) {
        if (type == "hmx" && ev == "mixedEv")
          varbin = fBwVarBg;
        else if (type == "hmx" && ev == "sameEv")
          varbin = fBwVarBg;
        string mode   = (type == "hmx") ? "evmix" : "fastsim";
        string hName  = type + "_" + "Minv";
        TH1D* pm      = VaryBinWidth(mode, fHMean.GetName(hName + "PM_" + ev, step), varbin);
        TH1D* pp      = VaryBinWidth(mode, fHMean.GetName(hName + "PP_" + ev, step), varbin);
        TH1D* mm      = VaryBinWidth(mode, fHMean.GetName(hName + "MM_" + ev, step), varbin);
        int nBins     = pm->GetNbinsX();
        TH1D* hr_ppmm = (TH1D*) pp->Clone();
        TH1D* hr_pppm = (TH1D*) pp->Clone();
        TH1D* hr_mmpm = (TH1D*) mm->Clone();
        hr_ppmm->Divide(mm);
        hr_pppm->Divide(pm);
        hr_mmpm->Divide(pm);
        int startbin   = pm->FindBin(0.7);
        double Ipm     = pm->Integral(startbin, nBins);
        double Ipp     = pp->Integral(startbin, nBins);
        double Imm     = mm->Integral(startbin, nBins);
        double r_ppmm  = Ipp / Imm;
        double r_pppm  = Ipp / Ipm;
        double r_mmpm  = Imm / Ipm;
        double k       = Ipm / (2 * std::sqrt(Ipp * Imm));
        string sr_ppmm = Cbm::NumberToString(r_ppmm, 2);
        string sr_pppm = Cbm::NumberToString(r_pppm, 2);
        string sr_mmpm = Cbm::NumberToString(r_mmpm, 2);
        string s_k     = Cbm::NumberToString(k, 2);
        c->cd(iC++);
        hr_ppmm->GetYaxis()->SetTitle("Ratio");
        hr_ppmm->GetYaxis()->SetRangeUser(0., 1.5);
        string texttype = (type == "hmx") ? "Simulation" : "FastSim";
        string textmode = (ev == "sameEv") ? "(same Events)" : "(mixed Events)";
        DrawH1({hr_ppmm, hr_pppm, hr_mmpm}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, 0.2, 0.6, 0.38, 0.85,
               "hist");
        //DrawTextOnPad("N++/N-- = " + sr_ppmm + ", N+-/(2 #sqrt{N++ N--}) = " + s_k, 0.05, 0.12, 0.89, 0.25);
        DrawTextOnPad(texttype + " " + textmode, 0.1, 0.9, 0.9, 0.99);
      }
    }
    TH1D* bre         = VaryBinWidth("mean", fHMean.GetName("hfsc_MinvBg", step), fBwVarBg);
    TH1D* cbc         = VaryBinWidth("mean", fHMean.GetName("hCbBg", step), fBwVarBg);
    TH1D* cbre        = VaryBinWidth("mean", "hReCb", fBwVarBg);
    TH1D* hr_cbc_bre  = (TH1D*) cbc->Clone();
    TH1D* hr_cbre_bre = (TH1D*) cbre->Clone();
    hr_cbc_bre->Divide(bre);
    hr_cbre_bre->Divide(bre);
    int nBins          = bre->GetNbinsX();
    int startbin       = bre->FindBin(0.7);
    double I_bre       = bre->Integral(startbin, nBins);
    double I_cbc       = cbc->Integral(startbin, nBins);
    double I_cbre      = cbre->Integral(startbin, nBins);
    double r_cbc_bre   = I_cbc / I_bre;
    double r_cbre_bre  = I_cbre / I_bre;
    string sr_cbc_bre  = Cbm::NumberToString(r_cbc_bre, 2);
    string sr_cbre_bre = Cbm::NumberToString(r_cbre_bre, 2);
    c->cd(iC++);
    DrawH1({hr_cbc_bre, hr_cbre_bre}, {"CB_{Sim} / B_{FS}", "CB_{FS} / B_{FS}"}, kLinear, kLinear, true, 0.6, 0.7, 0.92,
           0.91, "hist");
    DrawTextOnPad("CB_{Sim} / B_{FS} = " + sr_cbc_bre + ", CB_{FS} / B_{FS} = " + sr_cbre_bre, 0.08, 0.12, 0.89, 0.25);
  }
 
  // Ratios of Backgrounds with Charge Symmetries from Simulation
  for (const string cat : {""}) {  // , "_trueEl"}) { // TODO: ReCb not yet available for true electrons
    TH1D* bre  = VaryBinWidth("mean", "hfsc_MinvBg" + cat + "_elid", fBwVarBg);
    TH1D* cbc  = VaryBinWidth("mean", "hCbBg" + cat + "_elid", fBwVarBg);
    TH1D* cbre = VaryBinWidth("mean", "hReCb", fBwVarBg);
    TH1D* rat1 = (TH1D*) cbc->Clone();
    rat1->Divide(bre);
    TH1D* rat2 = (TH1D*) cbre->Clone();
    rat2->Divide(bre);
    rat1->GetYaxis()->SetTitle("Ratio");
    rat2->GetYaxis()->SetTitle("Ratio");
    rat1->GetYaxis()->SetRangeUser(0.95, 1.05);
    rat2->GetYaxis()->SetRangeUser(0.95, 1.05);
    string cNameFull = (cat == "") ? cName + "ReCb_all" : cName + "ReCb_trueEl";
    string label     = (cat == "") ? "(all)" : "(electrons)";
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 1600, 1600);
    c->Divide(2, 2);
    c->cd(1);
    DrawH1({rat1}, {"CB_{calc} / B_{FS}"}, kLinear, kLinear, true, 0.7, 0.8, 0.95, 0.9, "hist");
    DrawTextOnPad("Ratio " + label, 0.2, 0.9, 0.8, 0.99);
    c->cd(2);
    if (cat == "") DrawH1({rat2}, {"CB_{FS} / B_{FS}"}, kLinear, kLinear, true, 0.7, 0.8, 0.95, 0.9, "hist");
    DrawTextOnPad("Ratio " + label, 0.2, 0.9, 0.8, 0.99);
    int iC = 3;
    for (const string ev : {"sameEv", "mixedEv"}) {
      vector<pair<double, double>> varbin = fBwVarBg4;
      if (ev == "mixedEv") varbin = fBwVarBg3;
      TH1D* pm   = VaryBinWidth("evmix", "hmx_MinvPM" + cat + "_" + ev + "_elid", varbin);
      TH1D* pp   = VaryBinWidth("evmix", "hmx_MinvPP" + cat + "_" + ev + "_elid", varbin);
      TH1D* mm   = VaryBinWidth("evmix", "hmx_MinvMM" + cat + "_" + ev + "_elid", varbin);
      TH1D* ppmm = (TH1D*) pp->Clone();
      TH1D* pppm = (TH1D*) pp->Clone();
      TH1D* mmpm = (TH1D*) mm->Clone();
      ppmm->Divide(mm);
      pppm->Divide(pm);
      mmpm->Divide(pm);
      ppmm->GetYaxis()->SetTitle("Ratio");
      ppmm->GetYaxis()->SetRangeUser(0., 1.6);
      c->cd(iC++);
      DrawH1({ppmm, pppm, mmpm}, {"N--/N++", "N++/N+-", "N--/N+-"}, kLinear, kLinear, true, 0.77, 0.77, 0.95, 0.95,
             "hist");
      string title = (ev == "sameEv") ? "Same Events" : "Mixed Events";
      DrawTextOnPad(title, 0.2, 0.9, 0.8, 0.99);
    }
  }
 
  // B_RE vs. CB_RE Ratios with Pair Yields from Fast Simulations
  {
    string hName      = "hfsc_Minv";
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TH1D* pmSame      = fHFastSim.H1Clone(hName + "PM_sameEv", step);
    TH1D* ppSame      = fHFastSim.H1Clone(hName + "PP_sameEv", step);
    TH1D* mmSame      = fHFastSim.H1Clone(hName + "MM_sameEv", step);
    TH1D* pmMixed     = fHFastSim.H1Clone(hName + "PM_mixedEv", step);
    TH1D* ppMixed     = fHFastSim.H1Clone(hName + "PP_mixedEv", step);
    TH1D* mmMixed     = fHFastSim.H1Clone(hName + "MM_mixedEv", step);
    TH1D* bre         = fHMean.H1Clone("hfsc_MinvBg", step);
    TH1D* cbre        = fHMean.H1Clone("hReCb");
    TH1D* k           = fHMean.H1Clone("hReCbK");
    TH1D* rat         = (TH1D*) cbre->Clone();
    rat->Divide(bre);
    rat->GetYaxis()->SetTitle("Ratio");
    rat->GetYaxis()->SetRangeUser(0.95, 1.05);
    string cNameFull = cName + "FastSim";
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 1600, 1600);
    c->Divide(2, 2);
    c->cd(1);
    DrawH1({pmSame, ppSame, mmSame}, {"e+e-", "e+e+", "e-e-"}, kLinear, kLog, true, 0.7, 0.7, 0.91, 0.9, "hist");
    DrawTextOnPad("Pair Yields (Same Events)", 0.2, 0.9, 0.8, 0.99);
    c->cd(2);
    DrawH1({pmMixed, ppMixed, mmMixed}, {"e+e-", "e+e+", "e-e-"}, kLinear, kLog, true, 0.7, 0.7, 0.91, 0.9, "hist");
    DrawTextOnPad("Pair Yields (Mixed Events)", 0.19, 0.9, 0.81, 0.99);
    c->cd(3);
    DrawH1(k, kLinear, kLinear, "hist");
    DrawTextOnPad("#it{k} Factor", 0.3, 0.9, 0.7, 0.99);
    c->cd(4);
    DrawH1({rat}, {"CB_{FS} / B_{FS}"}, kLinear, kLinear, true, 0.7, 0.8, 0.91, 0.9, "hist");
    DrawTextOnPad("Ratio", 0.1, 0.9, 0.84, 0.99);
  }
}
 
void LmvmDrawAll::DrawStudies()  // Comment procedures which currently are not necessary
{
  string cName = "Studies/";
 
  // Restricted vs. full RICH: Pt-Y
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    LmvmHist HMfull, HMrestr;
 
    TFile* fileFull =
      new TFile("/lustre/cbm/users/criesen/data/studies/FullVsRestrRich/lmvm_fullRich/inmed/analysis.all.root");
    HMfull.fHM.ReadFromFile(fileFull);
    double nEvFull   = HMfull.H1("hEventNumber")->GetEntries();
    TH2D* hFullInmed = HMfull.H2Clone("hPtY_plutoEl+", step);
    hFullInmed->Add(HMfull.H2("hPtY_plutoEl-", step));
    TH2D* hFullEl = HMfull.H2Clone("hPtY_urqmdEl+", step);
    hFullEl->Add(HMfull.H2("hPtY_urqmdEl-", step));
    TH2D* hFullPi = HMfull.H2Clone("hPtY_pion+", step);
    hFullPi->Add(HMfull.H2("hPtY_pion-", step));
    hFullInmed->Scale(1. / nEvFull);
    hFullEl->Scale(1. / nEvFull);
    hFullPi->Scale(1. / nEvFull);
 
    TFile* fileRest =
      new TFile("/lustre/cbm/users/criesen/data/studies/FullVsRestrRich/lmvm_restRich/inmed/analysis.all.root");
    HMrestr.fHM.ReadFromFile(fileRest);
    double nEvRest   = HMrestr.H1("hEventNumber")->GetEntries();
    TH2D* hRestInmed = HMrestr.H2Clone("hPtY_plutoEl+", step);
    hRestInmed->Add(HMrestr.H2("hPtY_plutoEl-", step));
    TH2D* hRestEl = HMrestr.H2Clone("hPtY_urqmdEl+", step);
    hRestEl->Add(HMrestr.H2("hPtY_urqmdEl-", step));
    TH2D* hRestPi = HMrestr.H2Clone("hPtY_pion+", step);
    hRestPi->Add(HMrestr.H2("hPtY_pion-", step));
    hRestInmed->Scale(1. / nEvRest);
    hRestEl->Scale(1. / nEvRest);
    hRestPi->Scale(1. / nEvRest);
 
    DrawPtY(hFullInmed, hRestInmed, cName + "/FullVsRestrRich/inmed", 1e-9, 1e-3);
    DrawPtY(hFullEl, hRestEl, cName + "/FullVsRestrRich/electrons", 1e-9, 1e-3);
    DrawPtY(hFullPi, hRestPi, cName + "/FullVsRestrRich/pions", 1e-9, 1e-3);
  }
}
 
void LmvmDrawAll::DrawPtY(TH2D* hMc, TH2D* h, const string cName, double zMin, double zMax)
{
  TH2D* eff = (TH2D*) h->Clone();
  eff->Divide(hMc);
  hMc->GetZaxis()->SetRangeUser(zMin, zMax);
  h->GetZaxis()->SetRangeUser(zMin, zMax);
  eff->GetZaxis()->SetRangeUser(0., 2.);
  double e = h->Integral(0, h->GetXaxis()->GetNbins() + 1, 0, h->GetYaxis()->GetNbins() + 1)
             / hMc->Integral(0, h->GetXaxis()->GetNbins() + 1, 0, h->GetYaxis()->GetNbins() + 1);
  TCanvas* c = fHMean.fHM.CreateCanvas(cName, cName, 2400, 800);
  c->Divide(3, 1);
  c->cd(1);
  DrawH2(hMc, kLinear, kLinear, kLog, "colz");
  c->cd(2);
  DrawH2(h, kLinear, kLinear, kLog, "colz");
  c->cd(3);
  DrawH2(eff, kLinear, kLinear, kLinear, "colz");
  DrawTextOnPad("Efficiency", 0.25, 0.9, 0.75, 0.99);
  DrawTextOnPad("Eff = " + Cbm::NumberToString(e, 2), 0.42, 0.8, 0.75, 0.9);
}
 
void LmvmDrawAll::DrawPtY()
{
  ELmvmAnaStep step = ELmvmAnaStep::ElId;
  string cName      = "PtY/";
  // UrQMD
  for (const string& ptcl : fHMean.fCandNames) {
    if (ptcl == fHMean.fCandNames[0] || ptcl == fHMean.fCandNames[1]) continue;
    TH2D* hMc = fHMean.H2Clone("hPtY_" + ptcl, ELmvmAnaStep::Mc);
    TH2D* h   = fHMean.H2Clone("hPtY_" + ptcl, step);
    DrawPtY(hMc, h, cName + ptcl, 1e-10, 1e2);
  }
 
  // PLUTO
  for (ELmvmSignal signal : fHMean.fSignals) {
    TH2D* hMcP = H(signal)->H2Clone("hPtY_plutoEl+", ELmvmAnaStep::Mc);
    TH2D* hMcM = H(signal)->H2Clone("hPtY_plutoEl-", ELmvmAnaStep::Mc);
    TH2D* hMc  = (TH2D*) hMcP->Clone();
    hMc->Add(hMcM);
 
    TH2D* hP = H(signal)->H2Clone("hPtY_plutoEl+", step);
    TH2D* hM = H(signal)->H2Clone("hPtY_plutoEl-", step);
    TH2D* h  = (TH2D*) hP->Clone();
    h->Add(hM);
 
    string sigName = fHMean.fSignalNames[static_cast<int>(signal)];
    DrawPtY(hMcP, hP, cName + sigName + "_plutoEl+", 1e-10, 1e2);
    DrawPtY(hMcM, hM, cName + sigName + "_plutoEl-", 1e-10, 1e2);
    DrawPtY(hMc, h, cName + sigName, 1e-10, 1e2);
  }
}
 
TH1D* LmvmDrawAll::VaryBinWidth(const string& option, const string& hName, ELmvmAnaStep step,
                                vector<pair<double, double>> binValues)
{
  TH1D* h = VaryBinWidth(option, fHMean.GetName(hName, step), -1., binValues);
  return h;
}
 
TH1D* LmvmDrawAll::VaryBinWidth(const string& option, const string& hName, vector<pair<double, double>> binValues)
{
  TH1D* h = VaryBinWidth(option, hName, -1., binValues);
  return h;
}
 
TH1D* LmvmDrawAll::VaryBinWidth(TH1D* h, vector<pair<double, double>> binValues)  // pair(edge, bW)
{
  TH1D* hVar = VaryBinWidth(h, -1., binValues);
  return hVar;
}
 
TH1D* LmvmDrawAll::VaryBinWidth(const string& option, const string& hName, ELmvmAnaStep step, double nEvents,
                                vector<pair<double, double>> binValues)
{
  TH1D* h = VaryBinWidth(option, fHMean.GetName(hName, step), nEvents, binValues);
  return h;
}
 
TH1D* LmvmDrawAll::VaryBinWidth(const string& option, const string& hName, double nEvents,
                                vector<pair<double, double>> binValues)
{
  if (option != "mean" && option.find("cocktail_") == string::npos && option != "fastsim" && option != "evmix"
      && option != "inmed" && option != "omegaepem" && option != "omegadalitz" && option != "phi" && option != "qgp") {
    LOG(error) << "LmvmDrawAll::VaryBinWidth: No option " << option << " available!";
    return nullptr;
  }
 
  TH1D* h;
 
  if (option == "mean")
    h = fHMean.H1Clone(hName);
  else if (option == "fastsim")
    h = fHFastSim.H1Clone(hName);
  else if (option == "evmix")
    h = fHEvMix.H1Clone(hName);
  else if (option.find("cocktail_") != string::npos) {
    if (hName != "") LOG(info) << "LmvmDrawAll::VaryBinWidth: hName '" << hName << "' will be ignored.";
    ELmvmAnaStep step;
    vector<string> optsplit = Split(option, '_');
    string stepName         = optsplit[optsplit.size() - 1];
    if (stepName == fHMean.fAnaStepNames[0])
      step = ELmvmAnaStep::Mc;
    else if (stepName == fHMean.fAnaStepNames[1])
      step = ELmvmAnaStep::Reco;
    else if (stepName == fHMean.fAnaStepNames[2])
      step = ELmvmAnaStep::Acc;
    else if (stepName == fHMean.fAnaStepNames[3])
      step = ELmvmAnaStep::Chi2Prim;
    else if (stepName == fHMean.fAnaStepNames[4])
      step = ELmvmAnaStep::ElId;
    else if (stepName == fHMean.fAnaStepNames[5])
      step = ELmvmAnaStep::GammaCut;
    else if (stepName == fHMean.fAnaStepNames[6])
      step = ELmvmAnaStep::Mvd1Cut;
    else if (stepName == fHMean.fAnaStepNames[7])
      step = ELmvmAnaStep::Mvd2Cut;
    else if (stepName == fHMean.fAnaStepNames[8])
      step = ELmvmAnaStep::StCut;
    else if (stepName == fHMean.fAnaStepNames[9])
      step = ELmvmAnaStep::RtCut;
    else if (stepName == fHMean.fAnaStepNames[10])
      step = ELmvmAnaStep::TtCut;
    else if (stepName == fHMean.fAnaStepNames[11])
      step = ELmvmAnaStep::PtCut;
    else {
      LOG(error) << "LmvmDrawAll::VaryBinWidth: Step name '" << stepName
                 << "' not available in LmvmHist::fAnaStepNames!";
      return nullptr;
    }
    string hNameCoc;  // corrected this on 8.7.24
    if (option.find("_trueEl") != string::npos)
      hNameCoc = "hMinv_trueEl";
    else if (option.find("_urqmdAll") != string::npos)
      hNameCoc = "hMinv_urqmdAll";
    else if (option.find("_urqmdEl") != string::npos)
      hNameCoc = "hMinv_urqmdEl";
    else
      hNameCoc = "hMinv";
    h = GetCocktailMinvH1(hNameCoc, step, false);
  }
  else {
    ELmvmSignal signal = ELmvmSignal::Inmed;
    if (option == "omegaepem")
      signal = ELmvmSignal::Omega;
    else if (option == "omegadalitz")
      signal = ELmvmSignal::OmegaD;
    else if (option == "phi")
      signal = ELmvmSignal::Phi;
    else if (option == "qgp")
      signal = ELmvmSignal::Qgp;
    h = H(signal)->H1Clone(hName);
    h->Scale(1. / h->GetBinWidth(1));
  }
  TH1D* hVar = VaryBinWidth(h, nEvents, binValues);
  // TODO at this place: Scale Pluto histograms! Otherwise it has to be done by hand every time when called.
  h->Delete();
  return hVar;
}
 
TH1D* LmvmDrawAll::VaryBinWidth(TH1D* h, double nEvents, vector<pair<double, double>> binValues)  // pair(edge, bW)
{
  string hName = h->GetName();
 
  // Check if histogram is one-dimensional
  if (h->GetDimension() != 1) {
    LOG(error) << "LmvmDrawAll::VaryBinWidth: Histogram '" << hName << "' is not one dimensional!";
    return nullptr;
  }
  double bW0 = h->GetXaxis()->GetBinWidth(1);
 
  // Check if histogram has uniform bin width
  for (int iB = 2; iB <= h->GetNbinsX(); iB++) {
    if (h->GetBinWidth(iB) != bW0) {
      LOG(error) << "LmvmDrawAll::VaryBinWidth: name = " << hName << ": Bin width is not uniform!";
      return nullptr;
    }
  }
 
  // Check if values of 'binValues' are integer multiple of origin histogram
  for (size_t iV = 0; iV < binValues.size(); iV++) {
    if ((int) (1000 * binValues[iV].first) % (int) (1000 * bW0) != 0
        || (int) (1000 * binValues[iV].second) % (int) (1000 * bW0) != 0) {
      LOG(error) << "LmvmDrawAll::VaryBinWidth: name = " << hName
                 << ": At least one value of 'binValues' is not multiple integer of origin bin width!";
      return nullptr;
    }
    if (iV > 0) {
      if (((int) (1000 * binValues[iV].first) - (int) (1000 * binValues[iV - 1].first))
            % (int) (1000 * binValues[iV].second)
          != 0) {
        LOG(error) << "LmvmDrawAll::VaryBinWidth: name = " << hName
                   << ": Between at least two edges of different bin widths the bin width misfits its according range!";
        return nullptr;
      }
    }
  }
 
  // Create and fill vector for bin edges from binValues
  double xMin    = h->GetXaxis()->GetBinLowEdge(1);
  double xMax    = binValues[binValues.size() - 1].first;
  double xVal    = xMin;
  double xUpLast = xMin;  // upper edge of previous section
  int iBV        = 0;
  int n          = 1;
  vector<double> binEdges;
  binEdges.clear();
  binEdges.push_back(xVal);
  while (xVal <= xMax) {
    double bW = binValues[iBV].second;
    xVal      = xUpLast + n * bW;
    n++;
    binEdges.push_back(xVal);
    if (xVal >= xMax) break;
    if (IsCloseTo(xVal, binValues[iBV].first, bW / 1e6)) {
      iBV++;
      xUpLast = binValues[iBV - 1].first;
      n       = 1;
    }
  }
 
  // New histogram with new bin edges
  fBwVarCounter++;
  string hNameFull = hName + "_var" + Cbm::NumberToString(fBwVarCounter, 0);
  TH1D* hVar       = new TH1D(hNameFull.c_str(), hNameFull.c_str(), binEdges.size() - 1, binEdges.data());
  hVar->GetXaxis()->SetTitle(h->GetXaxis()->GetTitle());
  hVar->GetYaxis()->SetTitle(h->GetYaxis()->GetTitle());
 
  iBV        = 0;
  xVal       = xMin;
  int iBinH0 = 1;
  for (int iBinVar = 1; iBinVar <= hVar->GetNbinsX(); iBinVar++) {
    double bWNew = binValues[iBV].second;
    int f        = bWNew / bW0;
    double con   = 0.;
    double lim   = iBinH0 + f - 1;
    double N     = 0.;
 
    for (int iB0 = iBinH0; iB0 <= lim; iB0++) {
      con += h->GetBinContent(iB0) / f;
      xVal += bW0;
      iBinH0++;
      if (nEvents > 0) N += h->GetBinContent(iB0) * bW0 * nEvents;
      if (xVal >= binValues[iBV].first) iBV++;
    }
    double error = std::sqrt(N) / (bWNew * nEvents);
    hVar->SetBinContent(iBinVar, con);
    if (nEvents > 0) hVar->SetBinError(iBinVar, error);
  }
 
  // Insert error for cocktail (necessary for temperature plots)
  /*if (hName.find("hMinv_signal_") != string::npos && hName.find("_cocktail") != string::npos) {
    for (int iB = 1; iB <= hVar->GetNbinsX(); iB++) {
      double bW = hVar->GetBinWidth(iB);
      double c = hVar->GetBinContent(iB);
      double N = c * (fNofFastSimEvents/5.) * bW; // 5: number of signals
      double e = std::sqrt(N)/(fNofFastSimEvents/5.);
      hVar->SetBinError(iB, e);
    }
  }*/
  return hVar;
}
 
bool LmvmDrawAll::IsCloseTo(double value, double refValue, double tol)
{
  return (value >= refValue - tol && value <= refValue + tol);
}
 
void LmvmDrawAll::CheckVaryBinWidth()
{
  string cName                           = "CheckVaryBinWidth/";
  vector<pair<double, double>> binValues = {make_pair(0.8, 0.05), make_pair(1.5, 0.1), make_pair(2.5, 0.5)};
  ELmvmAnaStep step                      = ELmvmAnaStep::ElId;
 
  // Single contributions
  {
    TH1D* bg     = fHMean.H1Clone("hCbBg", ELmvmAnaStep::ElId);
    TH1D* bg2    = VaryBinWidth("mean", fHMean.GetName("hCbBg", ELmvmAnaStep::ElId), binValues);
    TH1D* inmed  = H(ELmvmSignal::Inmed)->H1Clone("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId);
    TH1D* inmed2 = VaryBinWidth("inmed", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), binValues);
 
    inmed->Scale(1. / H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries());
    inmed->Scale(1. / inmed->GetBinWidth(1));
    inmed2->Scale(1. / H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries());
 
    bg->GetYaxis()->SetRangeUser(1e-7, 2e-2);
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "single", cName + "single", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({bg, bg2}, {"CB_{calc}", "CB_{calc}2"}, kLinear, kLog, true, 0.8, 0.8, 0.95, 0.91, "pe");
    c->cd(2);
    DrawH1({inmed, inmed2}, {"inmed", "inmed2"}, kLinear, kLog, true, 0.8, 0.8, 0.95, 0.91, "pe");
  }
 
  // Minv spectra
  {
    TCanvas* c1 = fHMean.fHM.CreateCanvas(cName + "minv", cName + "minv", 1600, 800);
    c1->Divide(2, 1);
    c1->cd(1);
    TH1D* bgO       = fHMean.H1Clone("hMinv", ELmvmSrc::Bg, step);
    TH1D* pi0O      = fHMean.H1Clone("hMinv", ELmvmSrc::Pi0, step);
    TH1D* etaO      = fHMean.H1Clone("hMinv", ELmvmSrc::Eta, step);
    TH1D* gammaO    = fHMean.H1Clone("hMinv", ELmvmSrc::Gamma, step);
    TH1D* cocktailO = GetCocktailMinvH1("hMinv", step, false);
    TH1D* sbgO      = static_cast<TH1D*>(bgO->Clone());
    sbgO->Add(cocktailO);
    TH1D* cbO = nullptr;
    //TH1D* cbSame = nullptr;
    if (step == ELmvmAnaStep::ElId) {
      cbO = fHMean.H1Clone("hCbBg", step);
      //cbSame = fHMean.H1Clone("hCbBgSame", step);
    }
 
    double binWidth = bgO->GetBinWidth(1);
    vector<TH1D*> sHists(fHMean.fNofSignals);
    for (ELmvmSignal signal : fHMean.fSignals) {
      TH1D* sHist = H(signal)->H1Clone("hMinv", ELmvmSrc::Signal, step);
      sHist->Scale(1. / H(signal)->H1("hEventNumber")->GetEntries());
      sHist->Rebin(fRebinMinv);
      sHist->Scale(1. / binWidth);
      sHists[static_cast<int>(signal)] = sHist;
    }
 
    vector<LmvmDrawMinvData> drawData;
    if (step >= ELmvmAnaStep::Reco) {
      drawData.emplace_back(sbgO, kBlack, kBlack, 1, -1, "Cocktail+B_{MC}");
      drawData.emplace_back(bgO, kGray, kBlack, 1, -1, "B_{MC}");
    }
 
    drawData.emplace_back(pi0O, kGreen - 3, kGreen + 3, 2, -1, "#pi^{0} #rightarrow #gammae^{+}e^{-}");
    drawData.emplace_back(etaO, kRed - 4, kRed + 2, 2, -1, "#eta #rightarrow #gammae^{+}e^{-}");
    drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::OmegaD)], kCyan + 2, kCyan + 4, 2, -1,
                          "#omega #rightarrow #pi^{0}e^{+}e^{-}");
    drawData.emplace_back(gammaO, -1, kYellow, 4, -1, "#gamma #rightarrow e^{+}e^{-}");
    drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Omega)], kOrange + 7, kOrange + 4, 2, -1,
                          "#omega #rightarrow e^{+}e^{-}");
    drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Phi)], kAzure + 2, kAzure + 3, 2, -1,
                          "#phi #rightarrow e^{+}e^{-}");
    drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Qgp)], kOrange - 2, kOrange - 3, 4, 3112,
                          "QGP radiation");
    drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Inmed)], kMagenta - 3, kMagenta - 2, 4, 3018,
                          "in-medium #rho");
    drawData.emplace_back(cocktailO, -1, kRed + 2, 4, -1, "Cocktail");
    if (step >= ELmvmAnaStep::ElId) {
      drawData.emplace_back(cbO, -1, kCyan + 1, 4, -1, "CB_{calc}");
      //drawData.emplace_back(cbSame, -1, kCyan, 4, -1, "B_{calc} (same only)");
    }
 
    TH1D* h0     = nullptr;
    TLegend* leg = new TLegend(0.72, 0.55, 0.97, 0.99);
    for (size_t i = 0; i < drawData.size(); i++) {
      const auto& d = drawData[i];
      d.fH->GetYaxis()->SetLabelSize(0.04);
      if (step >= ELmvmAnaStep::ElId)
        d.fH->GetYaxis()->SetRangeUser(5e-10, 5e-2);
      else
        d.fH->GetYaxis()->SetRangeUser(5e-10, 1e2);
      if (d.fFillColor != -1) d.fH->SetFillColor(d.fFillColor);
      if (d.fFillStyle != -1) d.fH->SetFillStyle(d.fFillStyle);
      leg->AddEntry(d.fH, d.fLegend.c_str(), "f");
      DrawH1(d.fH, kLinear, kLog, (h0 == nullptr) ? "hist" : "hist,same", d.fLineColor, d.fLineWidth, 0);
      if (h0 == nullptr) h0 = d.fH;
    }
    fHMean.DrawAnaStepOnPad(step);
 
    leg->SetFillColor(kWhite);
    leg->Draw();
    gPad->SetLogy(true);
 
    c1->cd(2);
    DrawMinv(step);
    fHMean.DrawAnaStepOnPad(step);
  }
 
  // Signal
  {
    TH1D* bre = fHFastSim.H1Clone("hfsc_MinvBg_elid");
    TH1D* cbc = fHMean.H1Clone("hCbBg_elid");
    TH1D* coc = GetCocktailMinvH1("hMinv", step, false);
    TH1D* sig = (TH1D*) bre->Clone();
    sig->Add(coc);
    sig->Add(cbc, -1.);
    TH1D* sig2  = (TH1D*) sig->Clone();
    TH1D* sig5  = (TH1D*) sig->Clone();
    TH1D* sig10 = (TH1D*) sig->Clone();
    TH1D* sig25 = (TH1D*) sig->Clone();
    sig2->Rebin(2);
    sig5->Rebin(5);
    sig10->Rebin(10);
    sig25->Rebin(25);
    sig2->Scale(1. / 2.);
    sig5->Scale(1. / 5.);
    sig10->Scale(1. / 10.);
    sig25->Scale(1. / 25.);
    fHMean.fHM.CreateCanvas(cName + "Signal", cName + "Signal", 800, 800);
    DrawH1({coc, sig2, sig5, sig10, sig25}, {"Cocktail", "Signal2", "Signal5", "Signal10", "Signal25"}, kLinear, kLog,
           true, 0.7, 0.8, 0.95, 0.91, "hist");
  }
 
  // Ratios of Background Pair PDGs
  {
    vector<double> v_pm, v_pp, v_mm, v_pm_el, v_pp_el, v_mm_el;  // for charge symmetries
    for (const string comb : {"PM", "PP", "MM"}) {
      for (int iMinv = 0; iMinv <= 24; iMinv++) {
        string hName = "hBgPairPdg" + comb + "_pMc_" + Cbm::NumberToString(iMinv, 0);
        TH2D* h      = fHMean.H2Clone(hName);
        double I     = h->Integral(1, h->GetNbinsX(), 1, h->GetNbinsX());
        double ITrue = h->Integral(1, 4, 1, 4);
        if (comb == "PM") {
          v_pm.push_back(I);
          v_pm_el.push_back(ITrue);
        }
        else if (comb == "PP") {
          v_pp.push_back(I);
          v_pp_el.push_back(ITrue);
        }
        else if (comb == "MM") {
          v_mm.push_back(I);
          v_mm_el.push_back(ITrue);
        }
      }
    }
    // Histograms for charge symmetries
    TH1D* hSymm_ppmm = new TH1D("hSymm_ppmm-vb", "hSymm_ppmm-vb; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
    TH1D* hSymm_pppm = new TH1D("hSymm_pppm-vb", "hSymm_pppm-vb; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
    TH1D* hSymm_mmpm = new TH1D("hSymm_mmpm-vb", "hSymm_mmpm-vb; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
    for (int iB = 1; iB <= hSymm_ppmm->GetNbinsX(); iB++) {
      double ppmm = v_pp[iB - 1] / v_mm[iB - 1];
      double pppm = v_pp[iB - 1] / v_pm[iB - 1];
      double mmpm = v_mm[iB - 1] / v_pm[iB - 1];
      hSymm_ppmm->SetBinContent(iB, ppmm);
      hSymm_pppm->SetBinContent(iB, pppm);
      hSymm_mmpm->SetBinContent(iB, mmpm);
    }
    TH1D* hSymm_ppmm5 = (TH1D*) hSymm_ppmm->Clone();
    TH1D* hSymm_pppm5 = (TH1D*) hSymm_pppm->Clone();
    TH1D* hSymm_mmpm5 = (TH1D*) hSymm_mmpm->Clone();
    hSymm_ppmm5->Rebin(5);
    hSymm_pppm5->Rebin(5);
    hSymm_mmpm5->Rebin(5);
    hSymm_ppmm5->Scale(1. / 5.);
    hSymm_pppm5->Scale(1. / 5.);
    hSymm_mmpm5->Scale(1. / 5.);
    vector<pair<double, double>> varbin5 = {make_pair(2.5, 0.5)};
    TH1D* hSymm_ppmmVReg                 = VaryBinWidth(hSymm_ppmm, fBwVarReg);
    TH1D* hSymm_pppmVReg                 = VaryBinWidth(hSymm_pppm, fBwVarReg);
    TH1D* hSymm_mmpmVReg                 = VaryBinWidth(hSymm_mmpm, fBwVarReg);
    TH1D* hSymm_ppmmVBg3                 = VaryBinWidth(hSymm_ppmm, varbin5);
    TH1D* hSymm_pppmVBg3                 = VaryBinWidth(hSymm_pppm, varbin5);
    TH1D* hSymm_mmpmVBg3                 = VaryBinWidth(hSymm_mmpm, varbin5);
    TH1D* hSymm_ppmmVBg4                 = VaryBinWidth(hSymm_ppmm, fBwVarBg4);
    TH1D* hSymm_pppmVBg4                 = VaryBinWidth(hSymm_pppm, fBwVarBg4);
    TH1D* hSymm_mmpmVBg4                 = VaryBinWidth(hSymm_mmpm, fBwVarBg4);
    TH1D* hSymm_ppmmVBg5                 = VaryBinWidth(hSymm_ppmm, fBwVarBg5);
    TH1D* hSymm_pppmVBg5                 = VaryBinWidth(hSymm_pppm, fBwVarBg5);
    TH1D* hSymm_mmpmVBg5                 = VaryBinWidth(hSymm_mmpm, fBwVarBg5);
 
    double ymax = 3.;
    hSymm_ppmm->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_pppm->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_mmpm->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_ppmm5->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_pppm5->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_mmpm5->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_ppmmVReg->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_pppmVReg->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_mmpmVReg->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_ppmmVBg3->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_pppmVBg3->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_mmpmVBg3->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_ppmmVBg4->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_pppmVBg4->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_mmpmVBg4->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_ppmmVBg5->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_pppmVBg5->GetYaxis()->SetRangeUser(0., ymax);
    hSymm_mmpmVBg5->GetYaxis()->SetRangeUser(0., ymax);
 
    string cNameSymm = cName + "ChargeSymmetries";
    double x1        = 0.2;
    double x2        = 0.38;
    double y1        = 0.6;
    double y2        = 0.85;
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameSymm, cNameSymm, 2400, 1600);
    c->Divide(3, 2);
    c->cd(1);
    DrawH1({hSymm_ppmm, hSymm_pppm, hSymm_mmpm}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, x1, y1, x2, y2,
           "hist");
    DrawTextOnPad("Original", 0.1, 0.9, 0.8, 0.99);
    c->cd(2);
    DrawH1({hSymm_ppmm5, hSymm_pppm5, hSymm_mmpm5}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, x1, y1, x2, y2,
           "hist");
    DrawTextOnPad("Rebin 5", 0.1, 0.9, 0.8, 0.99);
    c->cd(3);
    DrawH1({hSymm_ppmmVReg, hSymm_pppmVReg, hSymm_mmpmVReg}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, x1,
           y1, x2, y2, "hist");
    DrawTextOnPad("Varbin Regular", 0.1, 0.9, 0.8, 0.99);
    c->cd(4);
    DrawH1({hSymm_ppmmVBg3, hSymm_pppmVBg3, hSymm_mmpmVBg3}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, x1,
           y1, x2, y2, "hist");
    DrawTextOnPad("Varbin5", 0.1, 0.9, 0.8, 0.99);
    c->cd(5);
    DrawH1({hSymm_ppmmVBg4, hSymm_pppmVBg4, hSymm_mmpmVBg4}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, x1,
           y1, x2, y2, "hist");
    DrawTextOnPad("Varbin Bg4", 0.1, 0.9, 0.8, 0.99);
    c->cd(6);
    DrawH1({hSymm_ppmmVBg5, hSymm_pppmVBg5, hSymm_mmpmVBg5}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, x1,
           y1, x2, y2, "hist");
    DrawTextOnPad("Varbin Bg5", 0.1, 0.9, 0.8, 0.99);
  }
}
 
void LmvmDrawAll::DrawEfficiencyCorrection()
{
  TH1D* mcReg   = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(ELmvmAnaStep::Mc)], "", fBwVarReg);
  TH1D* elidReg = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(ELmvmAnaStep::ElId)], "", fBwVarReg);
  TH1D* mcSig   = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(ELmvmAnaStep::Mc)], "", fBwVarSig);
  TH1D* elidSig = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(ELmvmAnaStep::ElId)], "", fBwVarSig);
  TH1D* rat     = (TH1D*) elidReg->Clone();
  rat->Divide(mcReg);
  //TH1D* rat = CalculateHistRatioWithErrors(elidReg, mcReg, fNofFastSimEvents, fNofFastSimEvents);
  mcReg->GetYaxis()->SetRangeUser(1e-10, 50);
  rat->GetYaxis()->SetTitle("Ratio");
  CalculateHistErrors(mcReg, fNofFastSimEvents);
  CalculateHistErrors(mcSig, fNofFastSimEvents);
  CalculateHistErrors(elidReg, fNofFastSimEvents);
  CalculateHistErrors(elidSig, fNofFastSimEvents);
  TCanvas* c = fHMean.fHM.CreateCanvas("EfficiencyCorrection/ec", "EfficiencyCorrection/ec", 2100, 2400);
  c->Divide(2, 3);
  c->cd(1);
  DrawH1({mcReg, elidReg}, {"MC", "Elid"}, kLinear, kLog, true, 0.8, 0.8, 0.95, 0.95, "p");
  DrawTextOnPad("Cocktail", 0.33, 0.9, 0.67, 0.99);
  c->cd(2);
  DrawH1(rat, kLinear, kLinear, "pe");
  c->cd(3);
  DrawTemperatureGraph(mcReg, ELmvmAnaStep::Mc, 1.12, 2.5);
  DrawTextOnPad("Temperature for MC", 0.25, 0.9, 0.65, 0.99);
  c->cd(4);
  DrawTemperatureGraph(elidReg, ELmvmAnaStep::ElId, 1.12, 2.5);
  DrawTextOnPad("Temperature for Elid", 0.24, 0.9, 0.66, 0.99);
  c->cd(5);
  DrawTemperatureGraph(mcSig, ELmvmAnaStep::Mc, 1.12, 2.5);
  DrawTextOnPad("Temperature for MC", 0.25, 0.9, 0.65, 0.99);
  c->cd(6);
  DrawTemperatureGraph(elidSig, ELmvmAnaStep::ElId, 1.12, 2.5);
  DrawTextOnPad("Temperature for Elid", 0.24, 0.9, 0.66, 0.99);
}
 
void LmvmDrawAll::DrawLikeSignCorrelations()
{
  vector<string> xLabel = {"#pi^{0} #rightarrow #gamma #gamma",
                           "#pi^{0} #rightarrow #gamma e^{+}e^{-}",
                           "#eta #rightarrow #gamma e^{+}e^{-}",
                           "#Chi #rightarrow ee...",
                           "#Chi #rightarrow xee",
                           "#Chi #rightarrow xx"};
  for (auto step : fHMean.fAnaSteps) {
    TH1D* h = fHMean.H1Clone("hLikeSignCorr", step);
    for (size_t iL = 0; iL < xLabel.size(); iL++) {
      h->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
    }
    string cName = "LikeSignCorrelations/LikeSignCorr_" + fHMean.fAnaStepNames[static_cast<int>(step)];
    fHMean.fHM.CreateCanvas(cName, cName, 1100, 800);
    DrawH1(h, kLinear, kLog, "hist");
  }
}
 
TH1D* LmvmDrawAll::GetSymmetry(TH1D* h)
{
  string hName = h->GetName();
  int nBinsX   = h->GetNbinsX();
  string title = (hName + "_symmetry" + "; " + h->GetXaxis()->GetTitle() + "; " + h->GetYaxis()->GetTitle()).c_str();
  TH1D* s;
  if (nBinsX % 2 == 0) {
    s = new TH1D((hName + "_symmetry").c_str(), title.c_str(), nBinsX / 2, h->GetMinimumBin(), h->GetMaximumBin());
    int binPartner = nBinsX - 1;
    for (int iB = 1; iB <= nBinsX / 2; iB++) {
      double r = (h->GetBinContent(iB) == 0) ? 0 : h->GetBinContent(iB + binPartner) / h->GetBinContent(iB);
      s->SetBinContent(nBinsX / 2 - iB + 1, r);
      binPartner -= 2;
    }
  }
  else {
    double bW = h->GetXaxis()->GetBinWidth(1);
    vector<double> binEdges((nBinsX + 1) / 2, 0.);
    for (int iB = 1; iB <= ((nBinsX + 1) / 2) + 1; iB++) {
      binEdges[iB] = (iB == 1) ? binEdges[iB - 1] + bW / 2. : binEdges[iB - 1] + bW;
    }
    s              = new TH1D((hName + "_symmetry").c_str(), title.c_str(), (nBinsX + 1) / 2, binEdges.data());
    int binPartner = nBinsX - 1;
    for (int iB = 1; iB <= (nBinsX + 1) / 2; iB++) {
      double r = (h->GetBinContent(iB) == 0) ? 0 : h->GetBinContent(iB + binPartner) / h->GetBinContent(iB);
      s->SetBinContent((nBinsX + 1) / 2 - iB + 1, r);
      binPartner -= 2;
    }
  }
  return s;
}
 
TH1D* LmvmDrawAll::GetSymmetry(TH1D* h1, string opt1, TH1D* h2, string opt2, const string& label)
{
  if ((opt1 != "+" && opt1 != "-") || (opt2 != "+" && opt2 != "-"))
    LOG(error) << "LmvmDrawAll::GetSymmetry(): At least one of the chosen options is not valid!";
  if (h1->GetNbinsX() != h2->GetNbinsX())
    LOG(error) << "LmvmDrawAll::GetSymmetry(): Number of bins of h1 and h2 are not equal!";
  if (h1 == h2 && opt1 == opt2) LOG(warning) << "LmvmDrawAll::GetSymmetry(): You chose the selfsame histogram parts!";
  TH1D* hH1 = GetHalfHisto(h1, opt1, label);
  TH1D* hH2 = GetHalfHisto(h2, opt2, label);
  TH1D* s   = (TH1D*) hH1->Clone();
  s->Divide(hH2);
  return s;
}
 
TH1D* LmvmDrawAll::GetHalfHisto(TH1D* h, string opt, const string& label)
{
  string hName     = h->GetName();
  string hNameFull = hName + "_half" + opt + "_" + label;
  int nBinsX       = h->GetNbinsX();
  double bW        = h->GetXaxis()->GetBinWidth(1);
  string title =
    hName + "_half" + opt + "_" + label + "; " + h->GetXaxis()->GetTitle() + "; " + h->GetYaxis()->GetTitle();
  TH1D* h2;
  if (nBinsX % 2 == 0) {  // Histograms with even number of bins
    vector<double> binEdges(nBinsX / 2 + 1, 0.);
    for (int iB = 1; iB <= nBinsX / 2; iB++) {
      binEdges[iB] = binEdges[iB - 1] + bW;
    }
    h2 = new TH1D(hNameFull.c_str(), title.c_str(), nBinsX / 2, binEdges.data());
    if (opt == "+") {  // get right half
      for (int iB = 1; iB <= nBinsX / 2; iB++) {
        h2->SetBinContent(iB, h->GetBinContent(nBinsX / 2 + iB));
      }
    }
    else {  // get left half
      for (int iB = 1; iB <= nBinsX / 2; iB++) {
        h2->SetBinContent(iB, h->GetBinContent(nBinsX / 2 + 1 - iB));
      }
    }
  }
  else {  // Histograms with odd number of bins
    vector<double> binEdges((nBinsX + 1) / 2 + 1, 0.);
    for (int iB = 1; iB <= (nBinsX + 1) / 2; iB++) {
      binEdges[iB] = (iB == 1) ? binEdges[iB - 1] + bW / 2. : binEdges[iB - 1] + bW;
    }
    h2 = new TH1D(hNameFull.c_str(), title.c_str(), (nBinsX + 1) / 2, binEdges.data());
    if (opt == "+") {
      for (int iB = 1; iB <= (nBinsX + 1) / 2; iB++) {
        if (iB == 1)
          h2->SetBinContent(iB, h->GetBinContent((nBinsX - 1) / 2 + iB) / 2);
        else
          h2->SetBinContent(iB, h->GetBinContent((nBinsX - 1) / 2 + iB));
      }
    }
    else {
      for (int iB = 1; iB <= (nBinsX + 1) / 2; iB++) {
        if (iB == 1)
          h2->SetBinContent(iB, h->GetBinContent((nBinsX + 1) / 2 + 1 - iB) / 2);
        else
          h2->SetBinContent(iB, h->GetBinContent((nBinsX + 1) / 2 + 1 - iB));
      }
    }
  }
  return h2;
}
 
void LmvmDrawAll::DrawMultiplicities(TH1D* plus, TH1D* minus, TH1D* plusrandom, TH1D* minusrandom, string cName,
                                     string hText)
{
  int nBinsMult = fHFastSim.H1("hfsp_mult_urqmd_gammaEl_plus_elid")->GetNbinsX();
  vector<string> xLabel;
  for (int iB = 0; iB < nBinsMult; iB++) {
    xLabel.push_back(Cbm::NumberToString(iB, 0));
  }
  TH1D* hRatP = (TH1D*) plus->Clone();
  TH1D* hRatM = (TH1D*) minus->Clone();
  hRatP->Divide(plusrandom);
  hRatM->Divide(minusrandom);
  plus->GetYaxis()->SetRangeUser(1e-8, 1);
  plusrandom->GetYaxis()->SetRangeUser(1e-7, 1);
  //hRatP->GetYaxis()->SetRangeUser(0.8, 5.5);
  hRatP->GetYaxis()->SetTitle("Ratio true/random");
  for (size_t iL = 0; iL < xLabel.size(); iL++) {
    plus->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
    hRatP->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
  }
  double IP     = plus->Integral(1, nBinsMult);
  double IM     = minus->Integral(1, nBinsMult);
  double IPrndm = plusrandom->Integral(1, nBinsMult);
  double IMrndm = minusrandom->Integral(1, nBinsMult);
  minus->Scale(0.1);
  minusrandom->Scale(0.1);
  TCanvas* c = fHMean.fHM.CreateCanvas(cName, cName, 1700, 800);
  c->Divide(2, 1);
  c->cd(1);
  DrawH1({plus, plusrandom, minus, minusrandom},
         {"e^{+}_{true}", "e^{+}_{random}", "e^{-}_{true} #upoint 0.1", "e^{-}_{random} #upoint 0.1"}, kLinear, kLog,
         true, 0.63, 0.62, 0.88, 0.87, "hist");
  DrawTextOnPad(hText, 0.2, 0.9, 0.8, 0.99);
  DrawTextOnPad("I_{+, true} = " + Cbm::NumberToString(IP, 2), 0.13, 0.31, 0.38, 0.36);
  DrawTextOnPad("I_{-, true} = " + Cbm::NumberToString(IM, 2), 0.13, 0.26, 0.38, 0.31);
  DrawTextOnPad("I_{+, rndm} = " + Cbm::NumberToString(IPrndm, 2), 0.13, 0.21, 0.38, 0.26);
  DrawTextOnPad("I_{-, rndm} = " + Cbm::NumberToString(IMrndm, 2), 0.13, 0.16, 0.38, 0.21);
  c->cd(2);
  DrawH1({hRatP, hRatM}, {"Ratio e+", "Ratio e-"}, kLinear, kLinear, true, 0.67, 0.74, 0.88, 0.87, "hist");
  DrawTextOnPad(hText, 0.2, 0.9, 0.8, 0.99);
}
 
void LmvmDrawAll::DrawFastSimHistosParticleBased()  // TODO: merge with 'DrawFastSimHistos()'
{
  // Prepare drawing
  string cName   = "FastSimParticleBased/";
  string nEvStr  = fNofFastSimEvents >= 1e9 ? Cbm::NumberToString(fNofFastSimEvents / 1e9, 1)
                                            : Cbm::NumberToString(fNofFastSimEvents / 1e6, 2);
  string nEvText = "NofFastSimEvents = " + nEvStr + (fNofFastSimEvents >= 1e9 ? "#times10^{9}" : "#times10^{6}");
 
  // Background: Charge-based vs. Particle-based
  {
    for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
      string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
      TH1D* cb        = VaryBinWidth("fastsim", "hfsc_MinvBg", step, fBwVarBg3);
      TH1D* pb        = VaryBinWidth("fastsim", "hfsp_MinvBg", step, fBwVarBg3);
      TH1D* r         = (TH1D*) pb->Clone();
      r->Divide(cb);
      r->GetYaxis()->SetTitle("Ratio");
      string cNameFull = cName + "Background/ParticleVsChargeBased_" + stepname;
      TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 1600, 800);
      c->Divide(2, 1);
      c->cd(1);
      DrawH1({pb, cb}, {"Particle-based", "Charge-Based"}, kLinear, kLog, true, 0.65, 0.7, 0.91, 0.91, "hist");
      DrawTextOnPad("Background", 0.2, 0.9, 0.8, 0.99);
      c->cd(2);
      DrawH1(r, kLinear, kLinear, "hist");
      DrawTextOnPad("Ratio Particle/Charge", 0.2, 0.9, 0.8, 0.99);
    }
  }
 
  // Multiplicity for UrQMD and Plutos
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    for (size_t iP = 0; iP < fHMean.fFSCandNames.size(); iP++) {
      string ptcl      = fHMean.fFSCandNames[iP];
      TH1D* hP         = fHFastSim.H1Clone("hfsp_mult_urqmd_" + ptcl + "_plus", step);
      TH1D* hM         = fHFastSim.H1Clone("hfsp_mult_urqmd_" + ptcl + "_minus", step);
      TH1D* hPrndm     = fHFastSim.H1Clone("hfsp_multRndm_urqmd_" + ptcl + "_plus", step);
      TH1D* hMrndm     = fHFastSim.H1Clone("hfsp_multRndm_urqmd_" + ptcl + "_minus", step);
      string text      = fHMean.fFSCandLatex[iP] + " (" + fHMean.fAnaStepLatex[static_cast<int>(step)] + ")";
      string cNameFull = cName + "Multiplicity/" + ptcl;
      DrawMultiplicities(hP, hM, hPrndm, hMrndm, cNameFull, text);
    }
    for (ELmvmSignal signal : fHMean.fSignals) {
      //int nofEventsSig = (int) fH[static_cast<int>(signal)]->H1("hEventNumber")->GetEntries();
      string sigName   = fHMean.fSignalNames[static_cast<int>(signal)];
      TH1D* hP         = fHFastSim.H1Clone("hfsc_mult_pluto_" + sigName + "_plus", step);
      TH1D* hM         = fHFastSim.H1Clone("hfsc_mult_pluto_" + sigName + "_minus", step);
      TH1D* hPrndm     = fHFastSim.H1Clone("hfsc_multRndm_pluto_" + sigName + "_plus", step);
      TH1D* hMrndm     = fHFastSim.H1Clone("hfsc_multRndm_pluto_" + sigName + "_minus", step);
      string text      = sigName + " (" + fHMean.fAnaStepLatex[static_cast<int>(step)] + ")";
      string cNameFull = cName + "Multiplicity/" + sigName + "_raw";
      DrawMultiplicities(hP, hM, hPrndm, hMrndm, cNameFull, text);
    }
    for (ELmvmSignal signal : fHMean.fSignals) {
      //int nofEventsSig = (int) fH[static_cast<int>(signal)]->H1("hEventNumber")->GetEntries();
      string sigName   = fHMean.fSignalNames[static_cast<int>(signal)];
      TH1D* hPcorr     = fHFastSim.H1Clone("hfsc_multCorr_pluto_" + sigName + "_plus", step);
      TH1D* hMcorr     = fHFastSim.H1Clone("hfsc_multCorr_pluto_" + sigName + "_minus", step);
      TH1D* hPrndm     = fHFastSim.H1Clone("hfsc_multRndm_pluto_" + sigName + "_plus", step);
      TH1D* hMrndm     = fHFastSim.H1Clone("hfsc_multRndm_pluto_" + sigName + "_minus", step);
      string text      = sigName + " (" + fHMean.fAnaStepLatex[static_cast<int>(step)] + ")";
      string cNameFull = cName + "Multiplicity/" + sigName + "_corr";
      DrawMultiplicities(hPcorr, hMcorr, hPrndm, hMrndm, cNameFull, text);
    }
  }
}
 
void LmvmDrawAll::DrawFastSimHistos()  // Charge-based
{
  /****************************************************************************************************************
* To be consistent, all histograms concerning Fast Simulations will be taken from fHFastSim, not from fHMean.   *
* In LmvmFastSim histograms are not scaled, except the minvBg histograms are scaled to bin width only.          *
* All histograms that are created and filled in LmvmFastSim are scaled by pattern here to 1/fNofFastSimEvents.  *
* Mind, that this does not include histograms that are created and filled in LmvmTask!                          *
* Until now, the Pluto histograms are scaled with factor fNofSignals "by hand" after scaling by pattern. This   *
* should be solved more elegant.                                                                                *
* The histograms that are created and filled in LmvmTask, but are taken from LmvmFastSim (fHFastSim),           *
* additionally have to be scaled to the number of FastSim jobs, since they are added via 'hadd'.                *
*                                                                                                               *
* Edit: Since using THnSparse histograms, these are scaled individually before drawing. Make this more elegant! *
*****************************************************************************************************************/
 
  // Prepare drawing
  string cName   = "FastSim/";
  string nEvStr  = fNofFastSimEvents >= 1e9 ? Cbm::NumberToString(fNofFastSimEvents / 1e9, 1)
                                            : Cbm::NumberToString(fNofFastSimEvents / 1e6, 2);
  string nEvText = "NofFastSimEvents = " + nEvStr + (fNofFastSimEvents >= 1e9 ? "#times10^{9}" : "#times10^{6}");
 
  int nBinsMult = fHFastSim.H1("hfsc_mult_urqmd_urqmd_plus_elid")->GetNbinsX();
  vector<string> xLabel;
  for (int iB = 0; iB < nBinsMult; iB++) {
    xLabel.push_back(Cbm::NumberToString(iB, 0));
  }
 
  // Draw
  for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
    string stepname  = fHMean.fAnaStepNames[static_cast<int>(step)];
    string stepLatex = fHMean.fAnaStepLatex[static_cast<int>(step)];
 
    // Multiplicities true vs. random (UrQMD)
    {
      TH1D* hP     = fHFastSim.H1Clone("hfsc_mult_urqmd_urqmd_plus", step);
      TH1D* hM     = fHFastSim.H1Clone("hfsc_mult_urqmd_urqmd_minus", step);
      TH1D* hPrndm = fHFastSim.H1Clone("hfsc_multRndm_urqmd_urqmd_plus", step);
      TH1D* hMrndm = fHFastSim.H1Clone("hfsc_multRndm_urqmd_urqmd_minus", step);
      TH1D* hRatP  = (TH1D*) hP->Clone();
      TH1D* hRatM  = (TH1D*) hM->Clone();
      hRatP->Divide(hPrndm);
      hRatM->Divide(hMrndm);
      hP->GetYaxis()->SetRangeUser(1e-8, 1);
      hP->GetYaxis()->SetTitle("Yield/Event");
      hPrndm->GetYaxis()->SetRangeUser(1e-8, 1);
      hRatP->GetYaxis()->SetRangeUser(0.5, 1.3);
      hRatP->GetYaxis()->SetTitle("Ratio true/random");
      for (size_t iL = 0; iL < xLabel.size(); iL++) {
        hP->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
        hPrndm->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
        hRatP->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
      }
      //double IP     = hP->Integral(1, nBinsMult);
      //double IM     = hM->Integral(1, nBinsMult);
      double IPrndm = hPrndm->Integral(1, nBinsMult);
      double IMrndm = hMrndm->Integral(1, nBinsMult);
      double nP     = 0.;
      double nM     = 0.;
      for (int iB = 2; iB <= hP->GetNbinsX(); iB++) {
        nP += hP->GetBinContent(iB) * (iB - 1) * fNofSimEvents;
        nM += hM->GetBinContent(iB) * (iB - 1) * fNofSimEvents;
      }
      if (step == ELmvmAnaStep::ElId) LOG(info) << "DrawFastSim: nP = " << nP << ", nM = " << nM;
      string cNameFull = cName + "Multiplicities/urqmd_" + stepname;
      TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 3200, 800);
      c->Divide(3, 1);
      c->cd(1);
      DrawH1({hP, hM}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.68, 0.91, 0.9, "hist");
      DrawTextOnPad("True Multiplicity", 0.2, 0.9, 0.8, 0.99);
      //DrawTextOnPad(nEvText, 0.5, 0.15, 0.9, 0.25);
      //DrawTextOnPad("I_{+} = " + Cbm::NumberToString(IP, 2), 0.17, 0.21, 0.37, 0.28);
      //DrawTextOnPad("I_{-} = " + Cbm::NumberToString(IM, 2), 0.17, 0.14, 0.37, 0.21);
      c->cd(2);
      DrawH1({hPrndm, hMrndm}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.68, 0.91, 0.9, "hist");
      DrawTextOnPad("Random Multiplicity", 0.2, 0.9, 0.8, 0.99);
      DrawTextOnPad(nEvText, 0.5, 0.15, 0.9, 0.25);
      DrawTextOnPad("I_{+} = " + Cbm::NumberToString(IPrndm, 2), 0.17, 0.21, 0.37, 0.28);
      DrawTextOnPad("I_{-} = " + Cbm::NumberToString(IMrndm, 2), 0.17, 0.14, 0.37, 0.21);
      c->cd(3);
      DrawH1({hRatP, hRatM}, {"e^{+}", "e^{-}"}, kLinear, kLinear, true, 0.8, 0.68, 0.91, 0.9, "hist");
      DrawTextOnPad("True vs. Random Multiplicity", 0.1, 0.9, 0.9, 0.99);
      DrawTextOnPad(nEvText, 0.5, 0.15, 0.9, 0.25);
    }
 
    // Multiplicities true vs. random (PLUTO)
    {
      for (ELmvmSignal signal : fHMean.fSignals) {
        string sigName = fHMean.fSignalNames[static_cast<int>(signal)];
        TH1D* hP       = fHFastSim.H1Clone("hfsc_multCorr_pluto_" + sigName + "_plus", step);
        TH1D* hM       = fHFastSim.H1Clone("hfsc_multCorr_pluto_" + sigName + "_minus", step);
        TH1D* hPrndm   = fHFastSim.H1Clone("hfsc_multRndm_pluto_" + sigName + "_plus", step);
        TH1D* hMrndm   = fHFastSim.H1Clone("hfsc_multRndm_pluto_" + sigName + "_minus", step);
        hPrndm->Scale(fHMean.fNofSignals / fNofFastSimEvents);
        hMrndm->Scale(fHMean.fNofSignals / fNofFastSimEvents);
        TH1D* hRatP = (TH1D*) hP->Clone();
        TH1D* hRatM = (TH1D*) hM->Clone();
        hRatP->Divide(hPrndm);
        hRatM->Divide(hMrndm);
        hP->GetYaxis()->SetRangeUser(1e-6, 1);
        hPrndm->GetYaxis()->SetRangeUser(1e-6, 1);
        hRatP->GetYaxis()->SetTitle("Ratio true/random");
        for (size_t iL = 0; iL < xLabel.size(); iL++) {
          hP->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
          hPrndm->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
          hRatP->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
        }
        string cNameFull = cName + "Multiplicities/" + sigName + "_" + stepname;
        TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 3500, 800);
        c->Divide(3, 1);
        c->cd(1);
        DrawH1({hP, hM}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.68, 0.91, 0.9, "hist");
        DrawTextOnPad("True Multiplicity", 0.2, 0.9, 0.8, 0.99);
        DrawTextOnPad(nEvText, 0.5, 0.15, 0.9, 0.25);
        c->cd(2);
        DrawH1({hPrndm, hMrndm}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.68, 0.91, 0.9, "hist");
        DrawTextOnPad("Random Multiplicity", 0.2, 0.9, 0.8, 0.99);
        DrawTextOnPad(nEvText, 0.5, 0.15, 0.9, 0.25);
        c->cd(3);
        DrawH1({hRatP, hRatM}, {"e^{+}", "e^{-}"}, kLinear, kLinear, true, 0.8, 0.68, 0.91, 0.9, "hist");
        DrawTextOnPad("True vs. Random Multiplicity", 0.1, 0.9, 0.9, 0.99);
        DrawTextOnPad(nEvText, 0.5, 0.15, 0.9, 0.25);
      }
    }
 
    // True Multiplicities all in one canvas
    {
      string cNameFull = cName + "Multiplicities/all_" + stepname;
      TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 3500, 1600);
      c->Divide(3, 2);
      int iC    = 1;
      TH1D* hPU = fHFastSim.H1Clone("hfsc_mult_urqmd_urqmd_plus", step);
      TH1D* hMU = fHFastSim.H1Clone("hfsc_mult_urqmd_urqmd_minus", step);
      for (size_t iL = 0; iL < xLabel.size(); iL++) {
        hPU->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
      }
      c->cd(iC++);
      DrawH1({hPU, hMU}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.68, 0.91, 0.9, "hist");
      DrawTextOnPad("True Multiplicity (UrQMD)", 0.17, 0.9, 0.83, 0.99);
      DrawTextOnPad(nEvText, 0.5, 0.15, 0.9, 0.25);
 
      for (ELmvmSignal signal : fHMean.fSignals) {
        string sigName = fHMean.fSignalNames[static_cast<int>(signal)];
        TH1D* hP       = fHFastSim.H1Clone("hfsc_multCorr_pluto_" + sigName + "_plus", step);
        TH1D* hM       = fHFastSim.H1Clone("hfsc_multCorr_pluto_" + sigName + "_minus", step);
        //hP->GetYaxis()->SetRangeUser(1e-15, 1);
        for (size_t iL = 0; iL < xLabel.size(); iL++) {
          hP->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
        }
        c->cd(iC++);
        DrawH1({hP, hM}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.68, 0.91, 0.9, "hist");
        DrawTextOnPad("True Multiplicity (" + sigName + ")", 0.17, 0.9, 0.83, 0.99);
      }
    }
 
    // Momentum (UrQMD)
    {
      // check size of THnSparse histograms
      static ProcInfo_t info;
      const float toMB = 1.f / 1024.f;
      gSystem->GetProcInfo(&info);
      double sizeRes1 = info.fMemResident * toMB;
      double sizeVir1 = info.fMemVirtual * toMB;
 
      THnSparseD* hPlusT  = (THnSparseD*) fHFastSim.fHM.GetObject("hfsc_mom_urqmd_urqmd_plus_" + stepname)->Clone();
      THnSparseD* hMinusT = (THnSparseD*) fHFastSim.fHM.GetObject("hfsc_mom_urqmd_urqmd_minus_" + stepname)->Clone();
      hPlusT->Scale(1. / (fNofSimEvents));
      hMinusT->Scale(1. / (fNofSimEvents));
 
      THnSparseD* hPlusR = (THnSparseD*) fHFastSim.fHM.GetObject("hfsc_momRndm_urqmd_urqmd_plus_" + stepname)->Clone();
      THnSparseD* hMinusR =
        (THnSparseD*) fHFastSim.fHM.GetObject("hfsc_momRndm_urqmd_urqmd_minus_" + stepname)->Clone();
      hPlusR->Scale(1. / fNofFastSimEvents);
      hMinusR->Scale(1. / fNofFastSimEvents);
 
      gSystem->GetProcInfo(&info);
      double sizeRes2 = info.fMemResident * toMB;
      double sizeVir2 = info.fMemVirtual * toMB;
      double sizeRes  = (sizeRes2 - sizeRes1) / 4.;
      double sizeVir  = (sizeVir2 - sizeVir1) / 4.;
      LOG(info) << "Size of one THnSparseD histogram: virtual: " << sizeVir << " MB, residential: " << sizeRes
                << " MB.";
 
      TH1D* hPlusXt  = (TH1D*) hPlusT->Projection(0, "");
      TH1D* hPlusYt  = (TH1D*) hPlusT->Projection(1, "");
      TH1D* hPlusZt  = (TH1D*) hPlusT->Projection(2, "");
      TH1D* hPlusXr  = (TH1D*) hPlusR->Projection(0, "");
      TH1D* hPlusYr  = (TH1D*) hPlusR->Projection(1, "");
      TH1D* hPlusZr  = (TH1D*) hPlusR->Projection(2, "");
      TH1D* hMinusXt = (TH1D*) hMinusT->Projection(0, "");
      TH1D* hMinusYt = (TH1D*) hMinusT->Projection(1, "");
      TH1D* hMinusZt = (TH1D*) hMinusT->Projection(2, "");
      TH1D* hMinusXr = (TH1D*) hMinusR->Projection(0, "");
      TH1D* hMinusYr = (TH1D*) hMinusR->Projection(1, "");
      TH1D* hMinusZr = (TH1D*) hMinusR->Projection(2, "");
      hPlusXt->Scale(1. / fNofFastSimJobs);
      hPlusYt->Scale(1. / fNofFastSimJobs);
      hPlusZt->Scale(1. / fNofFastSimJobs);
      hMinusXt->Scale(1. / fNofFastSimJobs);
      hMinusYt->Scale(1. / fNofFastSimJobs);
      hMinusZt->Scale(1. / fNofFastSimJobs);
      hPlusXt->GetYaxis()->SetTitle("Yield / Bin");
      hPlusYt->GetYaxis()->SetTitle("Yield / Bin");
      hPlusZt->GetYaxis()->SetTitle("Yield / Bin");
      hMinusXt->GetYaxis()->SetTitle("Yield / Bin");
      hMinusYt->GetYaxis()->SetTitle("Yield / Bin");
      hMinusZt->GetYaxis()->SetTitle("Yield / Bin");
      double min = 1e-7;
      double max = 3e-4;
      hPlusXt->GetYaxis()->SetRangeUser(min, max);
      hPlusYt->GetYaxis()->SetRangeUser(min, max);
      hPlusZt->GetYaxis()->SetRangeUser(min, max);
      hMinusXt->GetYaxis()->SetRangeUser(min, max);
      hMinusYt->GetYaxis()->SetRangeUser(min, max);
      hMinusZt->GetYaxis()->SetRangeUser(min, max);
 
      string cNametrP = cName + "Momentum/TrueVsRndm_plus_" + stepname;
      TCanvas* cP     = fHMean.fHM.CreateCanvas(cNametrP, cNametrP, 2400, 800);
      cP->Divide(3, 1);
      cP->cd(1);
      DrawH1({hPlusXt, hPlusXr}, {"P_{x} true", "P_{x} random"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True vs. random Momentum (e^{+})", 0.17, 0.9, 0.83, 0.99);
      //DrawTextOnPad(nEvText, 0.1, 0.8, 0.5, 0.89);
      cP->cd(2);
      DrawH1({hPlusYt, hPlusYr}, {"P_{y} true", "P_{y} random"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True vs. random Momentum (e^{+})", 0.17, 0.9, 0.83, 0.99);
      DrawTextOnPad(nEvText, 0.1, 0.8, 0.5, 0.89);
      cP->cd(3);
      DrawH1({hPlusZt, hPlusZr}, {"P_{z} true", "P_{z} random"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True vs. random Momentum (e^{+})", 0.17, 0.9, 0.83, 0.99);
      DrawTextOnPad(nEvText, 0.2, 0.8, 0.6, 0.89);
 
      string cNametrM = cName + "Momentum/TrueVsRndm_minus_" + stepname;
      TCanvas* cM     = fHMean.fHM.CreateCanvas(cNametrM, cNametrM, 2400, 800);
      cM->Divide(3, 1);
      cM->cd(1);
      DrawH1({hMinusXt, hMinusXr}, {"P_{x} true", "P_{x} random"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True vs. random Momentum (e^{-})", 0.17, 0.9, 0.83, 0.99);
      DrawTextOnPad(nEvText, 0.1, 0.8, 0.5, 0.89);
      cM->cd(2);
      DrawH1({hMinusYt, hMinusYr}, {"P_{y} true", "P_{y} random"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True vs. random Momentum (e^{-})", 0.17, 0.9, 0.83, 0.99);
      DrawTextOnPad(nEvText, 0.1, 0.8, 0.5, 0.89);
      cM->cd(3);
      DrawH1({hMinusZt, hMinusZr}, {"P_{z} true", "P_{z} random"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True vs. random Momentum (e^{-})", 0.17, 0.9, 0.83, 0.99);
      DrawTextOnPad(nEvText, 0.2, 0.8, 0.6, 0.89);
 
      // To avoid same colors for different histograms, copy twice used histograms
      TH1D* hPlusXt2  = (TH1D*) hPlusXt->Clone();
      TH1D* hPlusYt2  = (TH1D*) hPlusYt->Clone();
      TH1D* hPlusZt2  = (TH1D*) hPlusZt->Clone();
      TH1D* hMinusXt2 = (TH1D*) hMinusXt->Clone();
      TH1D* hMinusYt2 = (TH1D*) hMinusYt->Clone();
      TH1D* hMinusZt2 = (TH1D*) hMinusZt->Clone();
      hPlusXt2->GetYaxis()->SetRangeUser(min, max);
      hPlusYt2->GetYaxis()->SetRangeUser(min, max);
      hPlusZt2->GetYaxis()->SetRangeUser(min, max);
      string cNamePm = cName + "Momentum/PlusVsMinus_" + stepname;
      TCanvas* cPm   = fHMean.fHM.CreateCanvas(cNamePm, cNamePm, 2400, 800);
      cPm->Divide(3, 1);
      cPm->cd(1);
      DrawH1({hPlusXt2, hMinusXt2}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True Momentum", 0.3, 0.9, 0.7, 0.99);
      //DrawTextOnPad(nEvText, 0.1, 0.8, 0.5, 0.89);
      cPm->cd(2);
      DrawH1({hPlusYt2, hMinusYt2}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True Momentum", 0.3, 0.9, 0.7, 0.99);
      DrawTextOnPad(nEvText, 0.1, 0.8, 0.5, 0.89);
      cPm->cd(3);
      DrawH1({hPlusZt2, hMinusZt2}, {"e^{+}", "e^{-}"}, kLinear, kLog, true, 0.8, 0.75, 0.91, 0.9, "hist");
      DrawTextOnPad("True Momentum", 0.3, 0.9, 0.7, 0.99);
      DrawTextOnPad(nEvText, 0.2, 0.8, 0.6, 0.89);
    }
  }  // steps
 
  // Background
  {
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Background/Background", cName + "Background/Background", 2400, 800);
    c->Divide(3, 1);
    int iC = 1;
    for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
      string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
      TH1D* bg        = VaryBinWidth("fastsim", "hfsc_MinvBg_" + stepname, fBwVarReg);
      bg->GetYaxis()->SetRangeUser(1e-9, 1e-2);
      c->cd(iC++);
      DrawH1(bg, kLinear, kLog, "hist");
      fHMean.DrawAnaStepOnPad(step);
    }
  }
 
  // Background: Vs. MC-BG
  for (const string cat : {""}) {  //, "_trueEl", "_urqmdAll", "_urqmdEl"}) {
    TCanvas* c =
      fHMean.fHM.CreateCanvas(cName + "Background/VsMcBg" + cat, cName + "Background/VsMcBg" + cat, 1600, 2400);
    c->Divide(2, 3);
    int iC = 1;
    for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
      string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
      TH1D* bfs       = VaryBinWidth("fastsim", "hfsc_MinvBg" + cat + "_" + stepname, fNofFastSimEvents, fBwVarSig);
      TH1D* bmc       = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat + "_bg", step), fNofSimEvents, fBwVarSig);
      bfs->GetYaxis()->SetRangeUser(1e-7, 2e-2);
      TH1D* r = (TH1D*) bfs->Clone();
      r->Divide(bmc);
      r->GetYaxis()->SetRangeUser(0.5, 1.4);
      r->GetYaxis()->SetTitle("Ratio");
      c->cd(iC++);
      DrawH1({bfs, bmc}, {"B_{FS}", "B_{MC}"}, kLinear, kLog, true, 0.65, 0.75, 0.95, 0.9, "p");
      fHMean.DrawAnaStepOnPad(step);
      c->cd(iC++);
      DrawH1({r}, {"B_{FS} / B_{MC}"}, kLinear, kLinear, true, 0.75, 0.87, 0.95, 0.95, "p");
      fHMean.DrawAnaStepOnPad(step);
    }
  }
 
  // Background vs CBcalc from Fast Simulation (CB_{calc, FS})
  /*{
    TH1D* fs = VaryBinWidth("fastsim", "hfsc_MinvBg_elid", fNofFastSimEvents, fBwVarBg);
    TH1D* cb = VaryBinWidth("mean", "hFsCb", fNofFastSimEvents, fBwVarBg);
    TH1D* r  = (TH1D*) fs->Clone();
    r->Divide(cb);
    r->GetYaxis()->SetTitle("Ratio");
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Background/FsCb", cName + "Background/FsCb", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({fs, cb}, {"B_{FS}", "CB_{calc, FS}"},  kLinear, kLog, true, 0.7, 0.82, 0.92, 0.92, "hist");
    c->cd(2);
    DrawH1(r, kLinear, kLinear, "hist");
  }*/
 
  // Background: Smoothing effect of large number of FastSim procedure
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TCanvas* c =
      fHMean.fHM.CreateCanvas(cName + "Background/SmoothEffect", cName + "Background/SmoothEffect", 2400, 1600);
    c->Divide(3, 2);
    vector<int> canvas = {1, 4, 2, 5, 3, 6};
    int iC             = 0;
    for (const string cat : {""}) {  // , "_urqmdAll", "_urqmdEl"}) {
      TH1D* mc  = fHMean.H1Clone("hMinv" + cat + "_bg", step);
      TH1D* fs  = fHFastSim.H1Clone("hfsc_MinvBg" + cat, step);
      TH1D* cb  = fHMean.H1Clone("hCbBg" + cat, step);
      TH1D* rat = (TH1D*) cb->Clone();
      rat->Divide(fs);
      TH1D* rat2 = VaryBinWidth(rat, fBwVarReg);
      rat2->GetYaxis()->SetRangeUser(0.97, 1.1);
      rat2->GetYaxis()->SetTitle("CB_{calc} / B_{FS}");
      mc->GetXaxis()->SetTitle("M_{ee} [GeV/c^{2}]");
      mc->GetYaxis()->SetRangeUser(1e-9, 1e-2);
      string label = (cat == "") ? "PLUTO + UrQMD" : (cat == "_urqmdAll") ? "UrQMD" : "UrQMD electrons";
      c->cd(canvas[iC]);
      iC++;
      DrawH1({mc, fs, cb}, {"MC Background", "Fast Sim. Background", "CB_{calc}"}, kLinear, kLog, true, 0.52, 0.7, 0.91,
             0.9, "hist");
      DrawH1({mc, fs}, {"MC Background", "Fast Sim. Background"}, kLinear, kLog, true, 0.52, 0.77, 0.91, 0.9, "hist");
      DrawTextOnPad(label, 0.25, 0.9, 0.8, 0.99);
      fHMean.DrawSimDataLabel(0.14, 1.02e-8, 0.033);
      c->cd(canvas[iC]);
      iC++;
      DrawH1(rat2, kLinear, kLinear, "hist");
      DrawTextOnPad(label, 0.25, 0.9, 0.8, 0.99);
    }
  }
 
  // Signal: B_{FS} + Cocktail - CB_{calc} vs. Cocktail
  {
    for (const string cat : {""}) {  //}, "_trueEl", "_urqmdAll", "_urqmdEl"}) {
      string cNameFull = cName + "Signal/signal" + cat;
      TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 2400, 800);
      c->Divide(3, 1);
      int iC = 1;
      for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
        TH1D* sig = VaryBinWidth("fastsim", "hfsc_MinvBg" + cat, step, fNofFastSimEvents, fBwVarSig3);
        TH1D* cbc = VaryBinWidth("mean", fHMean.GetName("hCbBg" + cat, step),
                                 fNofSimEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarSig3);
        TH1D* coc = VaryBinWidth("cocktail" + cat + "_" + fHMean.fAnaStepNames[static_cast<int>(step)], "",
                                 fNofFastSimEvents, fBwVarSig3);
        sig->Add(coc);
        sig->Add(cbc, -1.);
        sig->GetYaxis()->SetRangeUser(1e-9, 3e-2);
        c->cd(iC++);
        DrawH1({sig, coc}, {"Signal = B_{FS} + Cocktail - CB_{calc}", "Cocktail"}, kLinear, kLog, true, 0.47, 0.77,
               0.91, 0.9, "pe");
        fHMean.DrawAnaStepOnPad(step);
        fHMean.DrawSimDataLabel(.08, 3e-9, 0.033);
      }
    }
  }
 
  // Signal from FastSim procedure only: B_{FS} + Cocktail - CB_{calc, FS} vs. Cocktail
  /*{
    vector<pair<double, double>> bwvar = fBwVarSig3;
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TH1D* sig  = VaryBinWidth("fastsim", "hfsc_MinvBg", step, fNofFastSimEvents, bwvar);
    TH1D* cbfs = VaryBinWidth("mean", "hFsCb", fNofFastSimEvents, bwvar);
    TH1D* coc  = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, bwvar);
    sig->Add(coc);
    sig->Add(cbfs, -1.);
    //sig->GetYaxis()->SetRangeUser(1e-9, 3e-2);
    string cNameFull = cName + "Signal/signal_RE";
    fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 800, 800);
    DrawH1({sig, coc}, {"Signal = B_{FS} + Cocktail - CB_{calc, FS}", "Cocktail"}, kLinear, kLinear, true, 0.45, 0.77, 0.91, 0.9, "pe");
    fHMean.DrawAnaStepOnPad(step);
  }*/
 
  // Reduced Signal (without known sources (pi0, eta, omega, phi)) vs. Cocktail
  {
    vector<pair<double, double>> bwvar = fBwVarSig3;
    for (const string cat : {""}) {  //, "_trueEl", "_urqmdAll", "_urqmdEl"}) {
      string cNameFull = cName + "Signal/Reduced/signal_reduced" + cat;
      string legSig    = "B_{FS} + Cocktail - CB_{calc} - #pi^{0} - #eta - #omega - #omega_{D} - #phi ";
      TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 3200, 800);
      c->Divide(4, 1);
      int iC = 1;
      for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
        string stepname   = fHMean.fAnaStepNames[static_cast<int>(step)];
        TH1D* sig         = VaryBinWidth("fastsim", "hfsc_MinvBg" + cat, step, bwvar);
        TH1D* fs          = VaryBinWidth("fastsim", "hfsc_MinvBg" + cat, step, bwvar);
        TH1D* cbc         = VaryBinWidth("mean", fHMean.GetName("hCbBg" + cat, step), bwvar);
        TH1D* pi0         = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat, ELmvmSrc::Pi0, step), bwvar);
        TH1D* eta         = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat, ELmvmSrc::Eta, step), bwvar);
        TH1D* gamma       = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat, ELmvmSrc::Gamma, step), bwvar);
        TH1D* inmed       = VaryBinWidth("inmed", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), bwvar);
        TH1D* omega       = VaryBinWidth("omegaepem", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), bwvar);
        TH1D* omegadalitz = VaryBinWidth("omegadalitz", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), bwvar);
        TH1D* phi         = VaryBinWidth("phi", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), bwvar);
        TH1D* qgp         = VaryBinWidth("qgp", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), bwvar);
        TH1D* coc = VaryBinWidth("cocktail" + cat + "_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", bwvar);
        inmed->Scale(1. / H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries());
        omega->Scale(1. / H(ELmvmSignal::Omega)->H1("hEventNumber")->GetEntries());
        omegadalitz->Scale(1. / H(ELmvmSignal::OmegaD)->H1("hEventNumber")->GetEntries());
        phi->Scale(1. / H(ELmvmSignal::Phi)->H1("hEventNumber")->GetEntries());
        qgp->Scale(1. / H(ELmvmSignal::Qgp)->H1("hEventNumber")->GetEntries());
        sig->Add(coc);
        sig->Add(cbc, -1.);
        sig->Add(pi0, -1.);
        sig->Add(eta, -1.);
        sig->Add(omega, -1.);
        sig->Add(omegadalitz, -1.);
        sig->Add(phi, -1.);
        TH1D* cocRed = (TH1D*) inmed->Clone();
        cocRed->Add(qgp);
        //CalculateHistErrors(cocRed, fNofFastSimEvents);
        //CalculateHistErrors(sig, fNofFastSimEvents);
        sig->GetYaxis()->SetRangeUser(1e-10, 5e-2);
        fs->GetYaxis()->SetRangeUser(1e-10, 5e-2);
        if (step == ELmvmAnaStep::ElId) {
          c->cd(iC++);
          DrawH1({fs, cbc, coc, omega, omegadalitz, phi, pi0, eta, gamma},
                 {"B_{FS}", "CB_{calc}", "Cocktail", "#omega", "#omega_{D}", "#phi", "#pi^{0}", "#eta", "#gamma"},
                 kLinear, kLog, true, 0.85, 0.55, 0.99, 0.9, "p");
        }
        c->cd(iC++);
        DrawH1({sig, cocRed}, {legSig, "#rho_{i.m.} + QGP"}, kLinear, kLog, true, 0.38, 0.77, 0.91, 0.9, "pe");
        DrawTextOnPad("Reduced Cocktail (" + stepname + ")", 0.1, 0.9, 0.9, 0.99);
        DrawTextOnPad(nEvText, 0.12, 0.15, 0.5, 0.25);
      }
    }
  }
 
  // Time per generated event
  {
    TH1D* h = fHFastSim.H1Clone("hfs_time");
    fHMean.fHM.CreateCanvas(cName + "Time", cName + "Time", 800, 800);
    DrawH1(h, kLinear, kLog, "hist");
    DrawTextOnPad("Time", 0.35, 0.9, 0.65, 0.99);
    h->Fit("gaus", "Q", "", 0., 35.);
    TF1* func   = h->GetFunction("gaus");
    double mean = (func != nullptr) ? func->GetParameter("Mean") : 0.;
    DrawTextOnPad("mean: " + Cbm::NumberToString(mean, 2) + " #mus/Event", 0.2, 0.65, 0.6, 0.89);
  }
 
  // Occupied memory
  {
    TH1D* hRes = fHFastSim.H1Clone("hfs_memory_res");
    TH1D* hVir = fHFastSim.H1Clone("hfs_memory_vir");
    fHMean.fHM.CreateCanvas(cName + "Memory", cName + "Memory", 800, 800);
    DrawH1({hRes, hVir}, {"residential", "virtual"}, kLinear, kLog, true, 0.8, 0.75, 0.91, 0.9, "hist");
  }
}
 
void LmvmDrawAll::DrawSignalCBNormRangeDependent(string hName, string cName, ELmvmAnaStep step)
{
  if (hName != "hfsp_MinvBg" && hName != "hfsc_MinvBg")
    LOG(error) << "DrawSignalCBNormRangeDependent: hName " << hName << " is not valid!";
  vector<double> Start = {0.40, 0.45, 0.50, 0.55, 0.60};
  vector<double> End   = {0.70, 0.80, 0.90, 1.00, 1.10, 1.20};
  TH1D* bre            = VaryBinWidth("fastsim", hName, step, fNofFastSimEvents, fBwVarSig);
  TH1D* coc =
    VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarSig);
  for (size_t iStart = 0; iStart < Start.size(); iStart++) {
    for (size_t iEnd = 0; iEnd < End.size(); iEnd++) {
      TH1D* cbcRaw = GetCBForNormRange("hmx_Minv", step, Start[iStart], End[iEnd]);
      TH1D* cbc    = VaryBinWidth(cbcRaw, fNofSimEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarSig);
      TH1D* sig    = (TH1D*) bre->Clone();
      sig->Add(coc);
      sig->Add(cbc, -1.);
      sig->GetYaxis()->SetRangeUser(1e-9, 5e-2);
      string sStart    = Cbm::NumberToString(Start[iStart], 2);
      string sEnd      = Cbm::NumberToString(End[iEnd], 2);
      string cNameFull = cName + "CbNormRangeDependent/" + hName + "/" + sStart + "_" + sEnd;
      fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 800, 800);
      DrawH1({sig, coc}, {"Signal = B_{FS} + Cocktail - CB_{calc}", "Cocktail"}, kLinear, kLog, true, 0.47, 0.77, 0.91,
             0.9, "pe");
      fHMean.DrawAnaStepOnPad(step);
    }
  }
}
 
TH1D* LmvmDrawAll::GetCBForNormRange(const string hName, ELmvmAnaStep step, double rangeStart, double rangeEnd)
{
  LmvmHist HM     = fHEvMix;
  TH1D* pmSame    = HM.H1Clone(hName + "PM_sameEv", step);
  TH1D* ppSame    = HM.H1Clone(hName + "PP_sameEv", step);
  TH1D* mmSame    = HM.H1Clone(hName + "MM_sameEv", step);
  TH1D* pmMixed   = HM.H1Clone(hName + "PM_mixedEv", step);
  TH1D* ppMixed   = HM.H1Clone(hName + "PP_mixedEv", step);
  TH1D* mmMixed   = HM.H1Clone(hName + "MM_mixedEv", step);
  TH1D* geomSame  = (TH1D*) pmSame->Clone();
  TH1D* geomMixed = (TH1D*) pmSame->Clone();
  TH1D* k         = (TH1D*) pmMixed->Clone();
  TH1D* cb        = (TH1D*) pmSame->Clone();
  geomSame->Reset();
  geomMixed->Reset();
  cb->Reset();
  for (int iB = 1; iB <= geomSame->GetNbinsX(); iB++) {
    double cppSame = ppSame->GetBinContent(iB);
    double cmmSame = mmSame->GetBinContent(iB);
    double cSame   = std::sqrt(cppSame * cmmSame);
    geomSame->SetBinContent(iB, cSame);
    double cppMix = ppMixed->GetBinContent(iB);
    double cmmMix = mmMixed->GetBinContent(iB);
    double cMix   = std::sqrt(cppMix * cmmMix);
    geomMixed->SetBinContent(iB, cMix);
  }
  k->Divide(geomMixed);
  k->Scale(1. / 2.);
  int ChangeBin       = pmSame->FindBin(fCbChange);
  int NormRangeMinBin = pmSame->FindBin(rangeStart);
  int NormRangeMaxBin = pmSame->FindBin(rangeEnd);
  double normPPInt =
    ppSame->Integral(NormRangeMinBin, NormRangeMaxBin) / ppMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
  double normMMInt =
    mmSame->Integral(NormRangeMinBin, NormRangeMaxBin) / mmMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
  for (int iB = 1; iB <= cb->GetNbinsX(); iB++) {
    double kval  = k->GetBinContent(iB);
    double pm    = pmMixed->GetBinContent(iB);
    double cbval = (iB < ChangeBin) ? 2. * kval * geomSame->GetBinContent(iB) : pm * std::sqrt(normPPInt * normMMInt);
    cb->SetBinContent(iB, cbval);
  }
 
  // Calculate error for CB
  double bW = cb->GetBinWidth(1);
  for (int iB = 1; iB <= cb->GetNbinsX(); iB++) {
    //s_ for same, m_ for mixed
    double s_pp = ppSame->GetBinContent(iB) * fNofSimEvents * bW;
    double s_mm = mmSame->GetBinContent(iB) * fNofSimEvents * bW;
    double m_pm = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
    double m_pp = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
    double m_mm = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
 
    // derivatives of CB_{calc} w.r. to according value
    double d_m_pm = std::sqrt(s_pp * s_mm / (m_pp * m_mm));
    double d_m_pp = -0.5 * m_pm * std::pow(m_mm, -1. / 2.) * std::pow(m_pp, -3. / 2.) * std::sqrt(s_pp * s_mm);
    double d_m_mm = -0.5 * m_pm * std::pow(m_mm, -3. / 2.) * std::pow(m_pp, -1. / 2.) * std::sqrt(s_pp * s_mm);
    double d_s_pp = 0.5 * m_pm * std::sqrt(s_mm) * std::pow(m_pp * m_mm * s_pp, -1. / 2.);
    double d_s_mm = 0.5 * m_pm * std::sqrt(s_pp) * std::pow(m_pp * m_mm * s_mm, -1. / 2.);
 
    // contributions to error propagation
    double f_m_pm = std::pow(d_m_pm * std::sqrt(m_pm), 2);
    double f_m_pp = std::pow(d_m_pp * std::sqrt(m_pp), 2);
    double f_m_mm = std::pow(d_m_mm * std::sqrt(m_mm), 2);
    double f_s_pp = std::pow(d_s_pp * std::sqrt(s_pp), 2);
    double f_s_mm = std::pow(d_s_mm * std::sqrt(s_mm), 2);
 
    // final error propagation values
    double errorBc  = std::sqrt(f_m_pm + f_m_pp + f_m_mm + f_s_pp + f_s_mm) / (fNofSimEvents * bW);
    double errorBc2 = std::sqrt(normPPInt * normMMInt) * std::sqrt(m_pm) / (fNofSimEvents * bW);  // for range > 0.4 GeV
    if (iB < ChangeBin) cb->SetBinError(iB, errorBc);
    if (iB >= ChangeBin) cb->SetBinError(iB, errorBc2);
  }
  return cb;
}
 
void LmvmDrawAll::CalculateCBFromFastSimEvents()  // TODO: get CB via 'GetCBForNormRange()'
{
  string hName      = "hfsc_Minv";
  ELmvmAnaStep step = ELmvmAnaStep::ElId;
  TH1D* pmSame      = fHFastSim.H1Clone(hName + "Bg", step);
  TH1D* ppSame      = fHFastSim.H1Clone(hName + "PP_sameEv", step);
  TH1D* mmSame      = fHFastSim.H1Clone(hName + "MM_sameEv", step);
  TH1D* pmMixed     = fHFastSim.H1Clone(hName + "PM_mixedEv", step);
  TH1D* ppMixed     = fHFastSim.H1Clone(hName + "PP_mixedEv", step);
  TH1D* mmMixed     = fHFastSim.H1Clone(hName + "MM_mixedEv", step);
  TH1D* geomSame    = (TH1D*) pmSame->Clone();
  TH1D* geomMixed   = (TH1D*) pmSame->Clone();
  TH1D* k           = (TH1D*) pmMixed->Clone();
  TH1D* cb          = (TH1D*) pmSame->Clone();
  geomSame->Reset();
  geomMixed->Reset();
  cb->Reset();
  k->GetYaxis()->SetTitle("#it{k} Factor");
  for (int iB = 1; iB <= geomSame->GetNbinsX(); iB++) {
    double cppSame = ppSame->GetBinContent(iB);
    double cmmSame = mmSame->GetBinContent(iB);
    double cSame   = std::sqrt(cppSame * cmmSame);
    geomSame->SetBinContent(iB, cSame);
    double cppMix = ppMixed->GetBinContent(iB);
    double cmmMix = mmMixed->GetBinContent(iB);
    double cMix   = std::sqrt(cppMix * cmmMix);
    geomMixed->SetBinContent(iB, cMix);
  }
  k->Divide(geomMixed);
  k->Scale(1. / 2.);
  int ChangeBin       = pmSame->FindBin(fCbChange);
  int NormRangeMinBin = pmSame->FindBin(fCbNormRangeMin);
  int NormRangeMaxBin = pmSame->FindBin(fCbNormRangeMax);
  double normPPInt =
    ppSame->Integral(NormRangeMinBin, NormRangeMaxBin) / ppMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
  double normMMInt =
    mmSame->Integral(NormRangeMinBin, NormRangeMaxBin) / mmMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
  for (int iB = 1; iB <= cb->GetNbinsX(); iB++) {
    double kval              = k->GetBinContent(iB);
    double geomMeanMixNormed = geomMixed->GetBinContent(iB) * std::sqrt(normPPInt * normMMInt);
    double cbval = (iB < ChangeBin) ? 2. * kval * geomSame->GetBinContent(iB) : 2. * kval * geomMeanMixNormed;
    cb->SetBinContent(iB, cbval);
  }
 
  // Calculate error for CB
  double bW = cb->GetBinWidth(1);
  for (int iB = 1; iB <= cb->GetNbinsX(); iB++) {
    //s_ for same, m_ for mixed
    double s_pp = ppSame->GetBinContent(iB) * fNofSimEvents * bW;
    double s_mm = mmSame->GetBinContent(iB) * fNofSimEvents * bW;
    double m_pm = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
    double m_pp = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
    double m_mm = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
 
    // derivatives of CB_{calc} w.r. to according value
    double d_m_pm = std::sqrt(s_pp * s_mm / (m_pp * m_mm));
    double d_m_pp = -0.5 * m_pm * std::pow(m_mm, -1. / 2.) * std::pow(m_pp, -3. / 2.) * std::sqrt(s_pp * s_mm);
    double d_m_mm = -0.5 * m_pm * std::pow(m_mm, -3. / 2.) * std::pow(m_pp, -1. / 2.) * std::sqrt(s_pp * s_mm);
    double d_s_pp = 0.5 * m_pm * std::sqrt(s_mm) * std::pow(m_pp * m_mm * s_pp, -1. / 2.);
    double d_s_mm = 0.5 * m_pm * std::sqrt(s_pp) * std::pow(m_pp * m_mm * s_mm, -1. / 2.);
 
    // contributions to error propagation
    double f_m_pm = std::pow(d_m_pm * std::sqrt(m_pm), 2);
    double f_m_pp = std::pow(d_m_pp * std::sqrt(m_pp), 2);
    double f_m_mm = std::pow(d_m_mm * std::sqrt(m_mm), 2);
    double f_s_pp = std::pow(d_s_pp * std::sqrt(s_pp), 2);
    double f_s_mm = std::pow(d_s_mm * std::sqrt(s_mm), 2);
 
    // final error propagation values
    double errorBc  = std::sqrt(f_m_pm + f_m_pp + f_m_mm + f_s_pp + f_s_mm) / (fNofSimEvents * bW);
    double errorBc2 = std::sqrt(normPPInt * normMMInt) * std::sqrt(m_pm) / (fNofSimEvents * bW);  // for range > 0.4 GeV
    if (iB < ChangeBin) cb->SetBinError(iB, errorBc);
    if (iB >= ChangeBin) cb->SetBinError(iB, errorBc2);
  }
  fHMean.fHM.Add("hReCbGeom_sameEv", geomSame);
  fHMean.fHM.Add("hReCbGeom_mixedEv", geomMixed);
  fHMean.fHM.Add("hReCbK", k);
  fHMean.fHM.Add("hReCb", cb);
  string cName = "FastSim/CombinatorialBackground/BG";
  TCanvas* c   = fHMean.fHM.CreateCanvas(cName, cName, 3200, 800);
  c->Divide(4, 1);
  c->cd(1);
  DrawH1({pmSame, ppSame, mmSame}, {"e+e-", "e+e+", "e-e-"}, kLinear, kLog, true, 0.8, 0.75, 0.91, 0.9, "hist");
  DrawTextOnPad("Same Events", 0.3, 0.9, 0.7, 0.99);
  c->cd(2);
  DrawH1({pmMixed, ppMixed, mmMixed}, {"e+e-", "e+e+", "e-e-"}, kLinear, kLog, true, 0.8, 0.75, 0.91, 0.9, "hist");
  DrawTextOnPad("Mixed Events", 0.29, 0.9, 0.71, 0.99);
  c->cd(3);
  DrawH1(k, kLinear, kLinear, "hist");
  DrawTextOnPad("#it{k} Factor", 0.3, 0.9, 0.7, 0.99);
  c->cd(4);
  DrawH1(cb, kLinear, kLog, "hist");
  DrawTextOnPad("Combinatorial Background from Fast Simulations", 0.1, 0.9, 0.84, 0.99);
}
 
void LmvmDrawAll::DrawSystematicErrorFsSignal()
{
  ELmvmAnaStep step = ELmvmAnaStep::ElId;
  string stepname   = fHMean.fAnaStepNames[static_cast<int>(step)];
 
  vector<TH1*> HistsCB;
  vector<TH1*> HistsRE;
  vector<TH1*> HistsSig;
 
  for (const string cutset : {"cut_standard_8", "cut_looser_10", "cut_stricter_17"}) {
    string dir     = "/lustre/cbm/users/criesen/data/studies/RandomEvent/SysErrorSignal/" + cutset + "/";
    TH1D* coc      = nullptr;
    TH1D* cocPluto = nullptr;
    TH1D* cocUrqmd = nullptr;
    int nEvents    = 0;
    double bW      = 0;
 
    // Get Cocktail
    for (const string pf : {"inmed", "qgp", "omegadalitz", "omegaepem", "phi"}) {
      LmvmHist HM;
      TFile* filePluto = new TFile((dir + pf + "/analysis.all.root").c_str());
      HM.fHM.ReadFromFile(filePluto);
      int nEventsSig = HM.H1("hEventNumber")->GetEntries();
      nEvents += nEventsSig;
      string nameFull = fHMean.GetName("hMinv", ELmvmSrc::Signal, step);
      TH1D* pluto     = (TH1D*) HM.fHM.GetObject("hMinv_signal_" + stepname)->Clone();
      TH1D* eta       = (TH1D*) HM.fHM.GetObject("hMinv_eta_" + stepname)->Clone();
      TH1D* pi0       = (TH1D*) HM.fHM.GetObject("hMinv_pi0_" + stepname)->Clone();
      bW              = pluto->GetBinWidth(1);
      pluto->Scale(1. / (nEventsSig * bW));
      eta->Scale(1. / bW);
      pi0->Scale(1. / bW);
      if (cocPluto == nullptr)
        cocPluto = pluto;
      else
        cocPluto->Add(pluto);
      if (cocUrqmd == nullptr)
        cocUrqmd = eta;
      else
        cocUrqmd->Add(eta);
      cocUrqmd->Add(pi0);
    }
 
    cocUrqmd->Scale(1. / nEvents);
    coc = cocUrqmd;
    coc->Add(cocPluto);
 
    // Get Background from Fast Simulations
    LmvmHist HMFastSim;
    TFile* fileRandom = new TFile((dir + "randomevent.all.root").c_str());
    HMFastSim.fHM.ReadFromFile(fileRandom);
    double nofFastSimEv = HMFastSim.H1("hre_EventNumber")->GetEntries();
    HMFastSim.fHM.ScaleByPattern("hre.*_Minv.*", 1. / nofFastSimEv);
    TH1D* bre = HMFastSim.H1Clone("hrec_MinvBg");  //("hre_MinvBg_" + stepname);
 
    // Calculate Combinatorial Background
    LmvmHist HMCB;
    TFile* filecb = new TFile((dir + "evmix.all.root").c_str());
    HMCB.fHM.ReadFromFile(filecb);
    HMCB.fHM.ScaleByPattern("hmx_Minv.*", 1. / fNofEvMixEvents);
    string hName    = "hmx_Minv";
    TH1D* pmSame    = HMCB.H1Clone(hName + "PM_sameEv", step);
    TH1D* ppSame    = HMCB.H1Clone(hName + "PP_sameEv", step);
    TH1D* mmSame    = HMCB.H1Clone(hName + "MM_sameEv", step);
    TH1D* pmMixed   = HMCB.H1Clone(hName + "PM_mixedEv", step);
    TH1D* ppMixed   = HMCB.H1Clone(hName + "PP_mixedEv", step);
    TH1D* mmMixed   = HMCB.H1Clone(hName + "MM_mixedEv", step);
    TH1D* geomSame  = (TH1D*) pmSame->Clone();
    TH1D* geomMixed = (TH1D*) pmSame->Clone();
    TH1D* k         = (TH1D*) pmMixed->Clone();
    TH1D* cb        = (TH1D*) pmSame->Clone();
    geomSame->Reset();
    geomMixed->Reset();
    cb->Reset();
 
    for (int iB = 1; iB <= geomSame->GetNbinsX(); iB++) {
      double cppSame = ppSame->GetBinContent(iB);
      double cmmSame = mmSame->GetBinContent(iB);
      double cSame   = std::sqrt(cppSame * cmmSame);
      geomSame->SetBinContent(iB, cSame);
      double cppMix = ppMixed->GetBinContent(iB);
      double cmmMix = mmMixed->GetBinContent(iB);
      double cMix   = std::sqrt(cppMix * cmmMix);
      geomMixed->SetBinContent(iB, cMix);
    }
    k->Divide(geomMixed);
    k->Scale(1. / 2.);
    int ChangeBin       = pmSame->FindBin(fCbChange);
    int NormRangeMinBin = pmSame->FindBin(fCbNormRangeMin);
    int NormRangeMaxBin = pmSame->FindBin(fCbNormRangeMax);
    double normPPInt =
      ppSame->Integral(NormRangeMinBin, NormRangeMaxBin) / ppMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
    double normMMInt =
      mmSame->Integral(NormRangeMinBin, NormRangeMaxBin) / mmMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
 
    for (int iB = 1; iB <= cb->GetNbinsX(); iB++) {
      double kval  = k->GetBinContent(iB);
      double pp    = ppMixed->GetBinContent(iB);
      double mm    = mmMixed->GetBinContent(iB);
      double cbval = (iB < ChangeBin) ? 2. * kval * geomSame->GetBinContent(iB)
                                      : 2. * kval * std::sqrt(normPPInt * pp * normMMInt * mm);
      cb->SetBinContent(iB, cbval);
    }
 
    // Calculate error for CB
    for (int iB = 1; iB <= cb->GetNbinsX(); iB++) {
      //s_ for same, m_ for mixed
      double s_pp = ppSame->GetBinContent(iB) * fNofSimEvents * bW;
      double s_mm = mmSame->GetBinContent(iB) * fNofSimEvents * bW;
      double m_pm = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
      double m_pp = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
      double m_mm = pmMixed->GetBinContent(iB) * fNofSimEvents * bW;
 
      // derivatives of CB_{calc} w.r. to according value
      double d_m_pm = std::sqrt(s_pp * s_mm / (m_pp * m_mm));
      double d_m_pp = -0.5 * m_pm * std::pow(m_mm, -1. / 2.) * std::pow(m_pp, -3. / 2.) * std::sqrt(s_pp * s_mm);
      double d_m_mm = -0.5 * m_pm * std::pow(m_mm, -3. / 2.) * std::pow(m_pp, -1. / 2.) * std::sqrt(s_pp * s_mm);
      double d_s_pp = 0.5 * m_pm * std::sqrt(s_mm) * std::pow(m_pp * m_mm * s_pp, -1. / 2.);
      double d_s_mm = 0.5 * m_pm * std::sqrt(s_pp) * std::pow(m_pp * m_mm * s_mm, -1. / 2.);
 
      // contributions to error propagation
      double f_m_pm = std::pow(d_m_pm * std::sqrt(m_pm), 2);
      double f_m_pp = std::pow(d_m_pp * std::sqrt(m_pp), 2);
      double f_m_mm = std::pow(d_m_mm * std::sqrt(m_mm), 2);
      double f_s_pp = std::pow(d_s_pp * std::sqrt(s_pp), 2);
      double f_s_mm = std::pow(d_s_mm * std::sqrt(s_mm), 2);
 
      // final error propagation values
      double errorBc = std::sqrt(f_m_pm + f_m_pp + f_m_mm + f_s_pp + f_s_mm) / (fNofSimEvents * bW);
      double errorBc2 =
        std::sqrt(normPPInt * normMMInt) * std::sqrt(m_pm) / (fNofSimEvents * bW);  // for range > 0.4 GeV
      if (iB < ChangeBin) cb->SetBinError(iB, errorBc);
      if (iB >= ChangeBin) cb->SetBinError(iB, errorBc2);
    }
 
    // Calculate Signal with Errors
    TH1D* sig = (TH1D*) bre->Clone();
    sig->Add(coc);
    sig->Add(cb, -1.);
    for (int iB = 1; iB <= sig->GetNbinsX(); iB++) {
      double D_bre  = bre->GetBinError(iB);
      double D_cbc  = cb->GetBinError(iB);
      double D_dNdM = std::sqrt(D_bre * D_bre + D_cbc * D_cbc);
      sig->SetBinError(iB, D_dNdM);
    }
 
    TH1D* ratio = (TH1D*) sig->Clone();
    ratio->Divide(coc);
    VaryBinWidth(ratio, fBwVarSig);
    ratio->GetYaxis()->SetRangeUser(-2., 2.);
    ratio->GetYaxis()->SetTitle("Ratio Sig_{RE} / MC Cocktail");
 
    HistsSig.push_back(ratio);
    HistsCB.push_back(cb);
    HistsRE.push_back(bre);
  }
 
  fHMean.fHM.CreateCanvas("FastSim/SysErrors/SigToCock", "FastSim/SysErrors/SigToCock", 800, 800);
  DrawH1(HistsSig, {"cutset_0", "cutset_looser", "cutset_stricter"}, kLinear, kLinear, true, 0.7, 0.8, 0.95, 0.91,
         "pe");
 
  // Ratios of each CBcalc and BRE from different Elid cuts
  {
    TH1D* ratCbLoose  = (TH1D*) HistsCB[1];
    TH1D* ratCbStrict = (TH1D*) HistsCB[2];
    ratCbLoose->Divide(HistsCB[0]);
    ratCbStrict->Divide(HistsCB[0]);
 
    TH1D* ratReLoose  = (TH1D*) HistsRE[1];
    TH1D* ratReStrict = (TH1D*) HistsRE[2];
    ratReLoose->Divide(HistsRE[0]);
    ratReStrict->Divide(HistsRE[0]);
 
    VaryBinWidth(ratCbLoose, fBwVarReg);
    VaryBinWidth(ratCbStrict, fBwVarReg);
    VaryBinWidth(ratReLoose, fBwVarReg);
    VaryBinWidth(ratReStrict, fBwVarReg);
 
    ratCbLoose->GetYaxis()->SetRangeUser(0.5, 1.5);
    ratReLoose->GetYaxis()->SetRangeUser(0.5, 1.5);
    ratCbLoose->GetYaxis()->SetTitle("Ratio");
    ratReLoose->GetYaxis()->SetTitle("Ratio");
 
    TCanvas* c = fHMean.fHM.CreateCanvas("FastSim/SysErrors/Backgrounds", "FastSim/SysErrors/Backgrounds", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({ratCbLoose, ratCbStrict}, {"loose / standard", "strict / standard"}, kLinear, kLinear, true, 0.7, 0.8, 0.95,
           0.91, "p");
    DrawTextOnPad("Combinatorial Background", 0.25, 0.9, 0.75, 0.99);
    c->cd(2);
    DrawH1({ratReLoose, ratReStrict}, {"loose / standard", "strict / standard"}, kLinear, kLinear, true, 0.7, 0.8, 0.95,
           0.91, "p");
    DrawTextOnPad("Fast Simulation Background", 0.25, 0.9, 0.75, 0.99);
  }
 
  // Ratio BRE/CBcalc for different Elid cuts
  {
    TH1D* r0 = (TH1D*) HistsRE[0];
    TH1D* rL = (TH1D*) HistsRE[1];
    TH1D* rS = (TH1D*) HistsRE[2];
    r0->Divide(HistsCB[0]);
    rL->Divide(HistsCB[1]);
    rS->Divide(HistsCB[2]);
 
    VaryBinWidth(r0, fBwVarBg);
    VaryBinWidth(rL, fBwVarBg);
    VaryBinWidth(rS, fBwVarBg);
 
    r0->GetYaxis()->SetRangeUser(0.97, 1.03);
    r0->GetYaxis()->SetTitle("Ratio");
 
    fHMean.fHM.CreateCanvas("FastSim/SysErrors/BreOverCbcalc", "FastSim/SysErrors/BreOverCbcalc", 800, 800);
    DrawH1({r0, rL, rS}, {"cutset_0", "cutset_looser", "cutset_stricter"}, kLinear, kLinear, true, 0.7, 0.8, 0.95, 0.91,
           "pe");
    DrawTextOnPad("B_{FS} / CB_{calc}", 0.35, 0.9, 0.65, 0.99);
  }
}
 
void LmvmDrawAll::DrawNumbers()
{
  // Draw Numbers of Events
  {
    TH1D* h    = new TH1D("hNofEvents", "hNofEvents; PLUTO File; Number", fH.size(), 0., fH.size());
    double min = 1e9;
    double max = -1e9;
    for (size_t iS = 0; iS < fH.size(); iS++) {
      double iB = iS + 1;
      double c  = fH[iS]->H1("hEventNumber")->GetEntries();
      if (c < min) min = c;
      if (c > max) max = c;
      h->SetBinContent(iB, c);
      h->GetXaxis()->SetBinLabel(iB, fHMean.fSignalNames[iS].c_str());
    }
    h->GetYaxis()->SetRangeUser(0.9 * min, 1.1 * max);
    fHMean.fHM.CreateCanvas("Numbers/NofEvents", "Numbers/NofEvents", 800, 800);
    DrawH1(h, kLinear, kLinear, "hist text30");  // "b", "bar"
    h->SetMarkerSize(1.);
    DrawTextOnPad("Total: " + Cbm::NumberToString(fNofSimEvents, 0) + " Events", 0.1, 0.8, 0.55, 0.89);
  }
 
  // Draw Numbers of MC Tracks seperate
  {
    vector<string> xLabel = {"e^{#pm}", "#pi^{#pm}", "#pi^{0}", "p", "n", "#gamma_{ch}", "o."};
    fHMean.fHM.CreateCanvas("Numbers/MCTracks", "Numbers/MCTracks", 800, 800);
    TH1D* h = fHMean.H1Clone("hNofMcTracks");
    DrawH1(h, kLinear, kLog, "hist");
    for (size_t iL = 0; iL < xLabel.size(); iL++) {
      h->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
    }
    double nAll    = h->Integral(1, h->GetNbinsX());
    double ratEl   = 100 * h->GetBinContent(1) / nAll;
    double ratPiC  = 100 * h->GetBinContent(2) / nAll;
    double ratPi0  = 100 * h->GetBinContent(3) / nAll;
    double ratProt = 100 * h->GetBinContent(4) / nAll;
    double ratNeut = 100 * h->GetBinContent(5) / nAll;
    double ratGCh  = 100 * h->GetBinContent(6) / nAll;
    double ratioO  = 100 * h->GetBinContent(7) / nAll;
    DrawTextOnPad(Cbm::NumberToString(ratEl, 1) + " %", 0.17, 0.8, 0.27, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratPiC, 1) + " %", 0.28, 0.8, 0.38, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratPi0, 1) + " %", 0.38, 0.8, 0.48, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratProt, 1) + " %", 0.49, 0.8, 0.59, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratNeut, 1) + " %", 0.59, 0.8, 0.69, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratGCh, 0) + " %", 0.69, 0.8, 0.79, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratioO, 1) + " %", 0.8, 0.8, 0.9, 0.89);
    DrawTextOnPad("Total: " + Cbm::NumberToString(nAll, 0) + " MC Tracks / Event", 0.05, 0.65, 0.7, 0.83);
  }
 
  // Draw Numbers of Global Tracks seperate
  {
    vector<string> xLabel = {"e_{Pluto}", "e_{#gamma}", "e_{o.}", "#pi^{#pm}", "p", "o."};
    fHMean.fHM.CreateCanvas("Numbers/GlobalTracks", "Numbers/GlobalTracks", 800, 800);
    TH1D* h = fHMean.H1Clone("hNofGTracks");
    DrawH1(h, kLinear, kLog, "hist");
    for (size_t iL = 0; iL < xLabel.size(); iL++) {
      h->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
    }
    double nAll       = h->Integral(1, h->GetNbinsX());
    double ratPlutoEl = 100 * h->GetBinContent(1) / nAll;
    double ratGammaEl = 100 * h->GetBinContent(2) / nAll;
    double ratOtherEl = 100 * h->GetBinContent(3) / nAll;
    double ratPiC     = 100 * h->GetBinContent(4) / nAll;
    double ratProton  = 100 * h->GetBinContent(5) / nAll;
    double ratioO     = 100 * h->GetBinContent(6) / nAll;
    DrawTextOnPad(Cbm::NumberToString(ratPlutoEl, 1) + " %", 0.16, 0.8, 0.30, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratGammaEl, 1) + " %", 0.31, 0.8, 0.40, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratOtherEl, 1) + " %", 0.42, 0.8, 0.54, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratPiC, 1) + " %", 0.55, 0.8, 0.64, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratProton, 0) + " %", 0.67, 0.8, 0.77, 0.89);
    DrawTextOnPad(Cbm::NumberToString(ratioO, 1) + " %", 0.79, 0.8, 0.89, 0.89);
    DrawTextOnPad(Cbm::NumberToString(nAll, 0) + " Global Tracks / Event", 0.1, 0.7, 0.55, 0.83);
  }
 
  // Draw number of Candidates (w.o. Pluto electrons)
  {
    gStyle->SetPaintTextFormat("4.2f");
    fHMean.fHM.CreateCanvas("Numbers/Candidates", "Numbers/Candidates", 1100, 800);
    TH1D* h = fHMean.H1Clone("hNofBgTracks");
    DrawH1(h, kLinear, kLog, "hist text30");
    h->SetMarkerSize(1.5);
    fHMean.SetAnalysisStepAxis(h);
  }
 
  // Draw Occurence of PDG
  /*{
    TH1D* h = fHMean.H1Clone("hCandPdg_mc");
    TCanvas* c = fHMean.fHM.CreateCanvas("Numbers/pdg", "Numbers/pdg", 2400, 800);
    c->Divide(3, 1);
    c->cd(1);
    DrawH1(h, kLinear, kLog, "hist");
    c->cd(2);
    TH1D* h2 = (TH1D*) h->Clone();
    h2->GetXaxis()->SetRangeUser(-330., 330.);
    DrawH1(h2, kLinear, kLog, "hist");
    c->cd(3);
    TH1D* h3 = (TH1D*) h->Clone();
    h3->GetXaxis()->SetRangeUser(-25., 25.);
    DrawH1(h3, kLinear, kLog, "hist");
    
    vector<int> pdg;
    for (int iB = 1; iB < h->GetNbinsX(); iB++) {
      if (h->GetBinContent(iB) != 0 && h->GetBinCenter(iB) < 0) pdg.push_back(h->GetXaxis()->GetBinCenter(iB) - 0.5);
      if (h->GetBinContent(iB) != 0 && h->GetBinCenter(iB) > 0) pdg.push_back(h->GetXaxis()->GetBinCenter(iB) + 0.5);
    }
    cout << "Occuring PDGs: ";
    for (size_t i = 0; i < pdg.size(); i++) {
      cout << pdg[i] << ", ";
      if (i == pdg.size() - 1) cout << endl;
    }
  }*/
}
 
void LmvmDrawAll::DrawRapidity()
{
  string cName = "Rapidity/";
  TCanvas* c   = fHMean.fHM.CreateCanvas(cName + "Rapidity_mc", cName + "Rapidity_mc", 2400, 1600);
  c->Divide(3, 2);
  int iC = 1;
  for (ELmvmSignal signal : fHMean.fSignals) {
    int nEventsSig = (int) fH[static_cast<int>(signal)]->H1("hEventNumber")->GetEntries();
    TH1D* plus     = H(signal)->H1Clone("hRapidity+_signal_mc");
    TH1D* minus    = H(signal)->H1Clone("hRapidity-_signal_mc");
    plus->Scale(1. / nEventsSig);
    minus->Scale(1. / nEventsSig);
    plus->GetYaxis()->SetTitle("Entries/Event");
    c->cd(iC++);
    DrawH1({plus, minus}, {"e+", "e-"}, kLinear, kLog, true, 0.85, 0.7, 0.97, 0.92, "hist");
    DrawTextOnPad(fHMean.fSignalNames[static_cast<int>(signal)], 0.35, 0.9, 0.65, 0.99);
  }
  c->cd(6);
  //int nEventsSig = (int) fH[static_cast<int>(ELmvmSignal::Inmed)]->H1("hEventNumber")->GetEntries();
  TH1D* plus  = fHMean.H1Clone("hRapidity+_eta_mc");
  TH1D* minus = fHMean.H1Clone("hRapidity-_eta_mc");
  //plus->Scale(1. / nEventsSig);
  //minus->Scale(1. / nEventsSig);
  plus->GetYaxis()->SetTitle("Entries/Event");
  DrawH1({plus, minus}, {"e+", "e-"}, kLinear, kLog, true, 0.85, 0.7, 0.97, 0.92, "hist");
  DrawTextOnPad("Eta Dalitz (UrQMD)", 0.32, 0.9, 0.68, 0.99);
}
 
void LmvmDrawAll::DrawCandProperties()
{
  vector<string> xLabel = {
    "P_{x}",           "P_{y}",          "#Chi^{2}_{prim}", "#Chi^{2}_{STS}", "#Chi^{2}_{RICH}", "#Chi^{2}_{TRD} / 2",
    "E-Loss / 10^{4}", "ANN_{RICH} + 2", "Like El",         "Like Pi",        "m^{2} + 1",       "time_{TOF}",
    "dist_{TOF} / 5",  "nHitsSts",       "nHitsRich / 5",   "nHitsTrd"};
 
  //TCanvas* c = fHMean.fHM.CreateCanvas("Properties/Ratio/All", "Properties/Ratio/All", 3200, 1800);
  //c->Divide(4, 3);
 
  for (int i = 1; i <= 11; i++) {
    string hName = "hCandProperties_" + Cbm::NumberToString(i, 0);
    fHMean.DrawAllCands(2, "Properties/" + Cbm::NumberToString(i, 0), hName, xLabel, {""}, false, true, 1e-12, 10.);
  }
 
  TCanvas* cRat = fHMean.fHM.CreateCanvas("Properties/Ratio/All", "Properties/Ratio/All", 3200, 1800);
  cRat->Divide(4, 3);
  for (int i = 1; i <= 11; i++) {
    string hName = "hCandProperties_" + Cbm::NumberToString(i, 0);
 
    TH2D* ratio = fHMean.H2Clone(hName + "_" + fHMean.fCandNames[0]);
    ratio->Add(fHMean.H2(hName + "_" + fHMean.fCandNames[1]));
 
    TH2D* bg = fHMean.H2Clone(hName + "_" + fHMean.fCandNames[2]);
    for (size_t iC = 3; iC < fHMean.fCandNames.size(); iC++) {
      bg->Add(fHMean.H2(hName + "_" + fHMean.fCandNames[iC]));
    }
 
    ratio->Divide(bg);
    ratio->GetZaxis()->SetRangeUser(1e-5, 2);
    ratio->GetZaxis()->SetTitle("Ratio Signal/BG");
 
    cRat->cd(i);
    DrawH2(ratio, kLinear, kLog, kLog, "colz");
 
    for (size_t iL = 0; iL < xLabel.size(); iL++) {
      ratio->GetXaxis()->SetBinLabel(iL + 1, xLabel[iL].c_str());
    }
    if (i < 11)
      DrawTextOnPad(Cbm::NumberToString(i - 1, 0) + " GeV < P < " + Cbm::NumberToString(i, 0) + " GeV", 0.15, 0.9, 0.65,
                    0.99);
    else
      DrawTextOnPad("P > 10 GeV", 0.15, 0.9, 0.65, 0.99);
 
    fHMean.fHM.CreateCanvas("Properties/Ratio/" + Cbm::NumberToString(i, 0),
                            "Properties/Ratio/" + Cbm::NumberToString(i, 0), 2800, 800);
    DrawH2(ratio, kLinear, kLog, kLog, "colz");
    if (i < 11)
      DrawTextOnPad(Cbm::NumberToString(i - 1, 0) + " GeV < P < " + Cbm::NumberToString(i, 0) + " GeV", 0.15, 0.9, 0.65,
                    0.99);
    else
      DrawTextOnPad("P > 10 GeV", 0.15, 0.9, 0.65, 0.99);
  }
}
 
void LmvmDrawAll::DrawRichProperties()
{
  double min = 1e-7;
  double max = 1e-1;
  fHMean.DrawAllCands(2, "RICH/RingTrackDist/NextVsSecond/all_next", "RichRingNeighbour_all_next", {""}, {""}, false,
                      false, min, max);
  fHMean.DrawAllCands(2, "RICH/RingTrackDist/NextVsSecond/all_secondnext", "RichRingNeighbour_all_secondnext", {""},
                      {""}, false, false, min, max);
  fHMean.DrawAllCands(2, "RICH/RingTrackDist/NextVsSecond/elid_next", "RichRingNeighbour_elid_next", {""}, {""}, false,
                      false, min, max);
  fHMean.DrawAllCands(2, "RICH/RingTrackDist/NextVsSecond/elid_secondnext", "RichRingNeighbour_elid_secondnext", {""},
                      {""}, false, false, min, max);
 
  fHMean.DrawAllCandsAndSteps(1, "RICH/RingTrackDist/1D/", "hRichRingTrackDist", {""}, {""}, false, false, 1e-9, 10);
  fHMean.DrawAllCandsAndSteps(2, "RICH/RingTrackDist/2D/", "hRichRingTrackDistVsMom", {""}, {""}, false, false, 1e-7,
                              1e-2);
 
  fHMean.fHM.CreateCanvas("RICH/NofHits", "RICH/NofHits", 800, 800);
  TH1D* hHits = fHMean.H1Clone("hNofRichHits");
  //hHits->SetStats(1);
  DrawH1(hHits, kLinear, kLog, "hist");
  hHits->Fit("gaus", "Q");
  TF1* fHits   = hHits->GetFunction("gaus");
  double meanH = (fHits != nullptr) ? fHits->GetParameter("Mean") : 0.;
  DrawTextOnPad("mean: " + Cbm::NumberToString(meanH, 0), 0.1, 0.8, 0.4, 0.89);
 
  fHMean.fHM.CreateCanvas("RICH/NofRings", "RICH/NofRings", 800, 800);
  TH1D* hRings = fHMean.H1Clone("hNofRichRings");
  DrawH1(hRings, kLinear, kLog, "hist");
  hRings->Fit("gaus", "Q");
  TF1* fRings  = hRings->GetFunction("gaus");
  double meanR = (fRings != nullptr) ? fRings->GetParameter("Mean") : 0.;
  DrawTextOnPad("mean: " + Cbm::NumberToString(meanR, 0), 0.1, 0.8, 0.4, 0.89);
 
  TCanvas* c = fHMean.fHM.CreateCanvas("RICH/BoA", "RICH/BoA", 1600, 1600);
  c->Divide(2, 2);
  int iC = 1;
  for (const string step : {"mc", "acc", "chi2prim", "elid"}) {
    string hName = "hRichRingBoA_" + step;
    TH1D* h      = fHMean.H1Clone(hName);
    c->cd(iC++);
    DrawH1(h, kLinear, kLog, "hist");
    DrawTextOnPad(step, 0.3, 0.9, 0.7, 0.99);
  }
}
 
template<class T>
T* LmvmDrawAll::GetCocktailMinv(const string& name, ELmvmAnaStep step, bool scaleAll)
{
  T* sEta     = dynamic_cast<T*>(fHMean.GetObject(fHMean.GetName(name, ELmvmSrc::Eta, step)));
  T* sPi0     = dynamic_cast<T*>(fHMean.GetObject(fHMean.GetName(name, ELmvmSrc::Pi0, step)));
  T* cocktail = nullptr;
  string nameFull;
  for (ELmvmSignal signal : fHMean.fSignals) {
    nameFull         = fHMean.GetName(name, ELmvmSrc::Signal, step);
    T* sHist         = dynamic_cast<T*>(H(signal)->GetObject(nameFull)->Clone());
    int nofEventsSig = (int) H(signal)->H1("hEventNumber")->GetEntries();
    if (scaleAll)
      sHist->Scale(1. / (nofEventsSig * fHMean.fNofSignals));
    else
      sHist->Scale(1. / nofEventsSig);
    // Rebinning only for 1D histograms
    if (dynamic_cast<T*>(fHMean.GetObject(fHMean.GetName(name, ELmvmSrc::Eta, step)))->GetDimension() == 1) {
      sHist->Rebin(fRebinMinv);
      double binWidth = sHist->GetBinWidth(1);
      sHist->Scale(1. / binWidth);
    }
    if (cocktail == nullptr)
      cocktail = sHist;
    else
      cocktail->Add(sHist);
  }
  cocktail->Add(sEta);
  cocktail->Add(sPi0);
  cocktail->SetName((nameFull + "_cocktail").c_str());
  return cocktail;
}
 
void LmvmDrawAll::DrawElidCuts()
{
  fHMean.DrawAllCandsAndSteps(2, "STS/E-Loss/", "hELossSts", {""}, {""}, false, false, 1e-12, 1e-2);
  fHMean.DrawAllCandsAndSteps(2, "RICH/ANN/", "hRichAnn", {""}, {""}, false, false, 1e-13, 1.);
  fHMean.DrawAllCandsAndSteps(2, "TRD/El-Like/", "hTrdElLike", {""}, {""}, false, false, 1e-13, 1.);
  fHMean.DrawAllCandsAndSteps(2, "TRD/Chi2/", "hChi2Dets_trd", {""}, {""}, false, false, 1e-13, 1e-2);
  fHMean.DrawAllCandsAndSteps(2, "TOF/M2/", "hTofM2", {""}, {""}, false, false, 1e-12, 1e-1);
  fHMean.DrawAllCandsAndSteps(2, "TOF/Dist/", "hTofDist", {""}, {""}, false, false, 1e-12, 1e-1);
  fHMean.DrawAllCands(2, "TOF/Dist/truematch", "hTofDist_truematch", {""}, {""}, false, false, 1e-12, 1e-1);
  fHMean.DrawAllCands(2, "TOF/Dist/mismatch", "hTofDist_mismatch", {""}, {""}, false, false, 1e-12, 1e-1);
  //fHMean.DrawAllCands(2, "TOF/Chi2/all", "hTofChi2_all", {""}, {""}, false, false, 1e-12, 1e-1);
  //fHMean.DrawAllCands(2, "TOF/Chi2/elid", "hTofChi2_elid", {""}, {""}, false, false, 1e-12, 1e-1);
  //fHMean.DrawAllCandsAndSteps(2, "Momentum/Pt/", "hMomPt", {""}, {""}, false, false, 1e-12, 1e-1);
 
  // All Elid cuts in one Canvas
  {
    for (ELmvmAnaStep step : {ELmvmAnaStep::Chi2Prim, ELmvmAnaStep::ElId}) {
      TH2D* stsELoss = fHMean.GetRatioElectronsOthers("hELossSts", step);
      TH2D* richAnn  = fHMean.GetRatioElectronsOthers("hRichAnn", step);
      TH2D* trdLike  = fHMean.GetRatioElectronsOthers("hTrdElLike", step);
      TH2D* trdChi2  = fHMean.GetRatioElectronsOthers("hChi2Dets_trd", step);
      TH2D* tofM2    = fHMean.GetRatioElectronsOthers("hTofM2", step);
      TH2D* tofM2z   = fHMean.GetRatioElectronsOthers("hTofM2", step);
      TH2D* tofDist  = fHMean.GetRatioElectronsOthers("hTofDist", step);
      double min     = 1e-2;
      double max     = 1e4;
      stsELoss->GetZaxis()->SetRangeUser(min, max);
      richAnn->GetZaxis()->SetRangeUser(min, max);
      trdLike->GetZaxis()->SetRangeUser(min, max);
      trdChi2->GetZaxis()->SetRangeUser(min, max);
      tofM2->GetZaxis()->SetRangeUser(min, max);
      tofM2z->GetZaxis()->SetRangeUser(min, max);
      tofM2z->GetXaxis()->SetRangeUser(0., 4.);
      tofM2z->GetYaxis()->SetRangeUser(-0.1, 0.1);
      string cName = "ElidCuts/" + fHMean.fAnaStepNames[static_cast<int>(step)];
      TCanvas* c   = fHMean.fHM.CreateCanvas(cName, cName, 3200, 1600);
      c->Divide(4, 2);
      c->cd(1);
      DrawH2(stsELoss, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("STS E-Loss", 0.2, 0.9, 0.68, 0.99);
      c->cd(2);
      DrawH2(richAnn, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("RICH ANN", 0.23, 0.9, 0.67, 0.99);
      c->cd(3);
      DrawH2(trdLike, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("TRD Likelihood", 0.15, 0.9, 0.73, 0.99);
      c->cd(4);
      DrawH2(trdChi2, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("TRD #chi^{2}", 0.24, 0.9, 0.62, 0.99);
      c->cd(5);
      DrawH2(tofM2, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("TOF #it{m}^{2}", 0.24, 0.9, 0.64, 0.99);
      c->cd(6);
      DrawH2(tofM2z, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("TOF #it{m}^{2} (zoom)", 0.12, 0.9, 0.64, 0.99);
      c->cd(7);
      DrawH2(tofDist, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("TOF Dist (norm.)", 0.12, 0.9, 0.64, 0.99);
    }
  }
 
  // TRD: Likelihood in 1D (Projection)
  {
    for (ELmvmAnaStep step : {ELmvmAnaStep::Chi2Prim, ELmvmAnaStep::ElId}) {
      string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
      string cName    = "TRD/El-Like/Steps/1D_" + stepname;
      TCanvas* c      = fHMean.fHM.CreateCanvas(cName, cName, 2400, 1800);
      c->Divide(4, 3);
      int iC = 1;
      for (const string& ptcl : fHMean.fCandNames) {
        string hName    = fHMean.GetName("hTrdElLike_" + ptcl, step);
        string projname = hName + "_y";
        TH2D* h2        = fHMean.H2Clone(hName);
        TH1D* h1        = (TH1D*) h2->ProjectionY(projname.c_str(), 1, h2->GetYaxis()->GetNbins(), "");
        c->cd(iC++);
        DrawH1(h1, kLinear, kLinear, "p");
        DrawTextOnPad(fHMean.fCandLatex[iC - 2], 0.3, 0.9, 0.8, 0.99);
      }
    }
  }
 
  // TOF-M2 zoomed
  for (ELmvmAnaStep step : {ELmvmAnaStep::Chi2Prim, ELmvmAnaStep::ElId}) {
    string cName = "TOF/M2/Steps/" + fHMean.fAnaStepNames[static_cast<int>(step)] + "_zoom";
    TCanvas* c   = fHMean.fHM.CreateCanvas(cName, cName, 3200, 2400);
    c->Divide(4, 3);
    int iC = 1;
    for (const string& ptcl : fHMean.fCandNames) {
      TH2D* h = fHMean.H2Clone("hTofM2_" + ptcl, step);
      h->GetXaxis()->SetRangeUser(0., 4.);
      h->GetYaxis()->SetRangeUser(-0.1, 0.1);
      h->GetZaxis()->SetRangeUser(1e-12, 1e-1);
      c->cd(iC++);
      DrawH2(h, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad(fHMean.fCandLatex[iC - 2], 0.25, 0.9, 0.75, 0.99);
    }
  }
}
 
void LmvmDrawAll::DrawMinvScaleValues()
{
  TH1D* inmedRaw    = H(ELmvmSignal::Inmed)->H1Clone("hMinv_unscaled");
  TH1D* qgpRaw      = H(ELmvmSignal::Qgp)->H1Clone("hMinv_unscaled");
  TH1D* inmedScaled = H(ELmvmSignal::Inmed)->H1Clone("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::Mc);
  TH1D* qgpScaled   = H(ELmvmSignal::Qgp)->H1Clone("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::Mc);
  double bW         = inmedRaw->GetBinWidth(1);
  inmedRaw->Scale(1. / (bW * H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries()));
  inmedScaled->Scale(1. / (bW * H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries()));
  qgpRaw->Scale(1. / (bW * H(ELmvmSignal::Qgp)->H1("hEventNumber")->GetEntries()));
  qgpScaled->Scale(1. / (bW * H(ELmvmSignal::Qgp)->H1("hEventNumber")->GetEntries()));
  inmedRaw->GetYaxis()->SetRangeUser(1e-9, 6e-1);
  qgpRaw->GetYaxis()->SetRangeUser(1e-9, 6e-1);
 
  TCanvas* c = fHMean.fHM.CreateCanvas("MassScaling/signal", "MassScaling/signal", 1600, 800);
  c->Divide(2, 1);
  c->cd(1);
  DrawH1({inmedRaw, inmedScaled},
         {"#rho_{i.m.}(raw)", "#rho_{i.m.}(raw) #upoint fW_{#rho} #upoint #it{w}_{#rho}(#it{m}_{inv.})"}, kLinear, kLog,
         true, 0.2, 0.16, 0.6, 0.3, "hist");
  DrawTextOnPad("inmed", 0.35, 0.9, 0.65, 0.99);
  c->cd(2);
  DrawH1({qgpRaw, qgpScaled}, {"QGP (raw)", "QGP (raw) #upoint fW_{QGP} #upoint #it{w}_{QGP}(#it{m}_{inv.})"}, kLinear,
         kLog, true, 0.2, 0.16, 0.6, 0.3, "hist");
  DrawTextOnPad("qgp", 0.36, 0.9, 0.64, 0.99);
 
  TH1D* scaleInmed = new TH1D("inmed", "inmed; M_{ee} [GeV/c^{2}]; Scale Value", 3400., 0., 3.4);
  TH1D* scaleQgp   = new TH1D("qgp", "qgp; M_{ee} [GeV/c^{2}]; Scale Value", 3400., 0., 3.4);
  for (int iB = 1; iB < 3400; iB++) {
    double binCenter = scaleInmed->GetBinCenter(iB);
    double sInmed    = LmvmUtils::GetMassScaleInmed(binCenter);
    double sQgp      = LmvmUtils::GetMassScaleQgp(binCenter);
    scaleInmed->SetBinContent(iB, sInmed);
    scaleQgp->SetBinContent(iB, sQgp);
  }
  scaleInmed->GetXaxis()->SetRangeUser(0., 3.);
  fHMean.fHM.CreateCanvas("MassScaling/scaling", "MassScaling/scaling", 1120, 800);
  DrawH1({scaleInmed, scaleQgp}, {"inmed", "QGP"}, kLinear, kLog, true, 0.7, 0.73, 0.91, 0.9, "hist");
  DrawTextOnPad("Scaling Factors #it{w_{i}}(#it{m}_{inv.})", 0.25, 0.9, 0.75, 0.99);
 
  TH1D* inmed2 = (TH1D*) scaleInmed->Clone();
  TH1D* qgp2   = (TH1D*) scaleQgp->Clone();
  inmed2->GetXaxis()->SetRangeUser(1., 1.1);
  qgp2->GetXaxis()->SetRangeUser(1., 1.1);
  inmed2->GetYaxis()->SetRangeUser(3e-3, 5e-1);
  qgp2->GetYaxis()->SetRangeUser(3e-3, 5e-1);
  fHMean.fHM.CreateCanvas("MassScaling/scaling_zoom", "MassScaling/scaling_zoom", 800, 800);
  DrawH1({inmed2, qgp2}, {"inmed", "QGP"}, kLinear, kLog, true, 0.7, 0.7, 0.9, 0.9, "p");
  DrawTextOnPad("Scaling Factors #it{w_{i}}(#it{m}_{inv.}) (zoom)", 0.18, 0.9, 0.8, 0.99);
}
 
void LmvmDrawAll::DrawNofHits()
{
  for (const string det : {"sts", "rich", "trd", "tof"}) {
    string cName = "NofHits/" + det;
    string hName = "hNofHitsVsMom_" + det;
    TCanvas* c   = fHMean.fHM.CreateCanvas(cName, cName, 1600, 1600);
    c->Divide(4, 4);
    int i = 1;
    for (const string& ptcl : fHMean.fGTrackNames) {
      int hitsMax    = (det == "sts") ? 10 : (det == "rich") ? 50 : (det == "trd") ? 5 : 2;
      double limY    = (det == "sts") ? 3.5 : (det == "rich") ? 6.5 : (det == "trd") ? 1.5 : 0.5;
      TLine* limLine = new TLine(-0.5, limY, 10.5, limY);
      limLine->SetLineWidth(4.);
      TH2D* h = fHMean.H2Clone(hName + "_" + ptcl);
      h->GetYaxis()->SetRangeUser(0., hitsMax);
      h->GetZaxis()->SetRangeUser(1e-9, 100);
      c->cd(i++);
      DrawH2(h, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad(fHMean.fGTrackLatex[i - 2], 0.25, 0.9, 0.75, 0.99);
      if (hitsMax <= 20) {
        for (int iB = 0; iB < hitsMax; iB++) {
          TLine* binLine = new TLine(0., iB + 0.5, 10., iB + 0.5);
          binLine->SetLineWidth(1.);
          binLine->Draw();
        }
      }
      limLine->Draw();
    }
  }
}
 
void LmvmDrawAll::DrawSignificance(TH2D* hEl, TH2D* hBg, const string& name, double minZ, double maxZ,
                                   const string& option)
{
  string hElProjName = name + "_yProjEl";
  string hBgProjName = name + "_yProjBg";
  TH1D* el           = hEl->ProjectionY(hElProjName.c_str(), 1, hEl->GetXaxis()->GetNbins(), "");
  TH1D* bg           = hBg->ProjectionY(hBgProjName.c_str(), 1, hBg->GetXaxis()->GetNbins(), "");
  TH2D* rat          = (TH2D*) hEl->Clone();
  rat->Divide(hBg);
 
  const string hName = name + "_sign";
  const string cName = "Significance/" + name;
 
  TH1D* sign = fHMean.CreateSignificanceH1(el, bg, hName.c_str(), option);
  TCanvas* c = fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 2400, 1600);
  c->Divide(3, 2);
  c->cd(1);
  DrawH2(hEl, kLinear, kLinear, kLog, "colz");
  hEl->GetZaxis()->SetRangeUser(minZ, maxZ);
  DrawTextOnPad("Electrons", 0.25, 0.9, 0.75, 0.99);
  c->cd(2);
  DrawH2(hBg, kLinear, kLinear, kLog, "colz");
  hBg->GetZaxis()->SetRangeUser(minZ, maxZ);
  DrawTextOnPad("Other", 0.25, 0.9, 0.75, 0.99);
  c->cd(3);
  DrawH2(rat, kLinear, kLinear, kLog, "colz");
  DrawTextOnPad("Ratio Electrons/Other", 0.2, 0.9, 0.8, 0.99);
  c->cd(4);
  DrawH1({el, bg}, {"Electrons", "Other"}, kLinear, kLog, true, 0.75, 0.75, 0.91, 0.91);
  DrawTextOnPad("Yield / Event", 0.25, 0.9, 0.75, 0.99);
  c->cd(5);
  DrawH1(sign, kLinear, kLinear, "hist");
  double maxX = -999999.;
  double maxY = -999999.;
  for (int iB = 1; iB <= sign->GetNbinsX(); iB++) {
    if (option == "right" && sign->GetBinContent(iB) >= maxY) {
      maxX = sign->GetBinCenter(iB);
      maxY = sign->GetBinContent(iB);
    }
    if (option == "left" && sign->GetBinContent(iB) > maxY) {
      maxX = sign->GetBinCenter(iB);
      maxY = sign->GetBinContent(iB);
    }
  }
  DrawTextOnPad("max. at: " + Cbm::NumberToString(maxX, 1), 0.55, 0.2, 0.85, 0.5);
  DrawTextOnPad("Significance", 0.25, 0.9, 0.75, 0.99);
}
 
void LmvmDrawAll::DrawSignificancesAll()
{
  ELmvmAnaStep step = ELmvmAnaStep::ElId;
  // X2 in TRD (filled after ElID step)
  {
    TH2D* el = fHMean.H2Clone("hChi2Dets_trd_" + fHMean.fCandNames[0], step);
    el->Add(fHMean.H2("hChi2Dets_trd_" + fHMean.fCandNames[1], step));
 
    TH2D* bg = fHMean.H2Clone("hChi2Dets_trd_" + fHMean.fCandNames[2], step);
    for (size_t iP = 3; iP < fHMean.fCandNames.size(); iP++) {  // consider UrQMD-electrons as "BG"
      string ptcl   = fHMean.fCandNames[iP];
      string hName  = "hChi2Dets_trd_" + ptcl + "_" + fHMean.fAnaStepNames[static_cast<int>(step)];
      bg->Add(fHMean.H2(hName.c_str()));
    }
 
    DrawSignificance(el, bg, "hChi2Dets_trd", 1e-9, 1e-3, "right");
  }
}
 
void LmvmDrawAll::DrawGTrackVertex()
{
  TCanvas* c = fHMean.fHM.CreateCanvas("Vertex/globalTrackRZ", "Vertex/globalTrackRZ", 1600, 800);
  c->Divide(2, 1);
  c->cd(1);
  TH2D* h = fHMean.H2Clone("hVertexGTrackRZ");
  h->GetYaxis()->SetRangeUser(0., 50);
  h->GetZaxis()->SetRangeUser(1e-7, 10);
  DrawH2(h, kLinear, kLinear, kLog, "colz");
  c->cd(2);
  TH2D* h2 = fHMean.H2Clone("hVertexGTrackRZ");
  h2->GetXaxis()->SetRangeUser(-49., -39.);
  h2->GetYaxis()->SetRangeUser(0., 10.);
  h2->GetZaxis()->SetRangeUser(1e-7, 10);
  DrawH2(h2, kLinear, kLinear, kLog, "colz");
}
 
void LmvmDrawAll::DrawBetaMomSpectra()
{
  double min = 1e-5;
  double max = 10;
  for (size_t i = 0; i < fHMean.fCandNames.size(); i++) {
    string cName = "BetaMom/" + fHMean.fCandNames[i];
    string hName = "hBetaMom_" + fHMean.fCandNames[i];
    fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 800, 800);
    TH2D* h = fHMean.H2Clone(hName.c_str());
    h->GetZaxis()->SetRangeUser(min, max);
    DrawH2(h, kLinear, kLinear, kLog, "colz");
    DrawTextOnPad((fHMean.fCandLatex[i]).c_str(), 0.25, 0.9, 0.75, 0.999);
  }
}
 
void LmvmDrawAll::DrawMomentumUrqmd()
{
  vector<pair<double, double>> varbinLongMc = {make_pair(6., 0.1), make_pair(10., 0.2)};
  vector<pair<double, double>> varbinLongId = {make_pair(6., 0.4), make_pair(10., 1.)};
  //vector<pair<double, double>> varbinTrMc = {make_pair(-1., 0.5), make_pair(1., 0.1), make_pair(3., 0.5)};
  //vector<pair<double, double>> varbinTrId = {make_pair(-1., 0.5), make_pair(1., 0.1), make_pair(3., 0.5)};
  vector<pair<double, double>> varbinTrMc = {make_pair(3., 0.2)};
  vector<pair<double, double>> varbinTrId = {make_pair(3., 0.2)};
  // Sources
  {
    vector<string> srcs = {"bg", "pi0", "gamma", "eta"};
    vector<TH1*> ratios;
    for (const string& src : srcs) {
      TCanvas* c = fHMean.fHM.CreateCanvas("Momentum/UrQMD/" + src, "Momentum/UrQMD/" + src, 3200, 800);
      c->Divide(4, 1);
      int iC = 1;
      for (const string pi : {"", "Px", "Py", "Pz"}) {
        vector<pair<double, double>> varbinMc = varbinLongMc;
        vector<pair<double, double>> varbinId = varbinLongId;
        if (pi == "Px" || pi == "Py") {
          varbinMc = varbinTrMc;
          varbinId = varbinTrId;
        }
        string xTitle = "P [GeV/c]";
        if (pi != "") xTitle = pi + " [GeV/c]";
        TH1D* mcP   = VaryBinWidth("mean", "hMom" + pi + "+_" + src + "_mc", varbinMc);
        TH1D* mcM   = VaryBinWidth("mean", "hMom" + pi + "-_" + src + "_mc", varbinMc);
        TH1D* elidP = VaryBinWidth("mean", "hMom" + pi + "+_" + src + "_elid", varbinId);
        TH1D* elidM = VaryBinWidth("mean", "hMom" + pi + "-_" + src + "_elid", varbinId);
        mcP->GetXaxis()->SetTitle(xTitle.c_str());
        mcP->GetYaxis()->SetRangeUser(1e-8, 5e2);
        if (pi == "") {
          TH1D* ratio = (TH1D*) elidP->Clone();
          ratio->Divide(elidM);
          ratio->GetYaxis()->SetTitle("Ratio e+/e-");
          ratios.push_back(ratio);
        }
        c->cd(iC++);
        DrawH1({mcP, mcM, elidP, elidM}, {"e+ (MC)", "e- (MC)", "e+ (ID)", "e- (ID)"}, kLinear, kLog, true, 0.75, 0.7,
               0.92, 0.91, "hist");
        string tag = (src == "bg") ? "BG" : (src == "pi0") ? "#pi^{0}" : (src == "gamma") ? "#gamma" : "#eta";
        DrawTextOnPad(tag, 0.3, 0.9, 0.7, 0.99);
      }
    }
    fHMean.fHM.CreateCanvas("Momentum/UrQMD/ChargeSymmetry", "Momentum/UrQMD/ChargeSymmetry", 800, 800);
    DrawH1(ratios, srcs, kLinear, kLinear, true, 0.75, 0.7, 0.91, 0.91, "pe");
    fHMean.DrawAnaStepOnPad(ELmvmAnaStep::ElId);
  }
 
  // BG with true electrons
  {
    TH1D* plus  = VaryBinWidth("mean", "hMom+_trueEl_bg_elid", varbinLongId);
    TH1D* minus = VaryBinWidth("mean", "hMom-_trueEl_bg_elid", varbinLongId);
    fHMean.fHM.CreateCanvas("Momentum/UrQMD/bg_trueEl", "Momentum/UrQMD/bg_trueEl", 800, 800);
    DrawH1({plus, minus}, {"e+ (ID)", "e- (ID)"}, kLinear, kLog, true, 0.75, 0.8, 0.92, 0.91, "hist");
    DrawTextOnPad("BG (true electrons)", 0.15, 0.9, 0.85, 0.99);
  }
 
  // Compare Pi0 with Gamma
  {
    TCanvas* c = fHMean.fHM.CreateCanvas("Momentum/UrQMD/Pi0Gamma", "Momentum/UrQMD/Pi0Gamma", 1600, 800);
    c->Divide(2, 1);
    int iC = 1;
    for (const string suff : {"+", "-"}) {
      TH1D* pi0Mc     = VaryBinWidth("mean", "hMom" + suff + "_pi0_mc", varbinLongMc);
      TH1D* pi0Elid   = VaryBinWidth("mean", "hMom" + suff + "_pi0_elid", varbinLongId);
      TH1D* gammaMc   = VaryBinWidth("mean", "hMom" + suff + "_gamma_mc", varbinLongMc);
      TH1D* gammaElid = VaryBinWidth("mean", "hMom" + suff + "_gamma_elid", varbinLongId);
      pi0Mc->GetYaxis()->SetRangeUser(1e-8, 1e2);
      c->cd(iC++);
      DrawH1({pi0Mc, gammaMc, pi0Elid, gammaElid}, {"#pi^{0} (MC)", "#gamma (MC)", "#pi^{0} (ID)", "#gamma (ID)"},
             kLinear, kLog, true, 0.8, 0.75, 0.92, 0.91, "hist");
      DrawTextOnPad("e" + suff, 0.3, 0.9, 0.7, 0.99);
    }
  }
}
 
void LmvmDrawAll::DrawMomPluto()
{
  for (ELmvmSignal signal : fHMean.fSignals) {
    string cName = "Momentum/Pluto/" + fHMean.fSignalNames[static_cast<int>(signal)];
    TCanvas* c   = fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 3200, 800);
    c->Divide(4, 1);
    int i = 1;
    for (const string pi : {"", "Px", "Py", "Pz"}) {
      c->cd(i++);
      string hName = "hMom" + pi;
      TH1D* epMc   = H(signal)->H1Clone((hName + "+_signal_mc").c_str());
      TH1D* emMc   = H(signal)->H1Clone((hName + "-_signal_mc").c_str());
      TH1D* epElid = H(signal)->H1Clone((hName + "+_signal_elid").c_str());
      TH1D* emElid = H(signal)->H1Clone((hName + "-_signal_elid").c_str());
      double bW    = epMc->GetBinWidth(1);
      epMc->Scale(1. / (H(signal)->H1("hEventNumber")->GetEntries() * bW));
      emMc->Scale(1. / (H(signal)->H1("hEventNumber")->GetEntries() * bW));
      epElid->Scale(1. / (H(signal)->H1("hEventNumber")->GetEntries() * bW));
      emElid->Scale(1. / (H(signal)->H1("hEventNumber")->GetEntries() * bW));
      string xTitle     = (pi == "Px") ? "P_{X}" : (pi == "Py") ? "P_{Y}" : (pi == "Pz") ? "P_{Z}" : "P";
      string xTitleFull = xTitle + " [GeV/c]";
      epMc->GetXaxis()->SetTitle(xTitleFull.c_str());
      epMc->GetYaxis()->SetTitle("dN/dP [GeV/c]^{-1}");
      epMc->GetYaxis()->SetTitleOffset(1.6);
      DrawH1({epMc, emMc, epElid, emElid}, {"e^{+} (MC)", "e^{-} (MC)", "e^{+} (ID)", "e^{-} (ID)"}, kLinear, kLog,
             true, 0.75, 0.7, 0.91, 0.91);
      DrawTextOnPad(fHMean.fSignalNames[static_cast<int>(signal)].c_str(), 0.25, 0.9, 0.85, 0.99);
    }
  }
}
 
void LmvmDrawAll::DrawMomentumMisidVsTrue()
{
  // draw momentum for misidentified and not-misidentified particles (from global tracks)
  {
    double min = 5e-8;
    double max = 10;
    TCanvas* c = fHMean.fHM.CreateCanvas("Momentum/misid_vs_True", "Momentum/misid_vs_True", 2400, 1600);
    c->Divide(3, 2);
    int iC = 1;
    for (size_t iP = 4; iP < fHMean.fCandNames.size(); iP++) {  // only draw for not-electrons
      c->cd(iC++);
      string ptcl = fHMean.fCandNames[iP];
      TH1D* hMis  = fHMean.H1Clone("hMom_" + ptcl + "_misid");
      TH1D* hTrue = fHMean.H1Clone("hMom_" + ptcl + "_true");
      hMis->GetYaxis()->SetRangeUser(min, max);
      hTrue->GetYaxis()->SetRangeUser(min, max);
      DrawH1({hTrue, hMis}, {"not misidentified", "misidentified as electron"}, kLinear, kLog, true, 0.55, 0.8, 0.95,
             0.91, "hist");
      DrawTextOnPad(fHMean.fCandLatex[iP], 0.4, 0.9, 0.54, 0.99);
    }
  }
}
 
void LmvmDrawAll::DrawEfficiency()
{
  string cName = "Efficiency/";
  string hName = "hMom_";
 
  ELmvmAnaStep refstep = ELmvmAnaStep::Reco;
 
  // hMinv
  TCanvas* c1 = fHMean.fHM.CreateCanvas(cName + "hMinv", cName + "hMinv", 2400, 1600);
  c1->Divide(3, 2);
  int iC = 1;
  for (ELmvmSignal signal : fHMean.fSignals) {
    TH1D* mc   = H(signal)->H1Clone("hMinv_signal_mc");
    TH1D* reco = H(signal)->H1Clone("hMinv_signal_reco");
    TH1D* elid = H(signal)->H1Clone("hMinv_signal_elid");
    mc->Rebin(fRebinMinv);
    reco->Rebin(fRebinMinv);
    elid->Rebin(fRebinMinv);
    TH1D* effMc   = (TH1D*) elid->Clone();
    TH1D* effReco = (TH1D*) elid->Clone();
    effMc->Divide(mc);
    effReco->Divide(reco);
    effMc->GetYaxis()->SetTitle("Efficiency");
    int nBinsXMinv     = mc->GetXaxis()->GetNbins();
    double eMc         = 100 * elid->Integral(1, nBinsXMinv) / mc->Integral(1, nBinsXMinv);
    double eReco       = 100 * elid->Integral(1, nBinsXMinv) / reco->Integral(1, nBinsXMinv);
    string eMcString   = Cbm::NumberToString(eMc, 2) + " %";
    string eRecoString = Cbm::NumberToString(eReco, 2) + " %";
    c1->cd(iC++);
    effMc->GetYaxis()->SetRangeUser(0., 0.3);
    effReco->GetYaxis()->SetRangeUser(0., 0.3);
    DrawH1({effMc, effReco}, {"Eff_{MC}: " + eMcString, "Eff_{Reco}: " + eRecoString}, kLinear, kLinear, true, 0.6, 0.7,
           0.97, 0.92, "hist");
    DrawTextOnPad(fHMean.fSignalNames[static_cast<int>(signal)], 0.35, 0.9, 0.65, 0.99);
  }
 
  // Draw Efficiency for all together for various steps
  TH1D* hRef = fHMean.H1Clone(hName + fHMean.fCandNames[0], refstep);
  hRef->Add(fHMean.H1(hName + fHMean.fCandNames[1], refstep));
 
  TH1D* elid = fHMean.H1Clone(hName + fHMean.fCandNames[0], ELmvmAnaStep::ElId);
  elid->Add(fHMean.H1(hName + fHMean.fCandNames[1], ELmvmAnaStep::ElId));
  elid->Divide(hRef);
 
  TH1D* gamma = fHMean.H1Clone(hName + fHMean.fCandNames[0], ELmvmAnaStep::GammaCut);
  gamma->Add(fHMean.H1(hName + fHMean.fCandNames[1], ELmvmAnaStep::GammaCut));
  gamma->Divide(hRef);
 
  TH1D* tt = fHMean.H1Clone(hName + fHMean.fCandNames[0], ELmvmAnaStep::TtCut);
  tt->Add(fHMean.H1(hName + fHMean.fCandNames[1], ELmvmAnaStep::TtCut));
  tt->Divide(hRef);
 
  TH1D* pt = fHMean.H1Clone(hName + fHMean.fCandNames[0], ELmvmAnaStep::PtCut);
  pt->Add(fHMean.H1(hName + fHMean.fCandNames[1], ELmvmAnaStep::PtCut));
  pt->Divide(hRef);
 
  int nBinsX = hRef->GetXaxis()->GetNbins();
 
  double effElid  = 100 * elid->Integral(1, nBinsX) / nBinsX;
  double effGamma = 100 * gamma->Integral(1, nBinsX) / nBinsX;
  double effTt    = 100 * tt->Integral(1, nBinsX) / nBinsX;
  double effPt    = 100 * pt->Integral(1, nBinsX) / nBinsX;
 
  fHMean.fHM.CreateCanvas(cName + "all_steps", cName + "all_steps", 900, 900);
  elid->GetYaxis()->SetTitle("Efficiency");
  DrawH1({elid, gamma, tt, pt},
         {"El-ID (" + Cbm::NumberToString(effElid, 1) + " %)", "Gamma cut (" + Cbm::NumberToString(effGamma, 1) + " %)",
          "TT cut (" + Cbm::NumberToString(effTt, 1) + " %)", "P_{t} cut (" + Cbm::NumberToString(effPt, 1) + " %)"},
         kLinear, kLinear, true, 0.6, 0.75, 0.95, 0.91, "hist");
  DrawTextOnPad("Signal Efficiency", 0.3, 0.9, 0.7, 0.99);
 
  // Draw Efficiency seperate for PLUTO (after El-ID)
  ELmvmAnaStep step = ELmvmAnaStep::ElId;
  string cNameFull  = cName + "plutos_" + fHMean.fAnaStepNames[static_cast<int>(step)];
  fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 900, 900);
 
  vector<TH1D*> sHists(fHMean.fNofSignals);
  for (ELmvmSignal signal : fHMean.fSignals) {
    TH1D* hRef2 = H(signal)->H1Clone(hName + fHMean.fCandNames[0], refstep);
    hRef2->Add(H(signal)->H1Clone(hName + fHMean.fCandNames[1], refstep));
    TH1D* hEff = H(signal)->H1Clone(hName + fHMean.fCandNames[0], step);
    hEff->Add(H(signal)->H1Clone(hName + fHMean.fCandNames[1], step));
    hEff->Divide(hRef2);
    hEff->GetYaxis()->SetTitle("Efficiency");
    sHists[static_cast<int>(signal)] = hEff;
  }
 
  double effInmed  = 100 * sHists[0]->Integral(1, nBinsX) / nBinsX;
  double effQgp    = 100 * sHists[1]->Integral(1, nBinsX) / nBinsX;
  double effOmega  = 100 * sHists[2]->Integral(1, nBinsX) / nBinsX;
  double effPhi    = 100 * sHists[3]->Integral(1, nBinsX) / nBinsX;
  double effOmegaD = 100 * sHists[4]->Integral(1, nBinsX) / nBinsX;
 
  vector<LmvmDrawMinvData> data;
  data.emplace_back(sHists[static_cast<int>(ELmvmSignal::OmegaD)], -1, kCyan + 2, 2, -1,
                    "#omega #rightarrow #pi^{0}e^{+}e^{-} (" + Cbm::NumberToString(effOmegaD, 1) + " %)");
  data.emplace_back(sHists[static_cast<int>(ELmvmSignal::Omega)], -1, kOrange + 7, 2, -1,
                    "#omega #rightarrow e^{+}e^{-} (" + Cbm::NumberToString(effOmega, 1) + " %)");
  data.emplace_back(sHists[static_cast<int>(ELmvmSignal::Phi)], -1, kAzure + 2, 2, -1,
                    "#phi #rightarrow e^{+}e^{-} (" + Cbm::NumberToString(effPhi, 1) + " %)");
  data.emplace_back(sHists[static_cast<int>(ELmvmSignal::Qgp)], -1, kOrange - 2, 2, -1,
                    "QGP radiation (" + Cbm::NumberToString(effQgp, 1) + " %)");
  data.emplace_back(sHists[static_cast<int>(ELmvmSignal::Inmed)], -1, kMagenta - 3, 2, -1,
                    "in-medium #rho (" + Cbm::NumberToString(effInmed, 1) + " %)");
 
  TLegend* leg = new TLegend(0.75, 0.65, .99, 0.99);
  for (size_t i = 0; i < data.size(); i++) {
    const auto& d = data[i];
    d.fH->GetYaxis()->SetLabelSize(0.05);
    if (d.fFillColor != -1) d.fH->SetFillColor(d.fFillColor);
    if (d.fFillStyle != -1) d.fH->SetFillStyle(d.fFillStyle);
    leg->AddEntry(d.fH, d.fLegend.c_str(), "f");
    DrawH1(d.fH, kLinear, kLinear, (i == 0) ? "hist" : "hist,same", d.fLineColor, d.fLineWidth, 0);
  }
  DrawTextOnPad("Efficiency (average of each both electrons)", 0.01, 0.9, 0.8, 0.99);
  leg->SetFillColor(kWhite);
  leg->Draw();
 
  // Draw single contributions
  vector<TH1D*> sHistsStepP(fHMean.fNofSignals);
  vector<TH1D*> sHistsStepE(fHMean.fNofSignals);
  vector<TH1D*> sHistsRefP(fHMean.fNofSignals);
  vector<TH1D*> sHistsRefE(fHMean.fNofSignals);
  for (ELmvmSignal signal : fHMean.fSignals) {
    TH1D* hStepP                          = H(signal)->H1Clone(hName + fHMean.fCandNames[0], step);
    TH1D* hStepE                          = H(signal)->H1Clone(hName + fHMean.fCandNames[1], step);
    TH1D* hRefP                           = H(signal)->H1Clone(hName + fHMean.fCandNames[0], refstep);
    TH1D* hRefE                           = H(signal)->H1Clone(hName + fHMean.fCandNames[1], refstep);
    sHistsStepP[static_cast<int>(signal)] = hStepP;
    sHistsStepE[static_cast<int>(signal)] = hStepE;
    sHistsRefP[static_cast<int>(signal)]  = hRefP;
    sHistsRefE[static_cast<int>(signal)]  = hRefE;
  }
 
  for (ELmvmSignal signal : fHMean.fSignals) {
    string cNameFull2 = cName + "Components_" + fHMean.fSignalNames[static_cast<int>(signal)];
    TCanvas* c        = fHMean.fHM.CreateCanvas(cNameFull2, cNameFull2, 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({sHistsStepP[static_cast<int>(signal)], sHistsStepE[static_cast<int>(signal)]}, {"positron", "electron"},
           kLinear, kLog, true, 0.85, 0.7, 0.99, 0.99, "hist");
    fHMean.DrawAnaStepOnPad(step);
    c->cd(2);
    DrawH1({sHistsRefP[static_cast<int>(signal)], sHistsRefE[static_cast<int>(signal)]}, {"positron", "electron"},
           kLinear, kLog, true, 0.85, 0.7, 0.99, 0.99, "hist");
    fHMean.DrawAnaStepOnPad(refstep);
  }
 
  // Efficiency electrons
  {
    vector<pair<double, double>> bwvar = {make_pair(10., 1.)};
    TH1D* hElRef                       = VaryBinWidth("mean", "hMom_plutoEl+_reco", bwvar);
    TH1D* hElCounter                   = VaryBinWidth("mean", "hMom_plutoEl+_elid", bwvar);
    for (int iP = 1; iP <= 3; iP++) {
      string ptcl    = fHMean.fCandNames[iP];
      TH1D* href     = VaryBinWidth("mean", "hMom_" + ptcl + "_reco", bwvar);
      TH1D* hcounter = VaryBinWidth("mean", "hMom_" + ptcl + "_elid", bwvar);
      hElRef->Add(href);
      hElCounter->Add(hcounter);
    }
    TH1D* hEff = (TH1D*) hElCounter->Clone();
    hEff->Divide(hElRef);
    int nX     = hElRef->GetNbinsX();
    double eff = hEff->Integral(1, nX) / nX;
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "efficiency_electrons", cName + "Efficiency_electrons", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({hElRef, hElCounter}, {"Ref", "Counter"}, kLinear, kLog, true, 0.85, 0.85, 0.95, 0.95, "p");
    c->cd(2);
    DrawH1(hEff, kLinear, kLog, "p");
    DrawTextOnPad("Efficiency", 0.3, 0.9, 0.7, 0.99);
    DrawTextOnPad("Electron Efficiency = " + Cbm::NumberToString(eff, 1), 0.11, 0.15, 0.6, 0.28);
  }
}
 
void LmvmDrawAll::DrawSuppression()
{
  vector<pair<double, double>> varbin = {make_pair(8., 0.5), make_pair(10., 2.)};
  for (const string ptcl : {"pion", "proton"}) {
    TCanvas* c = fHMean.fHM.CreateCanvas("Suppression/" + ptcl + "s", "Suppression/" + ptcl + "s", 3200, 800);
    c->Divide(4, 1);
    c->cd(1);
    TH1D* mc   = VaryBinWidth("mean", "hSuppression_" + ptcl + "_mc", varbin);
    TH1D* reco = VaryBinWidth("mean", "hSuppression_" + ptcl + "_reco", varbin);
    TH1D* acc  = VaryBinWidth("mean", "hSuppression_" + ptcl + "_acc", varbin);
    TH1D* elid = VaryBinWidth("mean", "hSuppression_" + ptcl + "_elid", varbin);
    TH1D* tt   = VaryBinWidth("mean", "hSuppression_" + ptcl + "_ttcut", varbin);
    TH1D* pt   = VaryBinWidth("mean", "hSuppression_" + ptcl + "_ptcut", varbin);
 
    mc->GetYaxis()->SetRangeUser(1e-7, 250);
    DrawH1({mc, reco, acc, elid, tt, pt}, {"MC", "Rec", "Acc", "El-ID", "TT", "P_{t}"}, kLinear, kLog, true, 0.8, 0.7,
           0.95, 0.91, "hist");
    DrawTextOnPad(ptcl, 0.4, 0.9, 0.6, 0.99);
 
    int iC = 2;
    for (const string step : {"mc", "reco", "acc"}) {
      TH1D* supElid = VaryBinWidth("mean", "hSuppression_" + ptcl + "_" + step, varbin);
      TH1D* supTt   = VaryBinWidth("mean", "hSuppression_" + ptcl + "_" + step, varbin);
      TH1D* supPt   = VaryBinWidth("mean", "hSuppression_" + ptcl + "_" + step, varbin);
      supElid->Divide(elid);
      supTt->Divide(tt);
      supPt->Divide(pt);
      supElid->GetYaxis()->SetTitle("Suppression");
      int nBins    = supElid->GetNbinsX();
      string sElid = Cbm::NumberToString((double) (supElid->Integral(1, nBins) / nBins), 0);
      c->cd(iC++);
      supElid->GetYaxis()->SetRangeUser(1e2, 1e7);
      DrawH1({supElid, supTt, supPt}, {"El-ID", "TT", "P_{t}"}, kLinear, kLog, true, 0.73, 0.86, 0.95, 0.97, "p");
      DrawTextOnPad(ptcl + " suppression (norm. to " + step + ")", 0.04, 0.87, 0.8, 0.99);
      DrawTextOnPad(ptcl + " supp. (El-ID): " + sElid, 0.04, 0.12, 0.65, 0.25);
    }
  }
}
 
void LmvmDrawAll::DrawTofM2()
{
  // for candidates
  {
    double minX = 0.;
    double maxX = 2.5;
    double minY = -0.05;
    double maxY = 0.05;
    double minZ = 1e-8;
    double maxZ = 10;
    vector<TLine*> lines{new TLine(0., 0.01, 1.3, 0.01), new TLine(1.3, 0.01, 2.5, 0.022)};  // set by hand
 
    for (auto step : fHMean.fAnaSteps) {
      TH2D* hEl = fHMean.H2Clone(("hTofM2_" + fHMean.fCandNames[0]), step);
      for (size_t iP = 1; iP < 4; iP++) {
        string hName = "hTofM2_" + fHMean.fCandNames[iP] + "_" + fHMean.fAnaStepNames[static_cast<int>(step)];
        hEl->Add(fHMean.H2(hName.c_str()));
      }
      TH2D* hBg = fHMean.H2Clone(("hTofM2_" + fHMean.fCandNames[4]), step);
      for (size_t iP = 5; iP < fHMean.fCandNames.size(); iP++) {
        string hName = "hTofM2_" + fHMean.fCandNames[iP] + "_" + fHMean.fAnaStepNames[static_cast<int>(step)];
        hBg->Add(fHMean.H2(hName.c_str()));
      }
      string cName = "TOF/M2/" + fHMean.fAnaStepNames[static_cast<int>(step)];
      TCanvas* c   = fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 1600, 800);
      c->Divide(2, 1);
      c->cd(1);
      hEl->GetXaxis()->SetRangeUser(minX, maxX);
      hEl->GetYaxis()->SetRangeUser(minY, maxY);
      hEl->GetZaxis()->SetRangeUser(minZ, maxZ);
      DrawH2(hEl, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("Electrons (" + fHMean.fAnaStepNames[static_cast<int>(step)] + ")", 0.3, 0.89, 0.6, 0.99);
      for (size_t i = 0; i < lines.size(); i++) {
        lines[i]->SetLineWidth(2.);
        lines[i]->Draw();
      }
      c->cd(2);
      hBg->GetXaxis()->SetRangeUser(minX, maxX);
      hBg->GetYaxis()->SetRangeUser(minY, maxY);
      hBg->GetZaxis()->SetRangeUser(minZ, maxZ);
      DrawH2(hBg, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("Other (" + fHMean.fAnaStepNames[static_cast<int>(step)] + ")", 0.3, 0.89, 0.55, 0.99);
      for (size_t i = 0; i < lines.size(); i++) {
        lines[i]->SetLineWidth(2.);
        lines[i]->Draw();
      }
    }
  }
  fHMean.DrawAllCands(2, "TOF/M2/MatchTrue", "hTofM2_truematch", {""}, {""}, false, false, 1e-9, 1e-2);
  fHMean.DrawAllCands(2, "TOF/M2/MatchMis", "hTofM2_mismatch", {""}, {""}, false, false, 1e-9, 1e-2);
}
 
void LmvmDrawAll::DrawPtYAndTofM2Misid()
{
  int n = 200;
  double x[n], y[n];
  double m  = 511e-6;
  double m2 = m * m;
  double p  = 6;
  double p2 = p * p;
  for (int i = 0; i < n; i++) {
    x[i] = 0.02 * i;
    double counter =
      std::sqrt(2 * m2 * TMath::Exp(2 * x[i]) - m2 * TMath::Exp(4 * x[i]) + 4 * p2 * TMath::Exp(2 * x[i]) - m2);
    double denom = std::sqrt(1 + 2 * TMath::Exp(2 * x[i]) + TMath::Exp(4 * x[i]));
    double r     = counter / denom;
    y[i]         = r;
  }
  auto pLine = new TGraph(n, x, y);  // draw momentum line into Pt-Y histogram
 
  for (const string cat : {"hPtY"}) {  //, "hTofM2"}) {
 
    // draw misidentified and not-misidentified particles and ratio of both (all from global tracks)
    {
      double min = (cat == "hPtY") ? 1e-7 : 1e-8;
      double max = (cat == "hPtY") ? 10 : 10;
      string cName = (cat == "hPtY") ? "PtY/Misids/" : "TOF/M2/Misids/";
      for (size_t iP = 4; iP < fHMean.fCandNames.size(); iP++) {  // only draw for not-electrons
        string ptcl  = fHMean.fCandNames[iP];
        string cNameFull = cName + ptcl + "_misid";
        TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull.c_str(), cNameFull.c_str(), 2400, 800);
        c->Divide(3, 1);
        c->cd(1);
        TH2D* hTrue = fHMean.H2Clone(cat + "_" + ptcl + "_true");
        if (cat == "hTofM2") {
          hTrue->GetXaxis()->SetRangeUser(0., 2.5);
          hTrue->GetYaxis()->SetRangeUser(-0.05, 0.05);
        }
        hTrue->GetZaxis()->SetRangeUser(min, max);
        DrawH2(hTrue, kLinear, kLinear, kLog, "colz");
        DrawTextOnPad(fHMean.fCandLatex[iP] + " (not misidentified)", 0.2, 0.9, 0.75, 0.99);
        if (cat == "hPtY") pLine->Draw("C");
 
        c->cd(2);
        TH2D* hMis = fHMean.H2Clone(cat + "_" + ptcl + "_misid");
        if (cat == "hTofM2") {
          hMis->GetXaxis()->SetRangeUser(0., 2.5);
          hMis->GetYaxis()->SetRangeUser(-0.05, 0.05);
        }
        hMis->GetZaxis()->SetRangeUser(min, max);
        DrawH2(hMis, kLinear, kLinear, kLog, "colz");
        DrawTextOnPad(fHMean.fCandLatex[iP] + " (misidentified as electron)", 0.15, 0.9, 0.75, 0.99);
        if (cat == "hPtY") pLine->Draw("C");
 
        c->cd(3);
        TH2D* hRat = fHMean.H2Clone(cat + "_" + ptcl + "_misid");
        hRat->Divide(hTrue);
        if (cat == "hTofM2") {
          hRat->GetXaxis()->SetRangeUser(0., 2.5);
          hRat->GetYaxis()->SetRangeUser(-0.05, 0.05);
        }
        hRat->GetZaxis()->SetRangeUser(1e-5, 1);
        hRat->GetZaxis()->SetTitle("Ratio #misid./#not misid.");
        DrawH2(hRat, kLinear, kLinear, kLog, "colz");
        DrawTextOnPad(fHMean.fCandLatex[iP] + ":  Ratio #misid./#not misid.", 0.1, 0.9, 0.6, 0.99);
        if (cat == "hPtY") pLine->Draw("C");
      }
    }
 
    // draw misidentified candidates for each step
    {
      double min = (cat == "hPtY") ? 2e-8 : 2e-8;
      double max = (cat == "hPtY") ? 5e-3 : 5e-3;
      string cName = (cat == "hPtY") ? "PtY/Misids/" : "TOF/M2/Misids/";
      for (size_t iP = 4; iP < fHMean.fCandNames.size(); iP++) {
        string ptcl   = fHMean.fCandNames[iP];
        string cNameFull = cName + ptcl + "_misid_steps";
        TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull.c_str(), cNameFull.c_str(), 1800, 1800);
        c->Divide(3, 3);
        int i = 1;
        for (auto step : fHMean.fAnaSteps) {
          if (step < ELmvmAnaStep::ElId) continue;
          c->cd(i++);
          string hName = cat + "_" + ptcl;
          TH2D* h      = fHMean.H2Clone(hName.c_str(), step);
          if (cat == "hTofM2") {
            h->GetXaxis()->SetRangeUser(0., 2.5);
            h->GetYaxis()->SetRangeUser(-0.05, 0.05);
          }
          h->GetZaxis()->SetRangeUser(min, max);
          DrawH2(h, kLinear, kLinear, kLog, "colz");
          fHMean.DrawAnaStepOnPad(step);
          if (cat == "hPtY") pLine->Draw("C");
        }
      }
    }
  }  // cat: "hPtY", "hTofM2"
}
 
void LmvmDrawAll::DrawPurity()
{
  vector<string> pLabel = {"e^{#pm}_{PLUTO}", "e^{#pm}_{UrQMD}", "e_{#gamma}", "#pi^{#pm}", "p", "K^{#pm}", "o."};
 
  // Misidentified Particles vs. Momentum
  {
    for (const string suff : {"", "+", "-"}) {
      for (ELmvmAnaStep step : fHMean.fAnaSteps) {
        if (step == ELmvmAnaStep::Mc) continue;
        if ((suff == "+" || suff == "-") && step != ELmvmAnaStep::ElId) continue;
        string cName = "";
        string hName = "";
        if (suff == "+" || suff == "-") {
          hName = "hCandPdgVsMom" + suff;
          cName = "Purity/purity" + suff;
        }
        else {
          hName = "hCandPdgVsMom_" + fHMean.fAnaStepNames[static_cast<int>(step)];
          cName = "Purity/purity_" + fHMean.fAnaStepNames[static_cast<int>(step)];
        }
        fHMean.fHM.CreateCanvas(cName, cName, 800, 600);
        TH2D* h = fHMean.H2Clone(hName);
        h->GetZaxis()->SetRangeUser(1e-11, 1e-2);
        DrawH2(h, kLinear, kLinear, kLog, "colz");
        for (size_t y = 1; y <= pLabel.size(); y++) {
          h->GetYaxis()->SetBinLabel(y, pLabel[y - 1].c_str());
        }
        double nSigEl     = h->Integral(1, h->GetXaxis()->GetNbins(), 1, 1);
        double nUrqmdEl   = h->Integral(1, h->GetXaxis()->GetNbins(), 2, 2);
        double nGammaEl   = h->Integral(1, h->GetXaxis()->GetNbins(), 3, 3);
        double nEl        = nSigEl + nUrqmdEl + nGammaEl;
        double nPions     = h->Integral(1, h->GetXaxis()->GetNbins(), 4, 4);
        double nProtons   = h->Integral(1, h->GetXaxis()->GetNbins(), 5, 5);
        double nKaons     = h->Integral(1, h->GetXaxis()->GetNbins(), 6, 6);
        double nOther     = h->Integral(1, h->GetXaxis()->GetNbins(), 7, 7);
        double nAll       = h->Integral(1, h->GetXaxis()->GetNbins(), 1, h->GetYaxis()->GetNbins());
        double purSig     = (nSigEl / nAll) * 100;
        double purUrqmdEl = (nUrqmdEl / nAll) * 100;
        double purGammaEl = (nGammaEl / nAll) * 100;
        double purEl      = (nEl / nAll) * 100;
        double purPions   = (nPions / nAll) * 100;
        double purProtons = (nProtons / nAll) * 100;
        double purKaons   = (nKaons / nAll) * 100;
        double purOther   = (nOther / nAll) * 100;
        DrawTextOnPad("Purity: " + Cbm::NumberToString(purEl, 1) + " % or " + Cbm::NumberToString(purSig, 2) + " %",
                      0.1, 0.9, 0.45, 0.99);
        if (suff == "+" || suff == "-") DrawTextOnPad("(" + suff + ")", 0.5, 0.9, 0.6, 0.99);
 
        double xMin = 0.08;
        double xMax = 0.63;
        DrawTextOnPad(Cbm::NumberToString(nSigEl, 3) + "/Event,  Portion: " + Cbm::NumberToString(purSig, 1) + " %",
                      xMin, 0.15, xMax, 0.25);
        DrawTextOnPad(Cbm::NumberToString(nUrqmdEl, 3) + "/Event,  Portion: " + Cbm::NumberToString(purUrqmdEl, 1)
                        + " %",
                      xMin, 0.27, xMax, 0.35);
        DrawTextOnPad(Cbm::NumberToString(nGammaEl, 3) + "/Event,  Portion: " + Cbm::NumberToString(purGammaEl, 1)
                        + " %",
                      xMin, 0.37, xMax, 0.46);
        DrawTextOnPad(Cbm::NumberToString(nPions, 3) + "/Event,  Portion: " + Cbm::NumberToString(purPions, 1) + " %",
                      xMin, 0.47, xMax, 0.56);
        DrawTextOnPad(Cbm::NumberToString(nProtons, 3) + "/Event,  Portion: " + Cbm::NumberToString(purProtons, 1)
                        + " %",
                      xMin, 0.58, xMax, 0.67);
        DrawTextOnPad(Cbm::NumberToString(nKaons, 3) + "/Event,  Portion: " + Cbm::NumberToString(purKaons, 1) + " %",
                      xMin, 0.70, xMax, 0.78);
        DrawTextOnPad(Cbm::NumberToString(nOther, 3) + "/Event,  Portion: " + Cbm::NumberToString(purOther, 1) + " %",
                      xMin, 0.80, xMax, 0.89);
      }
    }
  }
 
  // Purity vs. Momentum
  {
    for (ELmvmAnaStep step : {ELmvmAnaStep::ElId, ELmvmAnaStep::TtCut, ELmvmAnaStep::PtCut}) {
      int nBins       = fHMean.H2("hCandPdgVsMom", step)->GetXaxis()->GetNbins();
      double xMin     = fHMean.H2("hCandPdgVsMom", step)->GetXaxis()->GetXmin();
      double xMax     = fHMean.H2("hCandPdgVsMom", step)->GetXaxis()->GetXmax();
      string hNameEl  = "purityEl_mom_" + fHMean.fAnaStepNames[static_cast<int>(step)];
      string hNameSig = "puritySig_mom_" + fHMean.fAnaStepNames[static_cast<int>(step)];
      TH1D* purityEl  = new TH1D(hNameEl.c_str(), "purityEl_mom; P [GeV/c]; Purity [%]", nBins, xMin, xMax);
      TH1D* puritySig = new TH1D(hNameSig.c_str(), "puritySig_mom; P [GeV/c]; Purity [%]", nBins, xMin, xMax);
      for (int i = 1; i <= purityEl->GetNbinsX(); i++) {
        double nEl  = fHMean.H2("hCandPdgVsMom", step)->GetBinContent(i, 2);
        double nSig = fHMean.H2("hCandPdgVsMom", step)->GetBinContent(i, 1);
        double nAll =
          fHMean.H2("hCandPdgVsMom", step)->Integral(i, i, 1, fHMean.H2("hCandPdgVsMom_elid")->GetYaxis()->GetNbins());
        double pEl  = (nAll != 0) ? 100 * nEl / nAll : 0.;
        double pSig = (nAll != 0) ? 100 * nSig / nAll : 0.;
        purityEl->SetBinContent(i, pEl);
        puritySig->SetBinContent(i, pSig);
      }
      purityEl->Rebin(5);
      purityEl->Scale(1. / 5.);
      puritySig->Rebin(5);
      puritySig->Scale(1. / 5.);
      puritySig->GetYaxis()->SetRangeUser(0., 100.);
      string cName = "Purity/PurityVsMom_" + fHMean.fAnaStepNames[static_cast<int>(step)];
      fHMean.fHM.CreateCanvas(cName, cName, 800, 800);
      DrawH1({puritySig, purityEl}, {"Signal Electrons", "All Electrons"}, kLinear, kLinear, true, 0.7, 0.8, 0.95, 0.91,
             "p");
    }
  }
 
  // Projections of Y
  {
    for (auto step : fHMean.fAnaSteps) {
      if (step == ELmvmAnaStep::Mc) continue;
      string hName = "hCandPdgInt_" + fHMean.fAnaStepNames[static_cast<int>(step)];
      TH2D* h2D    = fHMean.H2Clone("hCandPdgVsMom_" + fHMean.fAnaStepNames[static_cast<int>(step)]);
      TH1D* h1D =
        h2D->ProjectionY(hName.c_str(), 0, h2D->GetXaxis()->GetNbins() + 1, "");  // include under- / overflow bins
      h1D->GetYaxis()->SetRangeUser(1e-6, 5.);
      h1D->GetYaxis()->SetTitle("N / Event");
      for (size_t iL = 0; iL < pLabel.size(); iL++) {
        h1D->GetXaxis()->SetBinLabel(iL + 1, pLabel[iL].c_str());
      }
      string cName = "Purity/1D/" + fHMean.fAnaStepNames[static_cast<int>(step)];
      fHMean.fHM.CreateCanvas(cName, cName, 800, 800);
      DrawH1(h1D, kLinear, kLog, "hist");
      fHMean.DrawAnaStepOnPad(step);
 
      double nAll = h1D->Integral(1, h1D->GetNbinsX(), "width");
 
      double pElP  = 100 * (h1D->GetBinContent(1) / nAll);
      double pElU  = 100 * (h1D->GetBinContent(2) / nAll);
      double pElG  = 100 * (h1D->GetBinContent(3) / nAll);
      double pPiC  = 100 * (h1D->GetBinContent(4) / nAll);
      double pProt = 100 * (h1D->GetBinContent(5) / nAll);
      double pK    = 100 * (h1D->GetBinContent(6) / nAll);
      double pOth  = 100 * (h1D->GetBinContent(7) / nAll);
 
      DrawTextOnPad(Cbm::NumberToString(pElP, 1) + " %", 0.17, 0.8, 0.27, 0.89);
      DrawTextOnPad(Cbm::NumberToString(pElU, 1) + " %", 0.28, 0.8, 0.38, 0.89);
      DrawTextOnPad(Cbm::NumberToString(pElG, 1) + " %", 0.38, 0.8, 0.48, 0.89);
      DrawTextOnPad(Cbm::NumberToString(pPiC, 1) + " %", 0.49, 0.8, 0.59, 0.89);
      DrawTextOnPad(Cbm::NumberToString(pProt, 1) + " %", 0.59, 0.8, 0.69, 0.89);
      DrawTextOnPad(Cbm::NumberToString(pK, 1) + " %", 0.69, 0.8, 0.79, 0.89);
      DrawTextOnPad(Cbm::NumberToString(pOth, 1) + " %", 0.80, 0.8, 0.90, 0.89);
    }
  }
 
  // Purity seperate for ID Detectors
  {
    vector<string> yLabel = {"#pi^{+}", "#pi^{-}", "p", "K^{+}", "K^{-}", "o."};
    double min            = 1e-7;
    double max            = 10;
 
    for (const string cat : {"rec", "acc", "chi2prim"}) {
      TH2D* rich = fHMean.H2Clone("hPdgVsMom_rich_" + cat);
      TH2D* trd  = fHMean.H2Clone("hPdgVsMom_trd_" + cat);
      TH2D* tof  = fHMean.H2Clone("hPdgVsMom_tof_" + cat);
 
      rich->GetZaxis()->SetRangeUser(min, max);
      trd->GetZaxis()->SetRangeUser(min, max);
      tof->GetZaxis()->SetRangeUser(min, max);
 
      for (size_t y = 1; y <= yLabel.size(); y++) {
        rich->GetYaxis()->SetBinLabel(y, yLabel[y - 1].c_str());
        trd->GetYaxis()->SetBinLabel(y, yLabel[y - 1].c_str());
        tof->GetYaxis()->SetBinLabel(y, yLabel[y - 1].c_str());
      }
 
      TCanvas* c = fHMean.fHM.CreateCanvas("Purity/misid_gTracks_" + cat, "Purity/misid_gTracks_" + cat, 2400, 800);
      c->Divide(3, 1);
      c->cd(1);
      DrawH2(rich, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("RICH", 0.25, 0.9, 0.75, 0.999);
      DrawPurityHistText(rich);
      c->cd(2);
      DrawH2(trd, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("TRD", 0.25, 0.9, 0.75, 0.999);
      DrawPurityHistText(trd);
      c->cd(3);
      DrawH2(tof, kLinear, kLinear, kLog, "colz");
      DrawTextOnPad("ToF", 0.25, 0.9, 0.75, 0.999);
      DrawPurityHistText(tof);
    }
  }
}
 
void LmvmDrawAll::DrawPurityHistText(TH2D* h)
{
  int nX = h->GetXaxis()->GetNbins();
 
  double xMin = 0.4;
  double xMax = 0.75;
  double piP  = h->Integral(1, nX, 1, 1);
  double piM  = h->Integral(1, nX, 2, 2);
  double p    = h->Integral(1, nX, 3, 3);
  double KP   = h->Integral(1, nX, 4, 4);
  double KM   = h->Integral(1, nX, 5, 5);
  double o    = h->Integral(1, nX, 6, 6);
 
  DrawTextOnPad("#pi^{+}: " + Cbm::NumberToString(piP, 1) + " /Ev", xMin, 0.12, xMax, 0.3);
  DrawTextOnPad("#pi^{-}: " + Cbm::NumberToString(piM, 1) + " /Ev", xMin, 0.28, xMax, 0.37);
  DrawTextOnPad("p: " + Cbm::NumberToString(p, 1) + " /Ev", xMin, 0.43, xMax, 0.48);
  DrawTextOnPad("K^{+}: " + Cbm::NumberToString(KP, 1) + " /Ev", xMin, 0.53, xMax, 0.65);
  DrawTextOnPad("K^{-}: " + Cbm::NumberToString(KM, 1) + " /Ev", xMin, 0.66, xMax, 0.76);
  DrawTextOnPad("o.: " + Cbm::NumberToString(o, 1) + " /Ev", xMin, 0.77, xMax, 0.9);
}
 
void LmvmDrawAll::DrawMomentum()
{
  DrawMomPluto();
  DrawMomentumUrqmd();
  DrawMomentumMisidVsTrue();
}
 
void LmvmDrawAll::InvestigateMisid()
{
  DrawPtYAndTofM2Misid();
  DrawChi2();
 
  // Connection between Misidentification and Mismatches
  {
    vector<string> xLabel = {"0", "1", "2", "3"};
    vector<string> yLabel = {"true-ID", "mis-ID"};
    fHMean.DrawAllGTracks(2, "hMatchId_gTracks", "hMatchId_gTracks", {xLabel}, {yLabel}, false, false, 1e-7, 1e3);
  }
 
  // Number of Matches/Mismatches
  {
    TCanvas* c = fHMean.fHM.CreateCanvas("Mismatches/Det_Yields", "Mismatches/Det_Yields", 2400, 800);
    c->Divide(3, 1);
    int iC = 1;
    for (const string det : {"rich", "trd", "tof"}) {
      TH1D* h = fHMean.H1Clone("hMatch_" + det);
      h->GetXaxis()->SetBinLabel(1, "True Match");
      h->GetXaxis()->SetBinLabel(2, "Mismatch");
      c->cd(iC++);
      DrawH1(h, kLinear, kLinear, "hist");
      DrawTextOnPad(det, 0.42, 0.9, 0.58, 0.99);
      double mism = 100 * h->GetBinContent(2) / (h->GetBinContent(1) + h->GetBinContent(2));
      DrawTextOnPad("Mismatches: " + Cbm::NumberToString(mism, 1) + " %", 0.12, 0.14, 0.42, 0.24);
    }
  }
 
  // STS-E-Loss vs. TOF-M2
  {
    for (const string cat : {"Seg1Mom1", "Seg1Mom2", "Seg2Mom1", "Seg2Mom2"}) {
      fHMean.DrawAllCands(2, "ELossM2/chi2prim" + cat, "hElossTime_chi2prim_" + cat, {""}, {""}, false, false, 1e-17,
                          1e-2);
      fHMean.DrawAllCands(2, "ELossM2/elid" + cat, "hElossTime_elid_" + cat, {""}, {""}, false, false, 1e-17, 1e-2);
    }
  }
 
  // TOF-m2 in dependance on position
  for (int pos : {50, 100, 150, 200, 300, 400, 500}) {
    for (const string step : {"chi2prim", "elid"}) {
      string cName = "TOF/M2/Position/" + step + "_" + Cbm::NumberToString(pos, 0);
      string hName = "hTofM2_" + step + "_" + Cbm::NumberToString(pos, 0);
      fHMean.DrawAllCands(2, cName, hName, {""}, {""}, false, false, 1e-15, 1e-2);
    }
  }
 
  // TOF: Multiplicity of TofHitIndex at TofTracks
  for (const string nInd : {"1", "2", "3+"}) {
    string cName = "TOF/M2/NofTofHitIndex/" + nInd;
    string hName = "hTofM2_woDoubleIndex_" + nInd;
    fHMean.DrawAllCands(2, cName, hName, {""}, {""}, false, false, 1e-15, 1e-2);
  }
 
  // Vertex of TOF-misidentifications
  {
    double min = 1e-7;
    for (auto step : fHMean.fAnaSteps) {
      string cName = "TOF/Vertex/tofMisid_" + fHMean.fAnaStepNames[static_cast<int>(step)];
      vector<TH2D*> xyz{fHMean.H2("hVertexXZ_misidTof", step), fHMean.H2("hVertexYZ_misidTof", step),
                        fHMean.H2("hVertexXY_misidTof", step)};
 
      TCanvas* c = fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 1800, 600);
      c->Divide(3, 1);
      for (size_t i = 0; i < xyz.size(); i++) {
        c->cd(i + 1);
        DrawH2(xyz[i]);
        xyz[i]->SetMinimum(min);
        gPad->SetLogz(true);
      }
 
      TCanvas* cZoom = fHMean.fHM.CreateCanvas((cName + "_zoom").c_str(), (cName + "_zoom").c_str(), 1800, 600);
      cZoom->Divide(3, 1);
      for (size_t i = 0; i < xyz.size(); i++) {
        TH2D* hZoom = (TH2D*) xyz[i]->Clone();
        cZoom->cd(i + 1);
        if (i == 2) {
          hZoom->GetXaxis()->SetRangeUser(-10., 10.);
          hZoom->GetYaxis()->SetRangeUser(-10., 10.);
        }
        else {
          hZoom->GetXaxis()->SetRangeUser(fZ - 1., fZ + 10.);
          hZoom->GetYaxis()->SetRangeUser(-10., 10.);
        }
        DrawH2(hZoom);
        hZoom->SetMinimum(min);
        gPad->SetLogz(true);
      }
 
      fHMean.fHM.CreateCanvas((cName + "_RZ").c_str(), (cName + "_RZ").c_str(), 900, 900);
      TH2D* hRZ = fHMean.H2Clone("hVertexRZ_misidTof", step);
      hRZ->SetMinimum(min);
      DrawH2(hRZ, kLinear, kLinear, kLog);
    }
  }
 
  // draw chi2 of true-matched vs. mismatched
  for (const string match : {"truematch", "mismatch"}) {
    for (const string det : {"rich", "trd", "tof"}) {
      string cName = "hChi2/" + match + "_" + det;
      string hName = "hChi2_" + match + "_" + det;
      fHMean.DrawAllGTracks(1, cName, hName, {""}, {""}, false, false, 2e-7, 10);
    }
  }
 
  double minMism = 1e-4;
  double maxMism = 100.;
 
  vector<string> xLabelDet = {"STS_{all}", "RICH_{all}", "RICH_{mis}", "TRD_{all}",
                              "TRD_{mis}", "ToF_{all}",  "ToF_{mis}"};
  fHMean.DrawAllGTracks(1, "Mismatches/FullGTracks", "hNofMismatches_gTracks", xLabelDet, {""}, false, false, minMism,
                        maxMism);
 
  vector<string> xLabelSeg = {"0", "1", "2", "3"};
  fHMean.DrawAllGTracks(1, "Mismatches/TrackSegments", "hNofMismatchedTrackSegments", xLabelSeg, {""}, false, false,
                        minMism, maxMism);
}
 
void LmvmDrawAll::DrawChi2()
{
  string step = fHMean.fAnaStepNames[static_cast<int>(ELmvmAnaStep::ElId)];
  double min = 1e-9;
  double max = 5e-3;
  for (const string det : {"StsRich", "StsTrd", "RichTrd"}) {
    fHMean.DrawAllCands(2, "hChi2/Detectors/hChi2Comb" + det, "hChi2Comb_" + det, {""}, {""}, false, false, min, max);
  }
}
 
void LmvmDrawAll::DrawMinvAll()
{
  for (const ELmvmAnaStep step : fHMean.fAnaSteps) {
    //if (step < ELmvmAnaStep::ElId) continue;
    string cName = "Minv/" + fHMean.fAnaStepNames[static_cast<int>(step)];
    fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 1000, 1000);
    DrawMinv(step);
    fHMean.DrawAnaStepOnPad(step);
  }
}
 
void LmvmDrawAll::DrawMinv(ELmvmAnaStep step)
{
  TH1D* sbg = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Bg, step), fBwVarBg);
  sbg->Add(VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fBwVarBg));
  TH1D* bg       = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Bg, step), fBwVarBg);
  TH1D* pi0      = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Pi0, step), fBwVarBg);
  TH1D* eta      = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Eta, step), fBwVarBg);
  TH1D* gamma    = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Gamma, step), {make_pair(2.5, 0.02)});
  TH1D* cocktail = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fBwVarCock);
 
  TH1D* cb = nullptr;
  if (step >= ELmvmAnaStep::ElId) cb = VaryBinWidth("mean", fHMean.GetName("hCbBg", step), fBwVarBg);
 
  // Signals
  vector<TH1D*> sHists(fHMean.fNofSignals);
  for (ELmvmSignal signal : {ELmvmSignal::Inmed, ELmvmSignal::Qgp, ELmvmSignal::OmegaD}) {
    string sigName = fHMean.fSignalNames[static_cast<int>(signal)];
    TH1D* sHist    = VaryBinWidth(sigName, fHMean.GetName("hMinv", ELmvmSrc::Signal, step), fBwVarReg);
    sHist->Scale(1. / H(signal)->H1("hEventNumber")->GetEntries());
    sHists[static_cast<int>(signal)] = sHist;
  }
 
  TH1D* phi = VaryBinWidth("phi", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), fBwVarPhi);
  phi->Scale(1. / H(ELmvmSignal::Phi)->H1("hEventNumber")->GetEntries());
  sHists[static_cast<int>(ELmvmSignal::Phi)] = phi;
 
  TH1D* omega = VaryBinWidth("omegaepem", fHMean.GetName("hMinv", ELmvmSrc::Signal, step), fBwVarOmega);
  omega->Scale(1. / H(ELmvmSignal::Omega)->H1("hEventNumber")->GetEntries());
  sHists[static_cast<int>(ELmvmSignal::Omega)] = omega;
 
  // Prepare drawing
  vector<LmvmDrawMinvData> drawData;
  sbg->GetYaxis()->ChangeLabel(0, -1., 10., -1, -1, -1);  //, "dN/dM_{ee}/N_{Ev} [GeV/c^{2}]^{-1}");
  if (step >= ELmvmAnaStep::Reco) {
    drawData.emplace_back(sbg, kBlack, kBlack, 1, -1, "Cocktail+B_{MC}");
    drawData.emplace_back(bg, kGray, kBlack, 1, -1, "B_{MC}");
  }
 
  drawData.emplace_back(pi0, kGreen - 3, kGreen + 3, 2, -1, "#pi^{0} #rightarrow #gammae^{+}e^{-}");
  drawData.emplace_back(eta, kRed - 4, kRed + 2, 2, -1, "#eta #rightarrow #gammae^{+}e^{-}");
  drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::OmegaD)], kCyan + 2, kCyan + 4, 2, -1,
                        "#omega #rightarrow #pi^{0}e^{+}e^{-}");
  drawData.emplace_back(gamma, -1, kYellow, 4, -1, "#gamma #rightarrow e^{+}e^{-}");
  drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Omega)], kOrange + 7, kOrange + 4, 2, -1,
                        "#omega #rightarrow e^{+}e^{-}");
  drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Phi)], kAzure + 2, kAzure + 3, 2, -1,
                        "#phi #rightarrow e^{+}e^{-}");
  drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Qgp)], kOrange - 2, kOrange - 3, 4, 3112, "QGP radiation");
  drawData.emplace_back(sHists[static_cast<int>(ELmvmSignal::Inmed)], kMagenta - 3, kMagenta - 2, 4, 3018,
                        "in-medium #rho");
  drawData.emplace_back(cocktail, -1, kRed + 2, 4, -1, "Cocktail");
  if (step >= ELmvmAnaStep::ElId) drawData.emplace_back(cb, -1, kCyan + 1, 4, -1, "CB_{calc}");
 
  TH1D* h0     = nullptr;
  TLegend* leg = new TLegend(0.72, 0.55, 0.97, 0.99);
  for (size_t i = 0; i < drawData.size(); i++) {
    const auto& d = drawData[i];
    d.fH->GetYaxis()->SetLabelSize(0.04);
    if (step >= ELmvmAnaStep::ElId)
      d.fH->GetYaxis()->SetRangeUser(5e-10, 5e-2);
    else
      d.fH->GetYaxis()->SetRangeUser(5e-10, 1e2);
    if (d.fFillColor != -1) d.fH->SetFillColor(d.fFillColor);
    if (d.fFillStyle != -1) d.fH->SetFillStyle(d.fFillStyle);
    leg->AddEntry(d.fH, d.fLegend.c_str(), "f");
    DrawH1(d.fH, kLinear, kLinear, (h0 == nullptr) ? "hist" : "hist,same", d.fLineColor, d.fLineWidth, 0);
    if (h0 == nullptr) h0 = d.fH;
  }
 
  leg->SetFillColor(kWhite);
  leg->Draw();
  gPad->SetLogy(true);
}
 
void LmvmDrawAll::DrawMomRecoPrecision()
{
  string cName = "PrecisionReco/";
 
  // Minv
  fHMean.fHM.CreateCanvas(cName + "Minv", cName + "Minv", 800, 800);
  TH2D* minv = fHMean.H2Clone("hRecoPrec_Minv");
  minv->GetZaxis()->SetRangeUser(1e-15, 1e-3);
  DrawH2(minv, kLinear, kLinear, kLog, "colz");
 
 
  //TODO: do next histograms as projections from 2D histograms
  // Draw ratio P_rec/P_MC
  /*{
    for (const string cat : {"", "_zoom"}) {
      TCanvas* c   = fHMean.fHM.CreateCanvas(cName + "Mom_steps" + cat, cName + "Mom_steps" + cat, 1800, 1800);
      c->Divide(3, 3);
      int i = 1;
      for (auto step : fHMean.fAnaSteps) {
        if (step < ELmvmAnaStep::ElId) continue;
        vector<TH1*> hists;
        vector<string> legend;
        c->cd(i++);
        for (size_t iP = 0; iP < fHMean.fCandNames.size(); iP++) {
          TH1D* h = fHMean.H1Clone("hMomRatio_" + fHMean.fCandNames[iP], step);
          if (cat == "_zoom") h->GetXaxis()->SetRangeUser(0.9, 1.1);
          hists.push_back(h);
          legend.push_back((fHMean.fCandLatex[iP]).c_str());
        }
        DrawH1(hists, legend, kLinear, kLog, true, 0.8, 0.65, 0.99, 0.99, "hist");
        fHMean.DrawAnaStepOnPad(step);
      }
    }
  }*/
 
  // draw ratio P_rec/P_MC vs P
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    double min        = 0.5;
    double max        = 1.5;
 
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Mom_cands", cName + "Mom_cands", 2700, 1800);
    c->Divide(4, 3);
    int i = 1;
    for (auto ptcl : fHMean.fCandNames) {
      int iL = i - 1;
      c->cd(i++);
      string hName = "hRecoPrec_Mom_" + ptcl;
      TH2D* h      = fHMean.H2Clone(hName.c_str(), step);
      h->GetYaxis()->SetRangeUser(min, max);
      h->GetZaxis()->SetRangeUser(1e-10, 1e-2);
      DrawH2(h, kLinear, kLinear, kLog, "colz");
      string text = fHMean.fCandLatex[iL] + ", " + fHMean.fAnaStepLatex[static_cast<int>(step)];
      DrawTextOnPad(text.c_str(), 0.25, 0.9, 0.75, 0.999);
    }
 
    TCanvas* c2 = fHMean.fHM.CreateCanvas(cName + "Mom_ID", cName + "Mom_ID", 1800, 900);
    c2->Divide(2, 1);
    c2->cd(1);
    TH2D* hT = fHMean.H2Clone("hRecoPrec_Mom_ID_true");
    hT->GetYaxis()->SetRangeUser(0.7, 1.2);
    hT->GetZaxis()->SetRangeUser(1e-10, 1e-2);
    DrawH2(hT, kLinear, kLinear, kLog, "colz");
    DrawTextOnPad("True ID", 0.25, 0.9, 0.75, 0.999);
    c2->cd(2);
    TH2D* hM = fHMean.H2Clone("hRecoPrec_Mom_ID_misid");
    hM->GetYaxis()->SetRangeUser(0.7, 1.2);
    hM->GetZaxis()->SetRangeUser(1e-10, 1e-2);
    DrawH2(hM, kLinear, kLinear, kLog, "colz");
    DrawTextOnPad("Mis-ID", 0.25, 0.9, 0.75, 0.999);
  }
}
 
void LmvmDrawAll::DrawMinvOfficialStyle()
{
  int nofInmed  = H(ELmvmSignal::Inmed)->H1("hEventNumber")->GetEntries();
  int nofQgp    = H(ELmvmSignal::Qgp)->H1("hEventNumber")->GetEntries();
  int nofOmega  = H(ELmvmSignal::Omega)->H1("hEventNumber")->GetEntries();
  int nofOmegaD = H(ELmvmSignal::OmegaD)->H1("hEventNumber")->GetEntries();
  int nofPhi    = H(ELmvmSignal::Phi)->H1("hEventNumber")->GetEntries();
 
  for (auto step : fHMean.fAnaSteps) {
    if (step < ELmvmAnaStep::ElId) continue;
    TH1D* h_npm   = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPM_sameEv", step), fNofSimEvents, fBwVarBg2);
    TH1D* h_cb    = VaryBinWidth("mean", fHMean.GetName("hCbBg", step),
                              fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg2);
    TH1D* h_coc   = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fBwVarCock);
    TH1D* h_eta   = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Eta, step), fBwVarReg);
    TH1D* h_pi0   = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Pi0, step), fBwVarReg);
    TH1D* h_inmed = VaryBinWidth("inmed", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), fBwVarReg);
    TH1D* h_qgp   = VaryBinWidth("qgp", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), fBwVarReg);
    TH1D* h_omega = VaryBinWidth("omegaepem", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), fBwVarReg);
    TH1D* h_omegadalitz =
      VaryBinWidth("omegadalitz", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), fBwVarReg);
    TH1D* h_phi = VaryBinWidth("phi", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), fBwVarReg);
    TH1D* h_omega2 =
      VaryBinWidth("omegaepem", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), fBwVarOmega);
    TH1D* h_phi2 = VaryBinWidth("phi", fHMean.GetName("hMinv", ELmvmSrc::Signal, ELmvmAnaStep::ElId), fBwVarPhi);
    h_inmed->Scale(1. / nofInmed);
    h_qgp->Scale(1. / nofQgp);
    h_omega->Scale(1. / nofOmega);
    h_omegadalitz->Scale(1. / nofOmegaD);
    h_phi->Scale(1. / nofPhi);
    h_omega2->Scale(1. / nofOmega);
    h_phi2->Scale(1. / nofPhi);
 
    TH1D* h_sum = (TH1D*) h_eta->Clone();
    h_sum->Add(h_pi0);
    h_sum->Add(h_inmed);
    h_sum->Add(h_qgp);
    h_sum->Add(h_omega);
    h_sum->Add(h_omegadalitz);
    h_sum->Add(h_phi);
 
    TH1D* h_sum2 = (TH1D*) h_sum->Clone();
 
    /*for (int iB = 1; iB <= h_npm->GetXaxis()->GetNbins(); iB++) { // same result as automatically calculated by ROOT
      double bW = h_npm->GetBinWidth(iB);
      double c = h_npm->GetBinContent(iB);
      double n = c * bW * fNofSimEvents; // total entries in bin
      double err = std::sqrt(n)/(fNofSimEvents * bW);
      h_npm->SetBinError(iB, err);
    }*/
 
    fHMean.SetOptH1(h_npm, "#font[52]{M}_{ee} [GeV/#font[52]{c}^{2}]",
                    "1/N_{ev} dN/d#font[52]{M}_{ee} [GeV/#font[52]{c}^{2}]^{-1}", 510, 21, 1.3, kPink, "marker");
    fHMean.SetOptH1(h_cb, "#font[52]{M}_{ee} [GeV/#font[52]{c}^{2}]",
                    "1/N_{ev} dN/d#font[52]{M}_{ee} [GeV/#font[52]{c}^{2}]^{-1}", 510, 22, 1.3, kBlue - 2, "marker");
    fHMean.SetOptH1(h_coc, "#font[52]{M}_{ee} [GeV/#font[52]{c}^{2}]",
                    "1/N_{ev} dN/d#font[52]{M}_{ee} [GeV/#font[52]{c}^{2}]^{-1}", 510, 20, 1.1, kBlack, "marker");
 
    fHMean.SetOptH1(h_sum2, "", "", 510, 1, 1, kBlack, "line");
    fHMean.SetOptH1(h_eta, "", "", 510, 1, 1, kBlue + 2, "line");
    fHMean.SetOptH1(h_pi0, "", "", 510, 1, 1, kAzure - 4, "line");
    fHMean.SetOptH1(h_inmed, "", "", 510, 1, 1, kPink, "line");
    fHMean.SetOptH1(h_qgp, "", "", 510, 1, 1, kOrange, "line");
    fHMean.SetOptH1(h_omega2, "", "", 510, 1, 1, kGreen + 1, "line");
    fHMean.SetOptH1(h_omegadalitz, "", "", 510, 1, 1, kGreen + 3, "line");
    fHMean.SetOptH1(h_phi2, "", "", 510, 1, 1, kMagenta + 2, "line");
 
    h_npm->GetYaxis()->SetRangeUser(1e-9, 10);
 
    string cName = "MinvOfficialStyle/minv_" + fHMean.fAnaStepNames[static_cast<int>(step)];
    TCanvas* can = fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 900, 918);
    fHMean.SetOptCanvas(can);
    can->SetLogy();
    can->cd();
 
    h_npm->Draw("peist");
    h_cb->Draw("peistsame");
    h_coc->Draw("phistsame");
 
    h_sum2->Draw("histsame");
    h_eta->Draw("histsame");
    h_pi0->Draw("histsame");
    h_inmed->Draw("histsame");
    h_qgp->Draw("histsame");
    h_omega2->Draw("histsame");
    h_omegadalitz->Draw("histsame");
    h_phi2->Draw("histsame");
 
    vector<LmvmLegend> legend3;
    legend3.emplace_back(h_npm, "N^{#pm}_{same}", "p");
    legend3.emplace_back(h_cb, "CB_{calc}", "p");
    legend3.emplace_back(h_coc, "MC Cocktail", "p");
 
    vector<LmvmLegend> legend8;
    legend8.emplace_back(h_sum2, "MC Cocktail", "l");
    legend8.emplace_back(h_eta, "#eta#rightarrow#gammae^{+}e^{-}", "l");
    legend8.emplace_back(h_pi0, "#pi^{0}#rightarrow#gammae^{+}e^{-}", "l");
    legend8.emplace_back(h_omegadalitz, "#omega#rightarrow#pi^{0}e^{+}e^{-}", "l");
    legend8.emplace_back(h_omega2, "#omega#rightarrowe^{+}e^{-}", "l");
    legend8.emplace_back(h_phi2, "#phi#rightarrowe^{+}e^{-}", "l");
    legend8.emplace_back(h_inmed, "Rapp in-medium SF", "l");
    legend8.emplace_back(h_qgp, "Rapp QGP", "l");
 
    fHMean.SetLegend(legend3, 0.035, 0.37, 0.64, 0.57, 0.77);
    fHMean.SetLegend(legend8, 0.025, 0.66, 0.57, 0.82, 0.87);
    fHMean.DrawSimDataLabel(0.15, 1.8);
  }  // steps
}
 
void LmvmDrawAll::DrawBackground()
{
  string cName = "Background/";
 
  // Compare "hMinv_bg" with "hMinvPM_sameEv"
  {
    TH1D* pm1   = VaryBinWidth("mean", "hMinv_bg_elid", fBwVarBg);
    TH1D* pm2   = VaryBinWidth("mean", "hMinvPM_sameEv", fBwVarBg);
    TH1D* gamma = VaryBinWidth("mean", "hMinv_gamma_elid", fBwVarBg);
    pm1->Add(VaryBinWidth("cocktail_elid", "", fBwVarBg));
    pm1->Add(gamma);
    TH1D* rat = (TH1D*) pm2->Clone();
    rat->Divide(pm1);
    string cNameFull = cName + "McBg_vs_McPM";
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({pm1, pm2}, {"hMinv_bg + Coc + #gamma", "hMinvPM"}, kLinear, kLog, true, 0.6, 0.8, 0.91, 0.91, "hist");
    c->cd(2);
    DrawH1(rat, kLinear, kLinear, "hist");
  }
 
  // Background Types (BRE, CBcalc, MC) for different categories
  for (const string cat : {"", "_trueEl"}) {  //, "_urqmdAll", "_urqmdEl"}) {
    string cNameFull = cName + "Types/Backgrounds" + cat;
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 2400, 800);
    c->Divide(3, 1);
    int iC = 1;
    for (auto step : fHMean.fAnaStepsFS) {
      string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
      TH1D* mc        = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat + "_bg", step), fNofSimEvents, fBwVarSig);
      TH1D* cb        = VaryBinWidth("mean", fHMean.GetName("hCbBg" + cat, step),
                              fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarSig);
      TH1D* re        = VaryBinWidth("fastsim", "hfsc_MinvBg" + cat + "_" + stepname, fNofFastSimEvents, fBwVarSig);
      mc->GetYaxis()->SetRangeUser(1e-7, 1e-2);
      c->cd(iC++);
      DrawH1({mc, cb, re}, {"B_{MC}", "CB_{calc}", "B_{FS}"}, kLinear, kLog, true, 0.8, 0.76, 0.91, 0.93, "pe");
      fHMean.DrawAnaStepOnPad(step);
    }
  }
 
  // Ratios of Background Types
  vector<pair<double, double>> varbinZoom = {make_pair(2.5, 0.02)};
  for (const string cat : {""}) {  //"_trueEl", "_urqmdAll", "_urqmdEl"}) {
    string cNameFull = cName + "Types/Ratios" + cat;
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 3200, 2400);
    c->Divide(4, 3);
    int iC = 1;
    for (auto step : fHMean.fAnaStepsFS) {
      string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
      if (step != ELmvmAnaStep::ElId) continue;
      TH1D* mc     = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat + "_bg", step), fNofSimEvents, fBwVarBg);
      TH1D* cb     = VaryBinWidth("mean", fHMean.GetName("hCbBg" + cat, step),
                              fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
      TH1D* re     = VaryBinWidth("fastsim", "hfsc_MinvBg" + cat, step, fNofFastSimEvents, fBwVarBg);
      TH1D* mcZoom = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat + "_bg", step), fNofSimEvents, varbinZoom);
      TH1D* cbZoom = VaryBinWidth("mean", fHMean.GetName("hCbBg" + cat, step),
                                  fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), varbinZoom);
      TH1D* reZoom = VaryBinWidth("fastsim", "hfsc_MinvBg" + cat, step, fNofFastSimEvents, varbinZoom);
      mcZoom->GetXaxis()->SetRangeUser(0., 0.5);
      cbZoom->GetXaxis()->SetRangeUser(0., 0.5);
      reZoom->GetXaxis()->SetRangeUser(0., 0.5);
      TH1D* remc = (TH1D*) re->Clone();
      TH1D* cbmc = (TH1D*) cb->Clone();
      TH1D* cbre = (TH1D*) cb->Clone();
      remc->Divide(mc);
      cbmc->Divide(mc);
      cbre->Divide(re);
      /*for (int iB = 1; iB <= mc->GetNbinsX(); iB++) {
        double bW = mc->GetBinWidth(iB);
        double contmc = mc->GetBinContent(iB) * bW * fNofSimEvents;
        double contre = re->GetBinContent(iB) * bW * fNofFastSimEvents;
        double contcb = cb->GetBinContent(iB) * bW * fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]);
        double errMc = std::sqrt(contmc);
        double errRe = std::sqrt(contre);
        double errCb = std::sqrt(contcb);
        double errReMc = std::sqrt(std::pow(errRe/contmc, 2)/(bW*fNofFastSimEvents) + std::pow(contre * errMc / (contmc * contmc), 2)/(bW*fNofSimEvents));
        double errCbMc = std::sqrt(std::pow(errCb/contmc, 2)/(bW * fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)])) + std::pow(contcb * errMc / (contmc * contmc), 2)/(bW*fNofSimEvents));
        double errReCb = std::sqrt(std::pow(errRe/contcb, 2)/(bW*fNofFastSimEvents) + std::pow(contre * errCb / (contcb * contcb), 2))/(bW * fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]));
        remc->SetBinError(iB, errReMc);
        cbmc->SetBinError(iB, errCbMc);
        cbre->SetBinError(iB, errReCb);
      }*/
      //TH1D* remc = CalculateHistRatioWithErrors(re, mc, fNofFastSimEvents, fNofSimEvents);
      //TH1D* cbmc = CalculateHistRatioWithErrors(cb, mc, fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fNofSimEvents);
      //TH1D* cbre = CalculateHistRatioWithErrors(cb, re, fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fNofFastSimEvents);
      remc->GetYaxis()->SetTitle("Ratio");
      cbre->GetYaxis()->SetTitle("Ratio");
      remc->GetYaxis()->SetRangeUser(0.5, 2.);
      cbmc->GetYaxis()->SetRangeUser(0.5, 2.);
      cbre->GetYaxis()->SetRangeUser(0.8, 1.2);
      mc->GetYaxis()->SetRangeUser(1e-7, 1e-2);
 
      c->cd(iC++);
      DrawH1({mc, re, cb}, {"B_{MC}", "B_{FS}", "CB_{calc}"}, kLinear, kLog, true, 0.78, 0.76, 0.95, 0.93, "pe");
      fHMean.DrawAnaStepOnPad(step);
      c->cd(iC++);
      //DrawH1({mcZoom, reZoom, cbZoom}, {"B_{MC}", "B_{FS}", "CB_{calc}"}, kLinear, kLog, true, 0.78, 0.76, 0.95, 0.93, "pe");
      DrawH1({reZoom, cbZoom}, {"B_{FS}", "CB_{calc}"}, kLinear, kLog, true, 0.78, 0.82, 0.95, 0.93, "pe");
      fHMean.DrawAnaStepOnPad(step);
      c->cd(iC++);
      DrawH1({cbmc, remc}, {"CB_{calc} / B_{MC}", "B_{FS} / B_{MC}"}, kLinear, kLinear, true, 0.7, 0.75, 0.95, 0.9,
             "pe");
      fHMean.DrawAnaStepOnPad(step);
      c->cd(iC++);
      DrawH1({cbre}, {"CB_{calc} / B_{FS}"}, kLinear, kLinear, true, 0.65, 0.82, 0.95, 0.9, "pe");
      fHMean.DrawAnaStepOnPad(step);
    }
  }
 
  // Combinatorial Backgrounds from Simulation and Fast Simulations
  {
    TH1D* cbsim = VaryBinWidth(
      "mean", "hCbBg_elid", fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(ELmvmAnaStep::ElId)]), fBwVarBg);
    TH1D* ksim = VaryBinWidth(
      "mean", "hCbK_elid", fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(ELmvmAnaStep::ElId)]), fBwVarBg);
    TH1D* cbre = VaryBinWidth("mean", "hReCb", fNofFastSimEvents, fBwVarBg);
    TH1D* kre  = VaryBinWidth("mean", "hReCbK", fNofFastSimEvents, fBwVarBg);
    TH1D* rat  = (TH1D*) cbre->Clone();
    rat->Divide(cbsim);
    ksim->GetYaxis()->SetTitle("#it{k} Factor");
    rat->GetYaxis()->SetTitle("Ratio");
    string cNameFull = cName + "Types/CombinatorialBackground";
    TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 2400, 800);
    c->Divide(3, 1);
    c->cd(1);
    DrawH1({cbsim, cbre}, {"Simulation", "Fast Simulations"}, kLinear, kLog, true, 0.65, 0.8, 0.92, 0.92, "hist");
    DrawTextOnPad("Combinatorial Background", 0.2, 0.9, 0.8, 0.99);
    c->cd(2);
    DrawH1({ksim, kre}, {"Simulation", "Fast Simulations"}, kLinear, kLinear, true, 0.65, 0.8, 0.92, 0.92, "hist");
    DrawTextOnPad("#it{k} Factor", 0.3, 0.9, 0.7, 0.99);
    c->cd(3);
    DrawH1({rat}, {"CB_{calc, RE} / CB_{calc, Sim}"}, kLinear, kLinear, true, 0.65, 0.82, 0.92, 0.92, "hist");
    DrawTextOnPad("Ratio Combinatorial Backgrounds", 0.2, 0.9, 0.85, 0.99);
  }
 
  // Compare Pair Yields (from MC, CBcalc, BRE)
  {
    ELmvmAnaStep step                   = ELmvmAnaStep::ElId;
    string stepname                     = fHMean.fAnaStepNames[static_cast<int>(step)];
    vector<pair<double, double>> varbin = {make_pair(1.6, 0.2), make_pair(2.0, 0.4), make_pair(2.5, 0.5)};
    for (const string ev : {"sameEv", "mixedEv"}) {
      string cNameFull = cName + "Types/PairYields_" + ev;
      TCanvas* c       = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 2400, 2400);
      int iC           = 1;
      c->Divide(3, 3);
      for (const string comb : {"PM", "PP", "MM"}) {
        TH1D* mc   = VaryBinWidth("mean", "hMinv" + comb + "_" + ev, fNofSimEvents, varbin);
        TH1D* re   = VaryBinWidth("fastsim", "hfsc_Minv" + comb + "_" + ev + "_" + stepname, fNofFastSimEvents, varbin);
        TH1D* cb   = VaryBinWidth("evmix", "hmx_Minv" + comb + "_" + ev + "_" + stepname, fNofEvMixEvents, varbin);
        TH1D* remc = (TH1D*) re->Clone();
        TH1D* cbmc = (TH1D*) cb->Clone();
        TH1D* cbre = (TH1D*) cb->Clone();
        remc->Divide(mc);
        cbmc->Divide(mc);
        cbre->Divide(re);
        remc->GetYaxis()->SetTitle("Ratio");
        cbre->GetYaxis()->SetTitle("Ratio");
        mc->GetYaxis()->SetRangeUser(1e-7, 1e-2);
        remc->GetYaxis()->SetRangeUser(0.0, 2.);
        string combMode = (comb == "PP") ? "e^{+}e^{+}" : (comb == "MM") ? "e^{-}e^{-}" : "e^{+}e^{-}";
        string label    = combMode + " (" + ev + ")";
        c->cd(iC++);
        DrawH1({mc, re, cb}, {"MC Simulation", "Fast Simulations", "Comb. BG Procedure"}, kLinear, kLog, true, 0.6, 0.7,
               0.91, 0.91, "pe");
        DrawTextOnPad(label, 0.25, 0.9, 0.72, 0.99);
        c->cd(iC++);
        DrawH1({remc, cbmc}, {"Fast Simulations / MC Simulation", "Comb. BG Procedure / MC Simulation"}, kLinear,
               kLinear, true, 0.55, 0.75, 0.92, 0.92, "hist");
        DrawTextOnPad(label, 0.25, 0.9, 0.72, 0.99);
        c->cd(iC++);
        DrawH1({cbre}, {"Comb. BG Procedure / Fast Sim."}, kLinear, kLinear, true, 0.5, 0.82, 0.95, 0.9, "hist");
        DrawTextOnPad(label, 0.25, 0.9, 0.72, 0.99);
      }
      // Geometric Mean
      TH1D* gmre = VaryBinWidth("mean", "hReCbGeom_" + ev, fNofFastSimEvents, varbin);
      TH1D* gmcb = VaryBinWidth("mean", fHMean.GetName("hCbGeom_" + ev, step), fNofFastSimEvents, varbin);
      TH1D* rat  = (TH1D*) gmre->Clone();
      rat->Divide(gmcb);
      rat->GetYaxis()->SetTitle("Ratio");
      string cNameFull2 = cName + "Types/GeomMean_" + ev;
      TCanvas* c2       = fHMean.fHM.CreateCanvas(cNameFull2, cNameFull2, 1600, 800);
      c2->Divide(2, 1);
      c2->cd(1);
      DrawH1({gmre, gmcb}, {"Fast Simulations", "Comb. BG Procedure"}, kLinear, kLog, true, 0.65, 0.75, 0.95, 0.9,
             "hist");
      DrawTextOnPad("Geometric Mean (" + ev + ")", 0.25, 0.9, 0.75, 0.99);
      c2->cd(2);
      DrawH1({rat}, {"Fast Simulations / Comb. BG Procedure"}, kLinear, kLinear, true, 0.65, 0.82, 0.95, 0.9, "hist");
      DrawTextOnPad("Ratio", 0.35, 0.9, 0.65, 0.99);
    }
  }
 
  // Compare unlike-sign yield (PM) of Fast Sim. with MC, with / without Cocktail
  {
    ELmvmAnaStep step                   = ELmvmAnaStep::ElId;
    string stepname                     = fHMean.fAnaStepNames[static_cast<int>(step)];
    vector<pair<double, double>> varbin = {make_pair(1.6, 0.2), make_pair(2.0, 0.4), make_pair(2.5, 0.5)};
    TH1D* mc = VaryBinWidth("mean", fHMean.GetName("hMinv_bg", step), fNofSimEvents, fBwVarBg);
    //TH1D* mc = VaryBinWidth("mean", "hMinvPM_sameEv", fNofSimEvents, fBwVarBg);
    TH1D* re   = VaryBinWidth("fastsim", "hfsc_MinvBg_" + stepname, fNofFastSimEvents, fBwVarBg);
    TH1D* coc  = VaryBinWidth("cocktail_" + stepname, "", fBwVarBg);
    TH1D* rat1 = (TH1D*) re->Clone();
    TH1D* rat2 = (TH1D*) re->Clone();
    rat2->Add(coc);
    rat1->Divide(mc);
    rat2->Divide(mc);
    fHMean.fHM.CreateCanvas(cName + "Types/PM_wwo-Cocktail", cName + "Types/PM_wwo-Cocktail", 800, 800);
    DrawH1({rat1, rat2}, {"B_{FS}/B_{MC}", "(B_{FS} + Coc)/B_{MC}"}, kLinear, kLog, true, 0.65, 0.75, 0.95, 0.9,
           "hist");
  }
 
  // Compare "MinvBg" with "MinvPM" from Fast Simulations
  {
    TH1D* bg1 = VaryBinWidth("fastsim", "hfsc_MinvPM_sameEv_elid", fNofFastSimEvents, fBwVarBg);
    TH1D* bg2 = VaryBinWidth("fastsim", "hfsc_MinvBg_elid", fNofFastSimEvents, fBwVarBg);
    TH1D* rat = (TH1D*) bg1->Clone();
    rat->Divide(bg2);
    rat->GetYaxis()->SetTitle("Ratio");
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Types/FastSimBgs", cName + "Types/FastSimBgs", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({bg1, bg2}, {"hMinv_bg_elid", "hMinvPM_sameEv"}, kLinear, kLog, true, 0.6, 0.7, 0.95, 0.9, "hist");
    c->cd(2);
    DrawH1(rat, kLinear, kLinear, "hist");
  }
 
  for (auto step : fHMean.fAnaSteps) {
    if (step != ELmvmAnaStep::ElId) continue;
    string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
    //vector<pair<double, double>> varbin = {make_pair(1.1, 0.1), make_pair(1.5, 0.2), make_pair(2.5, 0.5)};
    vector<pair<double, double>> varbin = fBwVarBg2;
 
    // Draw single background contributions
    {
      string hName = "hMinvBgSource2_" + fHMean.fAnaStepNames[static_cast<int>(step)] + "_";
      TH1D* gg     = VaryBinWidth("mean", hName + "gg", varbin);
      TH1D* pipi   = VaryBinWidth("mean", hName + "pipi", varbin);
      TH1D* pi0pi0 = VaryBinWidth("mean", hName + "pi0pi0", varbin);
      TH1D* oo     = VaryBinWidth("mean", hName + "oo", varbin);
      TH1D* gpi    = VaryBinWidth("mean", hName + "gpi", varbin);
      TH1D* gpi0   = VaryBinWidth("mean", hName + "gpi0", varbin);
      TH1D* go     = VaryBinWidth("mean", hName + "go", varbin);
      TH1D* pipi0  = VaryBinWidth("mean", hName + "pipi0", varbin);
      TH1D* pio    = VaryBinWidth("mean", hName + "pio", varbin);
      TH1D* pi0o   = VaryBinWidth("mean", hName + "pi0o", varbin);
 
      vector<LmvmDrawMinvData> drawData;
      drawData.emplace_back(gpi0, kBlack, kBlack, 1, -1, "#gamma - #pi^{0}");
      drawData.emplace_back(pi0pi0, kGray + 1, kGray + 1, 1, -1, "#pi^{0} - #pi^{0}");
      drawData.emplace_back(gg, kCyan + 2, kCyan + 4, 2, -1, "#gamma - #gamma");
      drawData.emplace_back(pipi0, kGreen - 3, kGreen + 3, 2, -1, "#pi^{#pm}_{mis} - #pi^{0}");
      drawData.emplace_back(pi0o, kRed - 4, kRed + 2, 1, -1, "#pi^{0} - o.");
      drawData.emplace_back(gpi, kOrange + 7, kOrange + 4, 2, -1, "#gamma - #pi^{#pm}_{mis}");
      drawData.emplace_back(go, kAzure + 2, kAzure + 3, 2, -1, "#gamma - o.");
      drawData.emplace_back(pipi, kOrange - 2, kOrange - 3, 4, 3112, "#pi^{#pm}_{mis} - #pi^{#pm}_{mis}");
      drawData.emplace_back(pio, kMagenta - 3, kMagenta - 2, 4, 3018, "#pi^{#pm}_{mis} - o.");
      drawData.emplace_back(oo, -1, kRed + 2, 4, -1, "o. - o.");
 
      string cNameFull = cName + "Composition/comp_" + fHMean.fAnaStepNames[static_cast<int>(step)];
      fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 1000, 1000);
 
      TH1D* h0     = nullptr;
      TLegend* leg = new TLegend(0.75, 0.35, 0.92, 0.9);
      for (size_t i = 0; i < drawData.size(); i++) {
        const auto& d = drawData[i];
        d.fH->GetYaxis()->SetLabelSize(0.05);
        d.fH->GetYaxis()->SetRangeUser(2e-7, 3e-3);
        if (d.fFillColor != -1) d.fH->SetFillColor(d.fFillColor);
        if (d.fFillStyle != -1) d.fH->SetFillStyle(d.fFillStyle);
        leg->AddEntry(d.fH, d.fLegend.c_str(), "f");
        DrawH1(d.fH, kLinear, kLinear, (h0 == nullptr) ? "hist" : "hist,same", d.fLineColor, d.fLineWidth, 0);
        if (h0 == nullptr) h0 = d.fH;
      }
 
      leg->SetFillColor(kWhite);
      leg->Draw();
      fHMean.DrawSimDataLabel(.57, 1.5e-3, 0.03);
      gPad->SetLogy(true);
    }
 
    // Draw sum of single contributions
    {
      string hName     = "hMinvBgSource2_" + fHMean.fAnaStepNames[static_cast<int>(step)] + "_";
      string cNameFull = cName + "Composition/sum_" + fHMean.fAnaStepNames[static_cast<int>(step)];
 
      TH1D* physBg = fHMean.H1Clone(hName + "gg");
      physBg->Add(fHMean.H1(hName + "gpi0"));
      physBg->Add(fHMean.H1(hName + "pi0pi0"));
 
      TH1D* cPi = fHMean.H1Clone(hName + "pipi");
      cPi->Add(fHMean.H1Clone(hName + "gpi"));
      cPi->Add(fHMean.H1Clone(hName + "pipi0"));
      cPi->Add(fHMean.H1Clone(hName + "pio"));
 
      TH1D* rest = fHMean.H1Clone(hName + "oo");
      rest->Add(fHMean.H1Clone(hName + "go"));
      rest->Add(fHMean.H1Clone(hName + "pi0o"));
 
      TH1D* physBg2 = VaryBinWidth(physBg, fBwVarBg2);
      TH1D* cPi2    = VaryBinWidth(cPi, fBwVarBg2);
      TH1D* rest2   = VaryBinWidth(rest, fBwVarBg2);
      physBg2->GetYaxis()->SetRangeUser(1e-7, 1e-2);
 
      fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 1000, 1000);
      DrawH1({physBg2, cPi2, rest2}, {"Phys. BG", "BG w. misid. #pi^{#pm}", "Rest"}, kLinear, kLog, true, 0.7, 0.8,
             0.95, 0.91, "h");
      fHMean.DrawSimDataLabel(.15, 2.7e-7, 0.03);
 
      //check if all bg pair combinations are considered
      if (step == ELmvmAnaStep::ElId || step == ELmvmAnaStep::GammaCut) {
        TH1D* bgRat = static_cast<TH1D*>(physBg2->Clone());
        bgRat->Add(cPi2);
        bgRat->Add(rest2);
 
        TH1D* bg = fHMean.H1Clone("hMinv", ELmvmSrc::Bg, step);
        bg->Add(fHMean.H1("hMinv", ELmvmSrc::Gamma, step), -1.);
        TH1D* bg2 = VaryBinWidth(bg, fBwVarBg);
 
        int nBins = bgRat->GetNbinsX();
        for (int i = 1; i <= nBins; i++) {
          if (bgRat->GetBinContent(i) == 0)
            bgRat->SetBinContent(i, 2);
          else {
            double r = bgRat->GetBinContent(i) / bg2->GetBinContent(i);
            bgRat->SetBinContent(i, r);
          }
        }
 
        bgRat->SetMinimum(0.95);
        bgRat->SetMaximum(1.05);
 
        string cNameFull2 = cName + "Composition/Ratio_" + fHMean.fAnaStepNames[static_cast<int>(step)];
        fHMean.fHM.CreateCanvas(cNameFull2, cNameFull2, 800, 800);
        DrawH1(bgRat, kLinear, kLinear, "hist");
      }
    }
  }  //step loop
 
  // Symmetry of misidentifications
  /*for (const string histo : {"hMinv", "hMinvCombPM_same"}) {
    TH1D* tt = VaryBinWidth("mean", histo + "_tt", fBwVarBg);
    TH1D* tm = VaryBinWidth("mean", histo + "_tm", fBwVarBg);
    TH1D* mt = VaryBinWidth("mean", histo + "_mt", fBwVarBg);
    TH1D* mm = VaryBinWidth("mean", histo + "_mm", fBwVarBg);
    TH1D* bg = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Bg, ELmvmAnaStep::ElId), fBwVarBg);
    TH1D* coc = VaryBinWidth("cocktail_elid", "", fBwVarBg);
    TH1D* gamma = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Gamma,  ELmvmAnaStep::ElId), fBwVarBg);
 
    string legText  = "#sum ee_{i} / B_{MC}";
    TH1D* sum;
    //sum->Sumw2();
    sum = (TH1D*) tt->Clone();
    sum->Add(tm);
    sum->Add(mt);
    sum->Add(mm);
    if (histo == "hMinvCombPM_same") {
      sum->Add(coc, -1.);
      sum->Add(gamma, -1.);
      legText = "#(){ #(){ #sum ee_{i} } - coc - #gamma} / B_{MC}";
    }
 
    TH1D* ratio = (TH1D*) sum->Clone();
    ratio->Divide(bg);
    ratio->GetYaxis()->SetTitle("Ratio");
 
    tt->GetYaxis()->SetRangeUser(1e-6, 5e-3);
    ratio->GetYaxis()->SetRangeUser(0., 2.);
    string cNameFull = cName + "Misid-Symm/" + histo;
    TCanvas* c = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({tt, tm, mt, mm}, {"e^{+}_{true} e^{-}_{true}", "e^{+}_{true} e^{-}_{mis.}", "e^{+}_{mis.} e^{-}_{true}", "e^{+}_{mis.} e^{-}_{mis.}"}, kLinear, kLog, true, 0.78, 0.75, 0.95, 0.91, "hist");
    fHMean.DrawAnaStepOnPad(ELmvmAnaStep::ElId);
    c->cd(2);
    DrawH1({ratio}, {legText}, kLinear, kLinear, true, 0.6, 0.8, 0.95, 0.91, "p");
  }*/
 
  // Draw Background Pair PDGs seperate for diff. minv regions
  {
    TLine* lineH = new TLine(0., 4., 4., 4.);
    TLine* lineV = new TLine(4., 0., 4., 4.);
    lineH->SetLineWidth(6.);
    lineV->SetLineWidth(6.);
    for (const string type : {"pRec"}) {                           // "pMc",
      vector<double> v_pm, v_pp, v_mm, v_pm_el, v_pp_el, v_mm_el;  // for charge symmetries
      for (const string comb : {"PM", "PP", "MM"}) {
        for (int iMinv = 0; iMinv <= 24; iMinv++) {
          string hName = "hBgPairPdg" + comb + "_" + type + "_" + Cbm::NumberToString(iMinv, 0);
          string text  = Cbm::NumberToString(100 * iMinv, 0) + " #leq m_{inv} < "
                        + Cbm::NumberToString(100 * (iMinv + 1), 0) + " MeV/c^{2} (ID)";
          TH2D* h = fHMean.H2Clone(hName);
          h->GetZaxis()->SetRangeUser(1e-15, 1e-3);
          vector<string> label = {"e_{signal}",      "e_{#pi^{0}}", "e_{#gamma}", "e_{o.}",
                                  "#pi^{#pm}_{mis}", "proton",      "kaon",       "other"};
          for (size_t y = 1; y <= label.size(); y++) {
            h->GetXaxis()->SetBinLabel(y, label[y - 1].c_str());
            h->GetYaxis()->SetBinLabel(y, label[y - 1].c_str());
          }
          double I     = h->Integral(1, h->GetNbinsX(), 1, h->GetNbinsX());
          double ITrue = h->Integral(1, 4, 1, 4);
          if (comb == "PM") {
            v_pm.push_back(I);
            v_pm_el.push_back(ITrue);
          }
          else if (comb == "PP") {
            v_pp.push_back(I);
            v_pp_el.push_back(ITrue);
          }
          else if (comb == "MM") {
            v_mm.push_back(I);
            v_mm_el.push_back(ITrue);
          }
          string xTitle = "PDG +";
          string yTitle = "PDG -";
          if (comb == "PP") yTitle = "PDG +";
          if (comb == "MM") xTitle = "PDG -";
          h->GetXaxis()->SetTitle(xTitle.c_str());
          h->GetYaxis()->SetTitle(yTitle.c_str());
          string cNameFull = cName + "PairPdg/" + type + "/" + comb + "/" + Cbm::NumberToString(iMinv, 0);
          fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 900, 600);
          DrawH2(h, kLinear, kLinear, kLog, "colz");
          DrawTextOnPad(text, 0.05, 0.9, 0.7, 0.99);
          DrawTextOnPad("I = " + Cbm::NumberToString(I, 2) + " / Event", 0.12, 0.8, 0.5, 0.89);
          DrawTextOnPad("I_{true} = " + Cbm::NumberToString(ITrue, 2) + " / Event", 0.15, 0.42, 0.43, 0.51);
          lineH->Draw();
          lineV->Draw();
        }
      }
      LOG(warn) << "PairYieldSymmetry: Check Calculation of Symmetry Ratios!!!";
      // Histograms for charge symmetries
      TH1D* hSymm_ppmm = new TH1D(("hSymm_ppmm_" + type).c_str(), "hSymm_ppmm; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
      TH1D* hSymm_pppm = new TH1D(("hSymm_pppm_" + type).c_str(), "hSymm_pppm; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
      TH1D* hSymm_mmpm = new TH1D(("hSymm_mmpm_" + type).c_str(), "hSymm_mmpm; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
      TH1D* hSymm_ppmm_el =
        new TH1D(("hSymm_ppmm_" + type + "_el").c_str(), "hSymm_ppmm_el; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
      TH1D* hSymm_pppm_el =
        new TH1D(("hSymm_pppm_" + type + "_el").c_str(), "hSymm_pppm_el; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
      TH1D* hSymm_mmpm_el =
        new TH1D(("hSymm_mmpm_" + type + "_el").c_str(), "hSymm_mmpm_el; M_{ee} [GeV/c^{2}]; Ratio", 25, 0., 2.5);
      for (int iB = 1; iB <= hSymm_ppmm->GetNbinsX(); iB++) {
        double ppmm   = v_pp[iB - 1] / v_mm[iB - 1];
        double pppm   = v_pp[iB - 1] / v_pm[iB - 1];
        double mmpm   = v_mm[iB - 1] / v_pm[iB - 1];
        double ppmmEl = v_pp_el[iB - 1] / v_mm_el[iB - 1];
        double pppmEl = v_pp_el[iB - 1] / v_pm_el[iB - 1];
        double mmpmEl = v_mm_el[iB - 1] / v_pm_el[iB - 1];
        //LOG(info) << "all: iB = " << iB << ", pm = " << v_pm[iB-1] << ", pp = " << v_pp[iB-1] << ", mm = " << v_mm[iB-1] << ", pp/mm = " << ppmm << ", pp/pm = " << pppm << ", mm/pm = " << mmpm;
        hSymm_ppmm->SetBinContent(iB, ppmm);
        hSymm_pppm->SetBinContent(iB, pppm);
        hSymm_mmpm->SetBinContent(iB, mmpm);
        hSymm_ppmm_el->SetBinContent(iB, ppmmEl);
        hSymm_pppm_el->SetBinContent(iB, pppmEl);
        hSymm_mmpm_el->SetBinContent(iB, mmpmEl);
      }
      vector<pair<double, double>> varbin = fBwVarBg5;
      TH1D* hSymm_ppmm2                   = VaryBinWidth(hSymm_ppmm, varbin);
      TH1D* hSymm_pppm2                   = VaryBinWidth(hSymm_pppm, varbin);
      TH1D* hSymm_mmpm2                   = VaryBinWidth(hSymm_mmpm, varbin);
      TH1D* hSymm_ppmm_el2                = VaryBinWidth(hSymm_ppmm_el, varbin);
      TH1D* hSymm_pppm_el2                = VaryBinWidth(hSymm_pppm_el, varbin);
      TH1D* hSymm_mmpm_el2                = VaryBinWidth(hSymm_mmpm_el, varbin);
      hSymm_ppmm2->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_pppm2->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_mmpm2->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_ppmm_el2->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_pppm_el2->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_mmpm_el2->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_ppmm->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_pppm->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_mmpm->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_ppmm_el->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_pppm_el->GetYaxis()->SetRangeUser(0., 1.2);
      hSymm_mmpm_el->GetYaxis()->SetRangeUser(0., 1.2);
      string cNameSymm = cName + "PairPdg/ChargeSymmetries_" + type;
      TCanvas* c       = fHMean.fHM.CreateCanvas(cNameSymm, cNameSymm, 1600, 800);
      c->Divide(2, 1);
      c->cd(1);
      DrawH1({hSymm_ppmm2, hSymm_pppm2, hSymm_mmpm2}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, 0.72, 0.7,
             0.91, 0.91, "hist");
      DrawTextOnPad("Charge Symmetries (all)", 0.1, 0.9, 0.8, 0.99);
      c->cd(2);
      DrawH1({hSymm_ppmm_el2, hSymm_pppm_el2, hSymm_mmpm_el2}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true,
             0.72, 0.7, 0.91, 0.91, "hist");
      DrawTextOnPad("Charge Symmetries (electrons)", 0.05, 0.9, 0.85, 0.99);
 
      TCanvas* ct = fHMean.fHM.CreateCanvas(cNameSymm + "_test", cNameSymm + "_test", 1600, 800);
      ct->Divide(2, 1);
      ct->cd(1);
      DrawH1({hSymm_ppmm, hSymm_pppm, hSymm_mmpm}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, 0.72, 0.7, 0.91,
             0.91, "hist");
      DrawTextOnPad("Charge Symmetries (all)", 0.1, 0.9, 0.8, 0.99);
      ct->cd(2);
      DrawH1({hSymm_ppmm_el, hSymm_pppm_el, hSymm_mmpm_el}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, 0.72,
             0.7, 0.91, 0.91, "hist");
      DrawTextOnPad("Charge Symmetries (electrons)", 0.05, 0.9, 0.85, 0.99);
    }
  }
 
  // Compare Background from all vs. only UrQMD particles
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TH1D* bg          = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Bg, step), fBwVarSig);
    TH1D* bgU         = VaryBinWidth("mean", fHMean.GetName("hMinv_urqmdAll", ELmvmSrc::Bg, step), fBwVarSig);
    TH1D* bgUEl       = VaryBinWidth("mean", fHMean.GetName("hMinv_urqmdEl", ELmvmSrc::Bg, step), fBwVarSig);
    TH1D* rat1        = (TH1D*) bgU->Clone();
    TH1D* rat2        = (TH1D*) bgUEl->Clone();
    rat1->Divide(bg);
    rat2->Divide(bg);
    rat1->GetYaxis()->SetTitle("Ratio");
    rat2->GetYaxis()->SetTitle("Ratio");
    bg->GetYaxis()->SetRangeUser(2e-7, 1e-2);
    rat1->GetYaxis()->SetRangeUser(0., 1.2);
    TCanvas* c = fHMean.fHM.CreateCanvas("Background/Categories", "Background/Categories", 1600, 800);
    c->Divide(2, 1);
    c->cd(1);
    DrawH1({bg, bgU, bgUEl}, {"B_{MC} (all)", "B_{MC} (UrQMD)", "B_{MC} (UrQMD electrons)"}, kLinear, kLog, true, 0.65,
           0.75, 0.91, 0.9, "p");
    c->cd(2);
    DrawH1({rat1, rat2}, {"B_{MC}(UrQMD) / B_{MC}(all)", "B_{MC}(UrQMD-El) / B_{MC}(all)"}, kLinear, kLinear, true,
           0.65, 0.75, 0.91, 0.9, "p");
  }
 
  // Study: Investigate impact of elid cut variation on CB and RE background
  /*bool doBgStudy = true;
  if (doBgStudy) {
    string dir = "/lustre/cbm/users/criesen/data/studies/BG_ReVsCb/";
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
    vector<TH1D*> histsRE, histsCB;
    vector<string> set = {"set8", "set9", "set10", "set11", "set12"}; // "set5"
    for (const string& iSet : set) {
      LmvmHist HMRE, HMCB;
 
      // Fast Simulation Background
      TFile* fileRE = new TFile((dir + "randomevent." + iSet + ".root").c_str());
      HMRE.fHM.ReadFromFile(fileRE);
      double nofFastSimEv = HMRE.H1("hre_EventNumber")->GetEntries();
      HMRE.fHM.ScaleByPattern("hre.*_Minv.*", 1. / nofFastSimEv);
      TH1D* hRe = HMRE.H1Clone("hre_MinvBg_" + stepname);
      histsRE.push_back(hRe);
 
      // Combinatorial Background
      TFile* fileCB = new TFile((dir + "evmix." + iSet + ".root").c_str());
      HMCB.fHM.ReadFromFile(fileCB);
      double fNofEvMixEvents = HMCB.H1("hmx_EventNumber")->GetEntries();
      HMCB.fHM.ScaleByPattern("hmx_Minv.*", 1. / fNofEvMixEvents);
      string hCbName = "hmx_Minv";
      TH1D* pmSame  = HMCB.H1Clone(hCbName + "PM_sameEv", step);
      TH1D* ppSame  = HMCB.H1Clone(hCbName + "PP_sameEv", step);
      TH1D* mmSame  = HMCB.H1Clone(hCbName + "MM_sameEv", step);
      TH1D* pmMixed = HMCB.H1Clone(hCbName + "PM_mixedEv", step);
      TH1D* ppMixed = HMCB.H1Clone(hCbName + "PP_mixedEv", step);
      TH1D* mmMixed = HMCB.H1Clone(hCbName + "MM_mixedEv", step);
      
      // Geometric Mean
      TH1D* hGeomSame = (TH1D*) pmSame->Clone();
      TH1D* hGeomMix  = (TH1D*) pmSame->Clone();
      for (int iB = 1; iB <= hGeomSame->GetNbinsX(); iB++) {
        double cppSame = ppSame->GetBinContent(iB);
        double cmmSame = mmSame->GetBinContent(iB);
        double cSame = std::sqrt(cppSame * cmmSame);
        hGeomSame->SetBinContent(iB, cSame);
        double cppMix = ppMixed->GetBinContent(iB);
        double cmmMix = mmMixed->GetBinContent(iB);
        double cMix = std::sqrt(cppMix * cmmMix);
        hGeomMix->SetBinContent(iB, cMix);
      }
 
      // k Factor
      TH1D* hK = (TH1D*) pmMixed->Clone();
      hK->Divide(hGeomMix);
      hK->Scale(0.5);
 
      // Normalization Range
      int ChangeBin       = pmSame->FindBin(fCbChange);
      int NormRangeMinBin = pmSame->FindBin(fCbNormRangeMin);
      int NormRangeMaxBin = pmSame->FindBin(fCbNormRangeMax);
      double normPPInt = ppSame->Integral(NormRangeMinBin, NormRangeMaxBin) / ppMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
      double normMMInt = mmSame->Integral(NormRangeMinBin, NormRangeMaxBin) / mmMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
 
      // Calculate Combinatorial Background
      TH1D* hCb = (TH1D*) pmSame->Clone();
      for (int iB = 1; iB <= hCb->GetNbinsX(); iB++) {
        double k  = hK->GetBinContent(iB);
        double pp = ppMixed->GetBinContent(iB);
        double mm = mmMixed->GetBinContent(iB);
        double cb = (iB < ChangeBin) ? 2. * k * hGeomSame->GetBinContent(iB) : 2. * k * std::sqrt(normPPInt * pp * normMMInt * mm);
        hCb->SetBinContent(iB, cb);
      }
      histsCB.push_back(hCb);
    }
    
    vector<TH1*> hRatRe, hRatCb, hRatCbRe;
    vector<string> leg;
    for (size_t iH = 1; iH < set.size(); iH++) {
      TH1D* ratRe = histsRE[iH];
      TH1D* ratCb = histsCB[iH];
      ratRe->Divide(histsRE[0]);
      ratCb->Divide(histsCB[0]);
      TH1D* ratRe2 = VaryBinWidth(ratRe, fBwVarRat);
      TH1D* ratCb2 = VaryBinWidth(ratCb, fBwVarRat);
      TH1D* ratCbRe2 = (TH1D*) ratCb2->Clone();
      ratCbRe2->Divide(ratRe2);
      ratRe2->GetYaxis()->SetRangeUser(0.5, 1.);
      ratCb2->GetYaxis()->SetRangeUser(0.5, 1.);
      ratCbRe2->GetYaxis()->SetRangeUser(0.95, 1.0);
      ratCb2->GetYaxis()->SetTitle("Ratio Backgrounds");
      ratRe2->GetYaxis()->SetTitle("Ratio Backgrounds");
      ratCbRe2->GetYaxis()->SetTitle("Ratio Backgrounds");
      hRatRe.push_back(ratRe2);
      hRatCb.push_back(ratCb2);
      hRatCbRe.push_back(ratCbRe2);
      string legtext = set[iH] + "/" + set[0];
      leg.push_back(legtext);
    }
 
    TCanvas* c = fHMean.fHM.CreateCanvas(cName + "Study/CutImpact_all", cName + "Study/CutImpact_all", 2400, 800);
    c->Divide(3, 1);
    c->cd(1);
    DrawH1(hRatCb, leg, kLinear, kLinear, true, 0.75, 0.7, 0.95, 0.92, "hist");
    DrawTextOnPad("Combinatorial Background", 0.15, 0.9, 0.8, 0.99);
    c->cd(2);
    DrawH1(hRatRe, leg, kLinear, kLinear, true, 0.75, 0.7, 0.95, 0.92, "hist");
    DrawTextOnPad("Fast Simulation Background", 0.15, 0.9, 0.8, 0.99);
    c->cd(3);
    DrawH1(hRatCbRe, leg, kLinear, kLinear, true, 0.75, 0.7, 0.95, 0.92, "hist");
    DrawTextOnPad("Background: CB_{calc} / B_{FS}", 0.1, 0.9, 0.73, 0.99);
 
    for (size_t iH = 0; iH < hRatCb.size(); iH++) {
      TH1D* ratCb = (TH1D*) hRatCb[iH]->Clone();
      TH1D* ratRe = (TH1D*) hRatRe[iH]->Clone();
      TH1D* ratCbRe = (TH1D*) ratCb->Clone();
      ratCbRe->Divide(ratRe);
      ratCb->GetYaxis()->SetTitle("Ratio Backgrounds");
      ratCbRe->GetYaxis()->SetRangeUser(0.95, 1.05);
      string cNameFull = cName + "Study/CutImpact_" + set[iH+1] ;
      TCanvas* c2 = fHMean.fHM.CreateCanvas(cNameFull, cNameFull, 800, 1600);
      c2->Divide(1, 2);
      c2->cd(1);
      DrawH1({ratCb, ratRe}, {"Ratio CB_{calc}", "Ratio B_{FS}"}, kLinear, kLinear, true, 0.75, 0.78, 0.95, 0.92, "hist");
      DrawTextOnPad(leg[iH], 0.3, 0.9, 0.7, 0.99);
      c2->cd(2);
      DrawH1(ratCbRe, kLinear, kLinear, "hist");
      DrawTextOnPad(leg[iH], 0.3, 0.9, 0.7, 0.99);
    }
  }*/
}
 
void LmvmDrawAll::DrawMinvPtAll()
{
  for (const ELmvmAnaStep step : fHMean.fAnaSteps) {
    string cName = "MinvPt/" + fHMean.fAnaStepNames[static_cast<int>(step)];
    fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 1000, 1000);
    DrawH2(GetCocktailMinv<TH2D>("hMinvPt", step, false), kLinear, kLinear, kLog, "colz");
  }
}
 
void LmvmDrawAll::DrawCombinatorialBackground()
{
  string folder = "CombinatorialBackground/";
  TH1D* time    = fHEvMix.H1Clone("hmx_time");
  fHMean.fHM.CreateCanvas("CombinatorialBackground/time", "CombinatorialBackground/time", 800, 800);
  DrawH1(time, kLinear, kLinear, "hist");
 
  // Check pair yields with yields from analysis
  {
    vector<int> canvas = {1, 4, 2, 5, 3, 6};
    for (const string evMode : {"sameEv", "mixedEv"}) {
      string cName = folder + "PairYields/CheckWithSim_" + evMode;
      TCanvas* c   = fHMean.fHM.CreateCanvas(cName, cName, 2400, 1600);
      c->Divide(3, 2);
      int iC = 0;
      for (const string comb : {"PM", "PP", "MM"}) {
        TH1D* sim = VaryBinWidth("mean", "hMinv" + comb + "_" + evMode, fBwVarBg5);
        TH1D* cb  = VaryBinWidth("evmix", "hmx_Minv" + comb + "_" + evMode + "_elid", fBwVarBg5);
        TH1D* r   = (TH1D*) cb->Clone();
        r->Divide(sim);
        r->GetYaxis()->SetTitle("Ratio");
        r->GetYaxis()->SetRangeUser(.95, 1.05);
        c->cd(canvas[iC]);
        iC++;
        DrawH1({sim, cb}, {"Simulation", "CB Procedure"}, kLinear, kLog, true, 0.6, 0.7, 0.92, 0.9, "hist");
        DrawTextOnPad(comb, 0.3, 0.9, 0.7, 0.99);
        c->cd(canvas[iC]);
        iC++;
        DrawH1(r, kLinear, kLinear, "hist");
        DrawTextOnPad(comb, 0.3, 0.9, 0.7, 0.99);
      }
    }
  }
 
  // Draw PM, MM, PP in one plot (ID)
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    for (const string cat : {"", "_trueEl"}) {  //, "_urqmdEl", "_urqmdAll"}) {
      for (const string ev : {"sameEv", "mixedEv"}) {
        string cName = folder + "PairYields/AllCombs_" + ev + cat;
        TCanvas* c   = fHMean.fHM.CreateCanvas(cName.c_str(), cName.c_str(), 1600, 800);
        c->Divide(2, 1);
        double nEvents =
          (ev == "sameEv") ? fNofEvMixEvents : fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]);
        vector<pair<double, double>> varbin = fBwVarBg4;
        if (ev == "mixedEv") varbin = fBwVarOrig;
        TH1D* pm   = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPM" + cat + "_" + ev, step), nEvents, varbin);
        TH1D* pp   = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPP" + cat + "_" + ev, step), nEvents, varbin);
        TH1D* mm   = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvMM" + cat + "_" + ev, step), nEvents, varbin);
        TH1D* ppmm = (TH1D*) pp->Clone();
        ppmm->Divide(mm);
        TH1D* pppm = (TH1D*) pp->Clone();
        TH1D* mmpm = (TH1D*) mm->Clone();
        pppm->Divide(pm);
        mmpm->Divide(pm);
        ppmm->GetYaxis()->SetTitle("Ratio");
        ppmm->GetYaxis()->SetRangeUser(0., 1.2);
        c->cd(1);
        DrawH1({pm, pp, mm}, {"e+e-", "e+e+", "e-e-"}, kLinear, kLog, true, 0.8, 0.7, 0.95, 0.9, "pe");
        fHMean.DrawAnaStepOnPad(step);
        DrawTextOnPad("fCbNormFactor = " + Cbm::NumberToString(fCbNormFactor[static_cast<int>(step)], 0), 0.11, 0.15,
                      0.68, 0.25);
        c->cd(2);
        DrawH1({ppmm, pppm, mmpm}, {"++/--", "++/+-", "--/+-"}, kLinear, kLinear, true, 0.77, 0.77, 0.95, 0.95, "pe");
        fHMean.DrawAnaStepOnPad(step);
      }
    }
  }
 
  // Compare like-sign pairs of same and mixed events
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    string stepstr    = fHMean.fAnaStepNames[static_cast<int>(step)];
    for (const string cat : {"", "_trueEl"}) {  //, "_urqmdEl", "_urqmdAll"}) {
      TH1D* ppSame = VaryBinWidth("evmix", "hmx_MinvPP" + cat + "_sameEv_" + stepstr, fNofEvMixEvents, fBwVarBg);
      TH1D* mmSame = VaryBinWidth("evmix", "hmx_MinvMM" + cat + "_sameEv_" + stepstr, fNofEvMixEvents, fBwVarBg);
      TH1D* ppMix  = VaryBinWidth("evmix", "hmx_MinvPP" + cat + "_mixedEv_" + stepstr,
                                 fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
      TH1D* mmMix  = VaryBinWidth("evmix", "hmx_MinvMM" + cat + "_mixedEv_" + stepstr,
                                 fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
 
      int minBin = ppSame->FindBin(fCbNormRangeMin);
      int maxBin = ppSame->FindBin(fCbNormRangeMax);
      double nP  = ppSame->Integral(minBin, maxBin) / ppMix->Integral(minBin, maxBin);
      double nM  = mmSame->Integral(minBin, maxBin) / mmMix->Integral(minBin, maxBin);
      ppMix->Scale(nP);
      mmMix->Scale(nM);
      mmSame->Scale(0.1);
      mmMix->Scale(0.1);
      ppSame->GetYaxis()->SetRangeUser(1e-8, 5e-3);
      TH1D* ppSame2 = (TH1D*) ppSame->Clone();
      TH1D* mmSame2 = (TH1D*) mmSame->Clone();
      TH1D* ppMix2  = (TH1D*) ppMix->Clone();
      TH1D* mmMix2  = (TH1D*) mmMix->Clone();
      ppSame2->GetXaxis()->SetRangeUser(0.3, 1.2);
      mmSame2->GetXaxis()->SetRangeUser(0.3, 1.2);
      ppMix2->GetXaxis()->SetRangeUser(0.3, 1.2);
      mmMix2->GetXaxis()->SetRangeUser(0.3, 1.2);
      ppSame2->GetYaxis()->SetRangeUser(1e-6, 5e-3);
      TCanvas* c = fHMean.fHM.CreateCanvas(folder + "PairYields/Likesign/likesign" + cat,
                                           folder + "PairYields/Likesign/likesign" + cat, 1600, 800);
      c->Divide(2, 1);
      c->cd(1);
      DrawH1({ppSame, ppMix, mmSame, mmMix},
             {"N_{e^{+}e^{+}}^{same}", "N_{e^{+}e^{+}}^{mixed} #upoint n_{+}", "N_{e^{-}e^{-}}^{same} #upoint 0.1",
              "N_{e^{-}e^{-}}^{mixed} #upoint n_{-} #upoint 0.1"},
             kLinear, kLog, true, 0.7, 0.75, 0.95, 0.99, "pe");
      fHMean.DrawAnaStepOnPad(step);
      c->cd(2);
      DrawH1({ppSame2, ppMix2, mmSame2, mmMix2},
             {"N_{e^{+}e^{+}}^{same}", "N_{e^{+}e^{+}}^{mixed} #upoint n_{+}", "N_{e^{-}e^{-}}^{same} #upoint 0.1",
              "N_{e^{-}e^{-}}^{mixed} #upoint n_{-} #upoint 0.1"},
             kLinear, kLog, true, 0.7, 0.75, 0.95, 0.99, "pe");
      fHMean.DrawAnaStepOnPad(step);
      DrawTextOnPad("Norm. Range: " + Cbm::NumberToString(fCbNormRangeMin, 1) + " - "
                      + Cbm::NumberToString(fCbNormRangeMax, 1) + " GeV",
                    0.06, 0.15, 0.55, 0.32);
      DrawTextOnPad("n_{+} = " + Cbm::NumberToString(nP, 3) + ", n_{-} = " + Cbm::NumberToString(nM, 3), 0.06, 0.1,
                    0.56, 0.25);
    }
  }
 
  // Draw MM/PP ratio for same events (steps)
  {
    for (const string cat : {"", "_trueEl"}) {  //, "_urqmdEl", "_urqmdAll"}) {
      TCanvas* c = fHMean.fHM.CreateCanvas(folder + "PairYields/Likesign/Ratio_" + cat,
                                           folder + "PairYields/Likesign/Ratio_" + cat, 1800, 1800);
      c->Divide(3, 3);
      int i = 1;
      for (auto step : fHMean.fAnaSteps) {
        if (step < ELmvmAnaStep::ElId) continue;
        TH1D* pp = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPP" + cat + "_sameEv", step), fBwVarBg3);
        TH1D* mm = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvMM" + cat + "_sameEv", step), fBwVarBg3);
        TH1D* r  = (TH1D*) mm->Clone();
        r->Divide(pp);
        r->GetYaxis()->SetRangeUser(0., 5.);
        r->GetYaxis()->SetTitle("Ratio e^{-}e^{-}/e^{+}e^{+}");
        c->cd(i++);
        DrawH1(r, kLinear, kLinear, "hist");
        fHMean.DrawAnaStepOnPad(step);
      }
    }
  }
 
  // Draw Geometric Mean for same and mixed (mixed normalized)
  {
    for (const string cat : {"", "_trueEl"}) {  //, "_urqmdEl", "_urqmdAll"}) {
      fHMean.fHM.CreateCanvas(folder + "GeometricMean/GeomMean" + cat, folder + "GeometricMean/GeomMean" + cat, 800,
                              800);
      //TCanvas* c   = fHMean.fHM.CreateCanvas(cName + "GeometricMean", cName + "GeometricMean", 1800, 1800);
      //c->Divide(3, 3);
      //int i = 1;
      for (auto step : fHMean.fAnaSteps) {
        if (step != ELmvmAnaStep::ElId) continue;
        //c->cd(i++);
        TH1D* same   = VaryBinWidth("mean", fHMean.GetName("hCbGeom" + cat + "_sameEv", step), fBwVarBg);
        TH1D* mixed  = VaryBinWidth("mean", fHMean.GetName("hCbGeom" + cat + "_mixedEv", step), fBwVarBg);
        int minBin   = same->FindBin(fCbNormRangeMin);
        int maxBin   = same->FindBin(fCbNormRangeMax);
        double scale = same->Integral(minBin, maxBin) / mixed->Integral(minBin, maxBin);
        mixed->Scale(scale);
        same->GetYaxis()->SetRangeUser(1e-7, 5e-3);
        same->GetXaxis()->SetTitle("M_{ee} [GeV/c^{2}]");
        DrawH1({same, mixed}, {"geom. mean (same)", "geom. mean (mixed)"}, kLinear, kLog, true, 0.6, 0.8, 0.99, 0.95,
               "hist");
        fHMean.DrawAnaStepOnPad(step);
        DrawTextOnPad("Factor mixed/same: " + Cbm::NumberToString(1. / scale, 0), 0.12, 0.15, 0.62, 0.35);
      }
    }
  }
 
  // Draw k factor (steps)
  {
    for (const string cat : {"", "_trueEl"}) {  //, "_urqmdEl", "_urqmdAll"}) {
      TCanvas* c =
        fHMean.fHM.CreateCanvas(folder + "/k-Factor/steps" + cat, folder + "/k-Factor/steps" + cat, 2400, 2400);
      c->Divide(3, 3);
      int iC = 1;
      for (ELmvmAnaStep step : fHMean.fAnaSteps) {
        if (step < ELmvmAnaStep::ElId) continue;
        TH1D* k = VaryBinWidth("mean", fHMean.GetName("hCbK_raw" + cat, step),
                               fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
        k->GetYaxis()->SetRangeUser(0.6, 1.4);
        k->GetYaxis()->SetTitle("#it{k} Factor");
        c->cd(iC++);
        DrawH1(k, kLinear, kLinear, "pe");
        fHMean.DrawAnaStepOnPad(step);
      }
    }
  }
 
  // Draw k factor (raw) with its components
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TH1D* k           = VaryBinWidth("mean", fHMean.GetName("hCbK_raw", step), fBwVarBg);
    TH1D* pm          = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPM_mixedEv", step), fBwVarBg);
    TH1D* pp          = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPP_mixedEv", step), fBwVarBg);
    TH1D* mm          = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvMM_mixedEv", step), fBwVarBg);
    TH1D* g           = VaryBinWidth("mean", fHMean.GetName("hCbGeom_mixedEv", step), fBwVarBg);
    TH1D* g2          = (TH1D*) g->Clone();
    g2->Scale(2.);
    TH1D* k2 = (TH1D*) pm->Clone();
    for (int iB = 1; iB <= pm->GetNbinsX(); iB++) {
      double con = pm->GetBinContent(iB) / (2 * std::sqrt(pp->GetBinContent(iB) * mm->GetBinContent(iB)));
      k2->SetBinContent(iB, con);
    }
    k->GetYaxis()->SetTitle("#it{k} Factor");
    k->GetYaxis()->SetRangeUser(0.6, 1.2);
    TCanvas* c = fHMean.fHM.CreateCanvas(folder + "/k-Factor/components", folder + "/k-Factor/components", 2400, 800);
    c->Divide(3, 1);
    c->cd(1);
    DrawH1({pm, pp, mm, g, g2}, {"#LT b^{#pm} #GT", "#LT b^{++} #GT", "#LT b^{--} #GT", "Geom. Mean", "2 * Geom. Mean"},
           kLinear, kLog, true, 0.75, 0.65, 0.99, 0.95, "p");
    fHMean.DrawAnaStepOnPad(step);
    DrawTextOnPad("Mixed Events", 0.12, 0.12, 0.4, 0.25);
    c->cd(2);
    DrawH1({k, k2}, {"k", "k2"}, kLinear, kLinear, true, 0.8, 0.8, 0.9, 0.9, "hist");
    fHMean.DrawAnaStepOnPad(step);
    c->cd(3);
    TH1D* gmean1 = VaryBinWidth("mean", fHMean.GetName("hCbGeom_mixedEv", step), fBwVarBg);
    TH1D* gmean2 = (TH1D*) pm->Clone();
    for (int iB = 1; iB <= gmean2->GetNbinsX(); iB++) {
      double con = std::sqrt(pp->GetBinContent(iB) * mm->GetBinContent(iB));
      gmean2->SetBinContent(iB, con);
    }
    DrawH1({gmean1, gmean2}, {"standard", "calc. new"}, kLinear, kLog, true, 0.75, 0.65, 0.99, 0.95, "p");
    DrawTextOnPad("Geometric Mean (mixed ev.)", 0.2, 0.9, 0.8, 0.99);
  }
 
  // Draw k factor: raw and fitted
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TCanvas* c = fHMean.fHM.CreateCanvas(folder + "/k-Factor/categories", folder + "/k-Factor/categories", 1600, 800);
    c->Divide(2, 1);
    int iC = 1;
    for (const string cat : {"_raw", "_fit"}) {
      TH1D* kAll = VaryBinWidth("mean", fHMean.GetName("hCbK" + cat, step), fBwVarBg);
      //TH1D* kEl   = VaryBinWidth("mean", fHMean.GetName("hCbK" + cat + "_trueEl", step), fBwVarBg);
      //TH1D* kUAll = VaryBinWidth("mean", fHMean.GetName("hCbK_urqmdAll" + cat, step), fBwVarBg);
      //TH1D* kUEl  = VaryBinWidth("mean", fHMean.GetName("hCbK_urqmdEl" + cat, step), fBwVarBg);
      kAll->GetYaxis()->SetTitle("#it{k} Factor");
      kAll->GetYaxis()->SetRangeUser(0.6, 1.2);
      c->cd(iC++);
      //DrawH1({kAll, kEl, kUAll, kUEl}, {"PLUTO + UrQMD", "PLUTO + UrQMD (el)", "UrQMD", "UrQMD (el)"}, kLinear, kLinear, true, 0.65, 0.8, 0.99, 0.95, "p");
      //DrawH1({kAll, kEl}, {"PLUTO + UrQMD", "PLUTO + UrQMD (el)"}, kLinear, kLinear, true, 0.65, 0.8, 0.99, 0.95, "p");
      DrawH1(kAll, kLinear, kLinear, "h");
      fHMean.DrawAnaStepOnPad(step);
    }
  }
 
  // Draw k factor in dependance on various quantities
  {
    // Px, Py
    for (const string cat : {"", "_mother"}) {
      TH2D* pxPM = fHMean.H2Clone("hMinvCombPM_px" + cat);
      TH2D* pxPP = fHMean.H2Clone("hMinvCombPP_px" + cat);
      TH2D* pxMM = fHMean.H2Clone("hMinvCombMM_px" + cat);
      TH2D* pyPM = fHMean.H2Clone("hMinvCombPM_py" + cat);
      TH2D* pyPP = fHMean.H2Clone("hMinvCombPP_py" + cat);
      TH2D* pyMM = fHMean.H2Clone("hMinvCombMM_py" + cat);
      TH2D* kPx  = (TH2D*) pxPM->Clone();
      TH2D* kPy  = (TH2D*) pyPM->Clone();
      for (int iX = 1; iX <= pxPM->GetXaxis()->GetNbins(); iX++) {
        for (int iY = 1; iY <= pxPM->GetYaxis()->GetNbins(); iY++) {
          double kx =
            pxPM->GetBinContent(iX, iY) / (2 * std::sqrt(pxPP->GetBinContent(iX, iY) * pxMM->GetBinContent(iX, iY)));
          double ky =
            pyPM->GetBinContent(iX, iY) / (2 * std::sqrt(pyPP->GetBinContent(iX, iY) * pyMM->GetBinContent(iX, iY)));
          kPx->SetBinContent(iX, iY, kx);
          kPy->SetBinContent(iX, iY, ky);
        }
      }
      kPx->GetZaxis()->SetRangeUser(0., 2.);
      kPy->GetZaxis()->SetRangeUser(0., 2.);
      kPx->GetXaxis()->SetTitle("P_{X_{1}} [GeV/c]");
      kPx->GetYaxis()->SetTitle("P_{X_{2}} [GeV/c]");
      kPy->GetXaxis()->SetTitle("P_{Y_{1}} [GeV/c]");
      kPy->GetYaxis()->SetTitle("P_{Y_{2}} [GeV/c]");
      kPx->GetZaxis()->SetTitle("#it{k} Factor");
      kPy->GetZaxis()->SetTitle("#it{k} Factor");
      TCanvas* cP =
        fHMean.fHM.CreateCanvas(folder + "k-Factor/dep_Pt" + cat, folder + "k-Factor/dep_Pt" + cat, 1600, 800);
      cP->Divide(2, 1);
      cP->cd(1);
      DrawH2(kPx, kLinear, kLinear, kLinear, "colz");
      cP->cd(2);
      DrawH2(kPy, kLinear, kLinear, kLinear, "colz");
 
      // Vertex in X-Y plane
      TH2D* RPM = fHMean.H2Clone("hMinvCombPM_R" + cat);
      TH2D* RPP = fHMean.H2Clone("hMinvCombPP_R" + cat);
      TH2D* RMM = fHMean.H2Clone("hMinvCombMM_R" + cat);
      TH2D* kR  = (TH2D*) RPM->Clone();
      for (int iX = 1; iX <= RPM->GetXaxis()->GetNbins(); iX++) {
        for (int iY = 1; iY <= RPM->GetYaxis()->GetNbins(); iY++) {
          double k =
            RPM->GetBinContent(iX, iY) / (2 * std::sqrt(RPP->GetBinContent(iX, iY) * RMM->GetBinContent(iX, iY)));
          kR->SetBinContent(iX, iY, k);
        }
      }
      kR->GetZaxis()->SetRangeUser(0., 2.);
      kR->GetZaxis()->SetTitle("#it{k} Factor");
      fHMean.fHM.CreateCanvas(folder + "k-Factor/dep_Vertex" + cat, folder + "k-Factor/dep_Vertex" + cat, 800, 800);
      DrawH2(kR, kLinear, kLinear, kLinear, "colz");
    }
 
    // Angle and Minv
    TH2D* aPM    = fHMean.H2Clone("hMinvCombPM_theta-minv");
    TH2D* aPP    = fHMean.H2Clone("hMinvCombPP_theta-minv");
    TH2D* aMM    = fHMean.H2Clone("hMinvCombMM_theta-minv");
    TH2D* kAngle = (TH2D*) aPM->Clone();
    for (int iA = 1; iA <= aPM->GetXaxis()->GetNbins(); iA++) {
      for (int iM = 1; iM <= aPM->GetYaxis()->GetNbins(); iM++) {
        double den = (2 * std::sqrt(aPP->GetBinContent(iA, iM) * aMM->GetBinContent(iA, iM)));
        double k   = (den == 0) ? 0 : aPM->GetBinContent(iA, iM) / den;
        kAngle->SetBinContent(iA, iM, k);
      }
    }
    kAngle->GetZaxis()->SetRangeUser(0., 2.);
    kAngle->GetZaxis()->SetTitle("#it{k} Factor");
    fHMean.fHM.CreateCanvas(folder + "k-Factor/dep_theta-minv", folder + "k-Factor/dep_theta-minv", 800, 800);
    DrawH2(kAngle, kLinear, kLinear, kLinear, "colz");
    kAngle->SetMarkerSize(2.);
  }
 
  // Background: Vs. MC-BG
  {
    for (const string cat : {"", "_trueEl", "_urqmdAll", "_urqmdEl"}) {
      TCanvas* c =
        fHMean.fHM.CreateCanvas(folder + "Background/VsMcBg" + cat, folder + "Background/VsMcBg" + cat, 1600, 2400);
      c->Divide(2, 3);
      int iC = 1;
      for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
        string stepname = fHMean.fAnaStepNames[static_cast<int>(step)];
        TH1D* cbc       = VaryBinWidth("mean", fHMean.GetName("hCbBg" + cat, step),
                                 fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarSig);
        TH1D* mcb       = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat + "_bg", step), fNofSimEvents, fBwVarSig);
        cbc->GetYaxis()->SetRangeUser(1e-7, 2e-2);
        TH1D* r = (TH1D*) cbc->Clone();
        r->Divide(mcb);
        r->GetYaxis()->SetRangeUser(0.5, 1.4);
        r->GetYaxis()->SetTitle("Ratio");
        c->cd(iC++);
        DrawH1({cbc, mcb}, {"CB_{calc}", "B_{MC}"}, kLinear, kLog, true, 0.65, 0.75, 0.95, 0.9, "p");
        fHMean.DrawAnaStepOnPad(step);
        c->cd(2);
        DrawH1({r}, {"CB_{calc} / B_{MC}"}, kLinear, kLinear, true, 0.75, 0.87, 0.95, 0.95, "p");
        fHMean.DrawAnaStepOnPad(step);
      }
    }
  }
 
  // CB for various categories
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
    TH1D* pu          = VaryBinWidth("mean", fHMean.GetName("hCbBg", step),
                            fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
    TH1D* puEl        = VaryBinWidth("mean", fHMean.GetName("hCbBg_trueEl", step),
                              fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
    TH1D* u           = VaryBinWidth("mean", fHMean.GetName("hCbBg_urqmdAll", step),
                           fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
    TH1D* uEl         = VaryBinWidth("mean", fHMean.GetName("hCbBg_urqmdEl", step),
                             fNofEvMixEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
    pu->GetYaxis()->SetRangeUser(1e-7, 1e-2);
    fHMean.fHM.CreateCanvas(folder + "Background/CbTypes", folder + "Background/CbTypes", 800, 800);
    DrawH1({pu, puEl, u, uEl}, {"PLUTO + UrQMD", "PLUTO + UrQMD (electrons)", "UrQMD", "UrQMD (electrons)"}, kLinear,
           kLog, true, 0.55, 0.78, 0.99, 0.95, "pe");
    fHMean.DrawAnaStepOnPad(step);
    DrawTextOnPad("fCbChange = " + Cbm::NumberToString(fCbChange, 0), 0.14, 0.24, 0.33, 0.28);
    DrawTextOnPad("fCbNormRangeMin = " + Cbm::NumberToString(fCbNormRangeMin, 0), 0.12, 0.20, 0.38, 0.24);
    DrawTextOnPad("fCbNormRangeMax = " + Cbm::NumberToString(fCbNormRangeMax, 0), 0.11, 0.16, 0.39, 0.20);
  }
 
  //Draw Combinatorial Signal with N+-same, CB, Cocktail
  {
    for (const string type : {"Mc", "Npm"}) {
      for (const string cat : {""}) {  //, "_trueEl", "_urqmdEl", "_urqmdAll"}) {
        //TCanvas* c = fHMean.fHM.CreateCanvas(folder + "Signal/VsInput_" + type + cat, folder + "Signal/VsInput_" + type + cat, 1800, 1800);
        //c->Divide(3, 3);
        //int i = 1;
        fHMean.fHM.CreateCanvas(folder + "Signal/VsInput" + type + cat, folder + "Signal/VsInput_" + type + cat, 800,
                                800);
        for (auto step : fHMean.fAnaSteps) {
          if (step != ELmvmAnaStep::ElId) continue;
          //c->cd(i++);
          TH1D* sig = VaryBinWidth("mean", fHMean.GetName("hCbSig" + type + cat, step), fBwVarSig);
          TH1D* coc =
            VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", fNofFastSimEvents, fBwVarSig);
          TH1D* npm =
            VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPM" + cat + "_sameEv", step), fNofSimEvents, fBwVarSig);
          for (int iB = 1; iB <= sig->GetNbinsX(); iB++) {
            double bW  = sig->GetBinWidth(iB);
            double N   = npm->GetBinContent(iB) * fNofSimEvents * bW;
            double err = std::sqrt(N) / (bW * fNofSimEvents);
            sig->SetBinError(iB, err);
          }
          sig->GetYaxis()->SetRangeUser(1e-10, 5e-2);
          //string sigLabel = (type == "Npm") ? "Signal = N_{same}^{+-} + Cocktail - CB_{calc}" : "Signal = B_{MC} + Cocktail - CB_{calc}";
          string sigLabel = "Signal";
          //DrawH1({sig, coc}, {sigLabel, "MC Cocktail"}, kLinear, kLog, true, 0.47, 0.77, 0.91, 0.9, "pe");
          DrawH1({sig, coc}, {sigLabel, "MC Cocktail"}, kLinear, kLog, true, 0.65, 0.78, 0.91, 0.91, "pe");
          //fHMean.DrawAnaStepOnPad(step);
        }
      }
    }
  }
 
  // Compare N+-, BG+Coc, BG and CB after ElID step
  {
    ELmvmAnaStep step = ELmvmAnaStep::ElId;
 
    for (const string cat : {"", "_trueEl"}) {
      TH1D* npm = VaryBinWidth("evmix", fHMean.GetName("hmx_MinvPM" + cat + "_sameEv", step), fNofSimEvents, fBwVarBg);
      TH1D* cb  = VaryBinWidth("mean", fHMean.GetName("hCbBg" + cat, step),
                              fNofSimEvents * std::sqrt(fCbNormFactor[static_cast<int>(step)]), fBwVarBg);
      TH1D* bg  = VaryBinWidth("mean", fHMean.GetName("hMinv" + cat, ELmvmSrc::Bg, step), fNofSimEvents, fBwVarBg);
      TH1D* coc = VaryBinWidth("cocktail" + cat + "_" + fHMean.fAnaStepNames[static_cast<int>(step)], "",
                               fNofFastSimEvents, fBwVarBg);
      TH1D* sbg = (TH1D*) bg->Clone();
      sbg->Add(coc);
 
      TH1D* ratS = (TH1D*) npm->Clone();
      TH1D* ratB = (TH1D*) cb->Clone();
      ratS->Divide(sbg);
      ratB->Divide(bg);
 
      TCanvas* c =
        fHMean.fHM.CreateCanvas(folder + "Signal/N+-VsBgCoc" + cat, folder + "Signal/N+-VsBgCoc" + cat, 1800, 900);
      c->Divide(2, 1);
      c->cd(1);
      npm->GetYaxis()->SetRangeUser(1e-9, 2e-2);
      DrawH1({npm, sbg, cb, bg}, {"N^{+-}_{same}", "B_{MC} + Cocktail", "CB_{calc}", "B_{MC}"}, kLinear, kLog, true,
             0.7, 0.7, 0.99, 0.95, "p");
      fHMean.DrawAnaStepOnPad(step);
      c->cd(2);
      ratS->GetYaxis()->SetTitle("Ratio");
      ratS->GetYaxis()->SetRangeUser(0., 2.);
      ratB->GetYaxis()->SetRangeUser(0., 2.);
      DrawH1({ratS, ratB}, {"N^{+-}_{same} / B_{MC}+Coc", "CB_{calc} / B_{MC}"}, kLinear, kLinear, true, 0.7, 0.8, 0.99,
             0.95, "p");
      fHMean.DrawAnaStepOnPad(step);
    }
  }
}
 
void LmvmDrawAll::DrawSBgVsMinv()
{
  vector<TH1*> hists;
  vector<pair<double, double>> varbin = fBwVarSig;
  for (ELmvmAnaStep step : {ELmvmAnaStep::ElId, ELmvmAnaStep::TtCut, ELmvmAnaStep::PtCut}) {
    TH1D* bg  = VaryBinWidth("mean", fHMean.GetName("hMinv", ELmvmSrc::Bg, step), varbin);
    TH1D* cbg = VaryBinWidth("cocktail_" + fHMean.fAnaStepNames[static_cast<int>(step)], "", varbin);
    cbg->Divide(bg);
    cbg->GetYaxis()->SetTitle("Cocktail/Background");
    cbg->GetYaxis()->SetRangeUser(9e-4, 11);
    hists.push_back(cbg);
  }
 
  fHMean.fHM.CreateCanvas("SignalToBg/SignalToBg", "SignalToBg/SignalToBg", 1000, 1000);
  DrawH1(hists, {"El-ID", "TT cut", "P_{t} cut"}, kLinear, kLog, true, 0.62, 0.7, 0.92, 0.92, "hist");
  //DrawH1(hists, {"El-ID"}, kLinear, kLog, true, 0.7, 0.82, 0.92, 0.92, "hist");
}
 
void LmvmDrawAll::LoadFastSimHistos()
{
  // Load and scale histograms from LmvmFastSim  and make them globally available.
  // Histograms from LmvmTask have to be scaled with 'fNofSimEvents' and number of jobs of LmvmFastSim procedure.
  // Histograms that are created and filled in LmvmFastSim procedure have to be scaled with fNofFastSimEvents.
  TFile* fastsimfile = new TFile((fDataDir + "/Background/FastSim/fastsim.all.root").c_str());
  fHFastSim.fHM.ReadFromFile(fastsimfile);
  fNofFastSimEvents = fHFastSim.H1("hfs_EventNumber")->GetEntries();
  LOG(info) << "Nof FastSim Events = " << fNofFastSimEvents;
  fNofFastSimJobs = fHFastSim.H1("hfs_nofJobs")->GetEntries();
  for (ELmvmSignal signal : fHMean.fSignals) {
    int nofEventsSig = (int) fH[static_cast<int>(signal)]->H1("hEventNumber")->GetEntries();
    string sigName   = fHMean.fSignalNames[static_cast<int>(signal)];
    fHFastSim.fHM.ScaleByPattern("(hfsc|hfsp)_mult_pluto_" + sigName + "_.*", 1. / (nofEventsSig * fNofFastSimJobs));
    fHFastSim.fHM.ScaleByPattern("(hfsc|hfsp)_multCorr_pluto_" + sigName + "_.*",
                                 1. / (nofEventsSig * fNofFastSimJobs));
    fHFastSim.fHM.ScaleByPattern("(hfsc|hfsp)_mom_pluto_" + sigName + ".*", 1. / (nofEventsSig * fNofFastSimJobs));
  }
  fHFastSim.fHM.ScaleByPattern("(hfsc|hfsp)_mult_urqmd_.*", 1. / (fNofSimEvents * fNofFastSimJobs));
  fHFastSim.fHM.ScaleByPattern("(hfsc|hfsp)_mom_urqmd_.*", 1. / (fNofSimEvents * fNofFastSimJobs));
  fHFastSim.fHM.ScaleByPattern("(hfsc|hfsp).*Rndm_urqmd_.*", 1. / fNofFastSimEvents);
  double scaleFS = 1.0;
  if (!IsCloseTo(scaleFS, 1.0, 1e-3))
    LOG(warn) << "Mind: Histos '(hfsc|hfsp).*_Minv.*' are scaled with factor " << scaleFS << "!";
  fHFastSim.fHM.ScaleByPattern("(hfsc|hfsp).*_Minv.*", scaleFS / fNofFastSimEvents);
  for (const string cat : {"", "_trueEl", "_urqmdAll", "_urqmdEl"}) {
    for (ELmvmAnaStep step : fHMean.fAnaStepsFS) {
      fHMean.CreateHByClone(fHFastSim.H1Clone("hfsc_MinvBg" + cat, step),
                            "hfsc_MinvBg" + cat + "_" + fHMean.fAnaStepNames[static_cast<int>(step)]);
      if (cat == "" || cat == "_trueEl")
        fHMean.CreateHByClone(fHFastSim.H1Clone("hfsp_MinvBg" + cat, step),
                              "hfsp_MinvBg" + cat + "_" + fHMean.fAnaStepNames[static_cast<int>(step)]);
    }
  }
  vector<TH1*> hnamesC = fHFastSim.fHM.H1Vector("hfsc_.*");
  vector<TH1*> hnamesP = fHFastSim.fHM.H1Vector("hfsp_.*");
  if (hnamesC.size() >= 1)
    fDoChargeBased = true;
  else
    LOG(error) << "Fast Simulation: No charge-based histograms.";  // Charge-based is standard and should exist
  if (hnamesP.size() >= 1)
    fDoParticleBased = true;
  else
    LOG(info) << "Fast Simulation: No particle-based histograms.";  // Optional
  LOG(info) << "hnamesC.size() = " << hnamesC.size()
            << " ->fDoChargeBased = " << fDoChargeBased;  // TODO: delete this line!
  LOG(info) << "hnamesP.size() = " << hnamesP.size()
            << " ->fDoParticleBased = " << fDoParticleBased;  // TODO: delete this line!
}
 
void LmvmDrawAll::CalculateCombBGHistos()
{
  fCbNormFactor.resize(fHMean.fNofAnaSteps);
  string hName  = "hmx_Minv";
  string cbName = "hCb";
 
  TFile* file = new TFile((fDataDir + "Background/EventMix/eventmix.all.root").c_str());
  fHEvMix.fHM.ReadFromFile(file);
  fNofEvMixEvents = fHEvMix.H1("hmx_EventNumber")->GetEntries();
  fNofEvMixJobs   = fHEvMix.H1("hmx_nofJobs")->GetEntries();
  fEvMixDepth = 1000 * fHEvMix.H1("hmx_NofFilesToMix")->GetEntries() / fNofEvMixJobs;  // usually 1000 events per file
  LOG(info) << "fNofEvMixEvents: " << fNofEvMixEvents;
  LOG(info) << "fNofEvMixJobs: " << fNofEvMixJobs;
  LOG(info) << "fEvMixDepth: " << fEvMixDepth << " events.";
  fHEvMix.fHM.ScaleByPattern("hmx_Minv.*", 1. / fNofEvMixEvents);
  double diff = fNofEvMixEvents / fNofSimEvents;
  if (diff <= 0.995 || diff >= 1.005)
    LOG(warn) << "Number of LmvmEventMix Events differs significantly from number of simulated events!";
  // Check that minv histos from LmvmEventMix have same properties as minv histos from LmvmTask
  TH1D* h1 = fHMean.H1Clone("hMinv", ELmvmSrc::Bg, ELmvmAnaStep::ElId);
  TH1D* h2 = fHEvMix.H1Clone("hmx_MinvPM_sameEv", ELmvmAnaStep::ElId);
  if ((h1->GetNbinsX() != h2->GetNbinsX()) || (h1->GetXaxis()->GetBinLowEdge(1) != h2->GetXaxis()->GetBinLowEdge(1))
      || (h1->GetXaxis()->GetBinUpEdge(h1->GetNbinsX()) != (h2->GetXaxis()->GetBinUpEdge(h2->GetNbinsX()))))
    LOG(error) << "LmvmDrawAll::CalculateCombBGHistos: Minv histograms from LmvmTask and LmvmEventMix do not agree!";
 
  // Calculate
  for (ELmvmAnaStep step : fHMean.fAnaSteps) {
    if (step < ELmvmAnaStep::ElId) continue;
    for (const string cat : {"", "_trueEl", "_urqmdAll", "_urqmdEl"}) {
      TH1D* pmSame  = fHEvMix.H1Clone(hName + "PM" + cat + "_sameEv", step);
      TH1D* ppSame  = fHEvMix.H1Clone(hName + "PP" + cat + "_sameEv", step);
      TH1D* mmSame  = fHEvMix.H1Clone(hName + "MM" + cat + "_sameEv", step);
      TH1D* pmMixed = fHEvMix.H1Clone(hName + "PM" + cat + "_mixedEv", step);
      TH1D* ppMixed = fHEvMix.H1Clone(hName + "PP" + cat + "_mixedEv", step);
      TH1D* mmMixed = fHEvMix.H1Clone(hName + "MM" + cat + "_mixedEv", step);
 
      // Geometric mean
      TH1D* hGeomSame  = fHMean.CreateHByClone(fHEvMix.H1Clone(fHMean.GetName(hName + "MM" + cat + "_sameEv", step)),
                                              fHMean.GetName(cbName + "Geom" + cat + "_sameEv", step));
      TH1D* hGeomMixed = fHMean.CreateHByClone(fHEvMix.H1Clone(fHMean.GetName(hName + "MM" + cat + "_sameEv", step)),
                                               fHMean.GetName(cbName + "Geom" + cat + "_mixedEv", step));
 
      for (int iB = 1; iB <= hGeomSame->GetNbinsX(); iB++) {
        double cppSame = ppSame->GetBinContent(iB);
        double cmmSame = mmSame->GetBinContent(iB);
        double cSame   = std::sqrt(cppSame * cmmSame);
        hGeomSame->SetBinContent(iB, cSame);
        double cppMix = ppMixed->GetBinContent(iB);
        double cmmMix = mmMixed->GetBinContent(iB);
        double cMix   = std::sqrt(cppMix * cmmMix);
        hGeomMixed->SetBinContent(iB, cMix);
      }
 
      // k factor ("raw", "fit" and "one")
      //"raw"
      TH1D* hKRaw = (TH1D*) pmMixed->Clone();
      hKRaw->Divide(hGeomMixed);
      hKRaw->Scale(0.5);
      fHMean.fHM.Add(fHMean.GetName(cbName + "K_raw" + cat, step), hKRaw);
 
      // "fit": Fitting k factor with a constant at higher inv. masses
      TH1D* hKFit    = (TH1D*) hKRaw->Clone();
      double kFitMin = 1.0;
      int changeBinK = hKFit->FindBin(kFitMin);
      hKFit->Fit("pol0", "Q", "", kFitMin, hKFit->GetMaximum());
      TF1* func   = hKFit->GetFunction("pol0");
      double mean = (func != nullptr) ? func->GetParameter(0) : 0;
      for (int iB = changeBinK; iB <= hKFit->GetNbinsX(); iB++) {
        hKFit->SetBinContent(iB, mean);
      }
      fHMean.fHM.Add(fHMean.GetName(cbName + "K_fit" + cat, step), hKRaw);
 
      // "one": Set k factor to value 1 from certain minv on
      TH1D* hKOne      = (TH1D*) hKRaw->Clone();
      double kOneStart = 0.7;
      int binOneStart  = hKRaw->FindBin(kOneStart);
      for (int iB = binOneStart; iB <= hKRaw->GetNbinsX(); iB++) {
        hKOne->SetBinContent(iB, 1.);
      }
      fHMean.fHM.Add(fHMean.GetName(cbName + "K_one" + cat, step), hKRaw);
 
      // Set hKRaw, hKFit or hKOne as standard for k here:
      TH1D* hK = (TH1D*) hKRaw->Clone();  // Will be used as standard for k factor; decide: hKRaw, hKFit or hKOne!
      fHMean.fHM.Add(fHMean.GetName(cbName + "K" + cat, step), hK);
 
      // Calculate combinatorial BG from same (m < fCbChange) and mixed (m >= fCbChange) events data
      // At first, calculate normalisation factor between same and mixed events in given range
      fCbChange           = 0.4;
      fCbNormRangeMin     = 0.4;
      fCbNormRangeMax     = 0.7;
      int ChangeBin       = pmSame->FindBin(fCbChange);
      int NormRangeMinBin = pmSame->FindBin(fCbNormRangeMin);
      int NormRangeMaxBin = pmSame->FindBin(fCbNormRangeMax);
      double normPPInt =
        ppSame->Integral(NormRangeMinBin, NormRangeMaxBin) / ppMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
      double normMMInt =
        mmSame->Integral(NormRangeMinBin, NormRangeMaxBin) / mmMixed->Integral(NormRangeMinBin, NormRangeMaxBin);
 
      fCbNormFactor[static_cast<int>(step)] = 1. / ((normPPInt + normMMInt) / 2.);
 
      // Combinatorial BG
      TH1D* hBc = fHMean.CreateHByClone(fHEvMix.H1Clone(fHMean.GetName(hName + "MM" + cat + "_sameEv", step)),
                                        fHMean.GetName(cbName + "Bg" + cat, step));
      for (int iB = 1; iB <= hBc->GetNbinsX(); iB++) {
        double k                 = hK->GetBinContent(iB);
        double geomMeanMixNormed = hGeomMixed->GetBinContent(iB) * std::sqrt(normPPInt * normMMInt);
        double cb = (iB < ChangeBin) ? 2. * k * hGeomSame->GetBinContent(iB) : 2. * k * geomMeanMixNormed;
        hBc->SetBinContent(iB, cb);
      }
 
      // Combinatorial BG without mixed event data (except k)
      TH1D* hBcSame = fHMean.CreateHByClone<TH1D>(cbName + "Geom" + cat + "_sameEv", cbName + "BgSame" + cat, step);
      hBcSame->Multiply(hK);
      hBcSame->Scale(2.);
 
      // Calculate signal from CB subtraction
      // Signal = N+-_{same} - CB_{calc}
      TH1D* hSigNpm = fHEvMix.H1Clone(hName + "PM" + cat + "_sameEv", step);
      fHMean.fHM.Add(fHMean.GetName(cbName + "SigNpm" + cat, step), hSigNpm);
      hSigNpm->Add(fHMean.H1(cbName + "Bg" + cat, step), -1.);
 
      // Signal = Coc+BG - CB_{calc}
      TH1D* hSigCoc = fHMean.H1Clone("hMinv" + cat + "_bg", step);
      fHMean.fHM.Add(fHMean.GetName(cbName + "SigMc" + cat, step), hSigCoc);
      hSigCoc->Add(GetCocktailMinvH1("hMinv" + cat, step, false));
      hSigCoc->Add(fHMean.H1(cbName + "Bg" + cat, step), -1.);
 
      // Calculate errors via error propagation formula for histograms with various bin widths and add to fHM
      for (auto bwv : fBwVarAll) {
        // Get basic histograms for number of entries (to estimate error)
        TH1D* h_s_pm = VaryBinWidth("evmix", fHMean.GetName(hName + "PM" + cat + "_sameEv", step), bwv);
        TH1D* h_s_pp = VaryBinWidth("evmix", fHMean.GetName(hName + "PP" + cat + "_sameEv", step), bwv);
        TH1D* h_s_mm = VaryBinWidth("evmix", fHMean.GetName(hName + "MM" + cat + "_sameEv", step), bwv);
        TH1D* h_m_pm = VaryBinWidth("evmix", fHMean.GetName(hName + "PM" + cat + "_mixedEv", step), bwv);
        TH1D* h_m_pp = VaryBinWidth("evmix", fHMean.GetName(hName + "PP" + cat + "_mixedEv", step), bwv);
        TH1D* h_m_mm = VaryBinWidth("evmix", fHMean.GetName(hName + "MM" + cat + "_mixedEv", step), bwv);
 
        string tag = "";
        if (bwv == fBwVarOrig)
          tag = fBwVarAllTags[0];
        else if (bwv == fBwVarReg)
          tag = fBwVarAllTags[1];
        else if (bwv == fBwVarBg)
          tag = fBwVarAllTags[2];
        else if (bwv == fBwVarSig)
          tag = fBwVarAllTags[3];
        else if (bwv == fBwVarSig2)
          tag = fBwVarAllTags[4];
        else if (bwv == fBwVarSig3)
          tag = fBwVarAllTags[5];
        else
          LOG(error) << "LmvmDrawAll::CalculateCombBGHistos: Check bwVar-tag assignment!";
        TH1D* bg     = VaryBinWidth("mean", cbName + "Bg" + cat, step, bwv);
        TH1D* sigMc  = VaryBinWidth("mean", cbName + "SigMc" + cat, step, bwv);
        TH1D* sigNpm = VaryBinWidth("mean", cbName + "SigNpm" + cat, step, bwv);
 
        TH1D* approxerror =
          (TH1D*) bg->Clone();  // to compare exact calulcated error with approximated // TODO: delete this block
        TH1D* trueerror = (TH1D*) bg->Clone();
        approxerror->Reset();
        trueerror->Reset();
 
        int nofBins = h_s_pm->GetNbinsX();
        double bW2  = h_s_pm->GetBinWidth(1);
        for (int iB = 1; iB <= nofBins; iB++) {
          double N_s_pm = h_s_pm->GetBinContent(iB) * fNofEvMixEvents * bW2;
          double N_s_pp = h_s_pp->GetBinContent(iB) * fNofEvMixEvents * bW2;
          double N_s_mm = h_s_mm->GetBinContent(iB) * fNofEvMixEvents * bW2;
          double N_m_pm = h_m_pm->GetBinContent(iB) * fNofEvMixEvents * fEvMixDepth * bW2;
          double N_m_pp = h_m_pp->GetBinContent(iB) * fNofEvMixEvents * fEvMixDepth * bW2;
          double N_m_mm = h_m_mm->GetBinContent(iB) * fNofEvMixEvents * fEvMixDepth * bW2;
 
          // derivatives of CB_{calc} w.r. to according value
          double d_m_pm = std::sqrt(N_s_pp * N_s_mm / (N_m_pp * N_m_mm));
          double d_m_pp =
            -0.5 * N_m_pm * std::pow(N_m_mm, -1. / 2.) * std::pow(N_m_pp, -3. / 2.) * std::sqrt(N_s_pp * N_s_mm);
          double d_m_mm =
            -0.5 * N_m_pm * std::pow(N_m_mm, -3. / 2.) * std::pow(N_m_pp, -1. / 2.) * std::sqrt(N_s_pp * N_s_mm);
          double d_s_pp = 0.5 * N_m_pm * std::sqrt(N_s_mm) * std::pow(N_m_pp * N_m_mm * N_s_pp, -1. / 2.);
          double d_s_mm = 0.5 * N_m_pm * std::sqrt(N_s_pp) * std::pow(N_m_pp * N_m_mm * N_s_mm, -1. / 2.);
 
          // contributions to error propagation
          double f_m_pm = std::pow(d_m_pm * std::sqrt(N_m_pm), 2);
          double f_m_pp = std::pow(d_m_pp * std::sqrt(N_m_pp), 2);
          double f_m_mm = std::pow(d_m_mm * std::sqrt(N_m_mm), 2);
          double f_s_pp = std::pow(d_s_pp * std::sqrt(N_s_pp), 2);
          double f_s_mm = std::pow(d_s_mm * std::sqrt(N_s_mm), 2);
 
          // final error propagation values
          double errorBc = std::sqrt(f_m_pm + f_m_pp + f_m_mm + f_s_pp + f_s_mm) / (bW2 * fNofEvMixEvents);
          double errorBc2 =
            std::sqrt(normPPInt * normMMInt) * std::sqrt(N_m_pm) / (bW2 * fNofEvMixEvents * fEvMixDepth);
          double errorSig  = std::sqrt(N_s_pm + std::pow(errorBc, 2)) / (bW2 * fNofEvMixEvents);
          double errorSig2 = std::sqrt(N_s_pm / std::pow(bW2 * fNofEvMixEvents, 2)
                                       + std::pow(errorBc2 / (bW2 * fNofEvMixEvents * fEvMixDepth), 2));
 
          if (iB < ChangeBin) bg->SetBinError(iB, errorBc);
          if (iB >= ChangeBin) bg->SetBinError(iB, errorBc2);
          if (iB < ChangeBin) sigMc->SetBinError(iB, errorSig);
          if (iB >= ChangeBin) sigMc->SetBinError(iB, errorSig2);
          if (iB < ChangeBin) sigNpm->SetBinError(iB, errorSig);
          if (iB >= ChangeBin) sigNpm->SetBinError(iB, errorSig2);
 
          // Compare exact error with approximated // TODO: delete
          double errappr = std::sqrt(N_s_mm + N_s_pp) / (bW2 * fNofEvMixEvents);
          double errappr2 =
            std::sqrt(N_m_pp + N_m_mm) / (bW2 * fNofEvMixEvents * fEvMixDepth * fCbNormFactor[static_cast<int>(step)]);
          if (iB < ChangeBin) {
            trueerror->SetBinContent(iB, errorBc);
            approxerror->SetBinContent(iB, errappr);
          }
          if (iB >= ChangeBin) {
            trueerror->SetBinContent(iB, errorBc2);
            approxerror->SetBinContent(iB, errappr2);
          }
        }  // iB
        fHMean.CreateHByClone(bg, fHMean.GetName(cbName + "Bg" + cat + "_" + tag, step));
        fHMean.CreateHByClone(sigMc, fHMean.GetName(cbName + "SigMc" + cat + "_" + tag, step));
        fHMean.CreateHByClone(sigNpm, fHMean.GetName(cbName + "SigNpm" + cat + "_" + tag, step));
        if (step == ELmvmAnaStep::ElId && cat == "" && bwv == fBwVarOrig) {
          fHMean.fHM.CreateCanvas("CombinatorialBackground/Error", "CombinatorialBackground/Error", 800, 800);
          DrawH1({trueerror, approxerror}, {"exact error", "approx. error"}, kLinear, kLog, true, 0.65, 0.75, 0.89,
                 0.88, "hist");
        }
      }  // ..bwVar
    }    // ..cat
  }      // ..steps
  for (ELmvmAnaStep step : fHMean.fAnaSteps) {
    double f = fCbNormFactor[static_cast<int>(step)];
    LOG(info) << "fCbNormFactor[" << fHMean.fAnaStepNames[static_cast<int>(step)] << "]: " << f;
  }
  cout << endl;
}
 
void LmvmDrawAll::CalcCutEffRange(double minMinv, double maxMinv)
{
  stringstream ss1;
  ss1 << "hCutEff_" << minMinv << "to" << maxMinv;
  fHMean.CreateH1(ss1.str() + "_bg", "Analysis step", "Efficiency [%]", fHMean.fNofAnaSteps, 0, fHMean.fNofAnaSteps);
  fHMean.CreateH1(ss1.str() + "_s", "Analysis step", "Efficiency [%]", fHMean.fNofAnaSteps, 0, fHMean.fNofAnaSteps);
  TH1D* hS         = fHMean.H1(ss1.str() + "_s");
  TH1D* hBg        = fHMean.H1(ss1.str() + "_bg");
  int x            = 1;
  TH1D* cocktail   = GetCocktailMinvH1("hMinv", ELmvmAnaStep::ElId, false);
  int binMin       = cocktail->FindBin(minMinv);
  int binMax       = cocktail->FindBin(maxMinv);
  double sIntElId  = cocktail->Integral(binMin, binMax);
  double bgIntElId = fHMean.H1("hMinv", ELmvmSrc::Bg, ELmvmAnaStep::ElId)->Integral(binMin, binMax);
  for (ELmvmAnaStep step : fHMean.fAnaSteps) {
    if (step < ELmvmAnaStep::ElId) continue;
    if (!fUseMvd && (step == ELmvmAnaStep::Mvd1Cut || step == ELmvmAnaStep::Mvd2Cut)) continue;
 
    double effS = 100. * GetCocktailMinvH1("hMinv", step, false)->Integral(binMin, binMax) / sIntElId;
    double effB = 100. * fHMean.H1("hMinv", ELmvmSrc::Bg, step)->Integral(binMin, binMax) / bgIntElId;
 
    hBg->GetXaxis()->SetBinLabel(x, fHMean.fAnaStepLatex[static_cast<int>(step)].c_str());
    hBg->SetBinContent(x, effB);
    hS->SetBinContent(x, effS);
    x++;
  }
 
  hBg->GetXaxis()->SetLabelSize(0.06);
  hBg->GetXaxis()->SetRange(1, x - 1);
  hS->GetXaxis()->SetRange(1, x - 1);
 
  stringstream ss;
  ss << "lmvmAll_cutEff_" << minMinv << "to" << maxMinv;
  fHMean.fHM.CreateCanvas(ss.str(), ss.str(), 1000, 1000);
  DrawH1({hBg, hS}, {"B_{MC}", "Cocktail"}, kLinear, kLinear, true, 0.75, 0.85, 1.0, 1.0, "hist");
  hBg->SetLineWidth(4);
  hS->SetLineWidth(4);
  hBg->SetMinimum(1);
  hBg->SetMaximum(110);
 
  stringstream ss2;
  ss2 << minMinv << "<M [GeV/c^2]<" << maxMinv;
  TText* t = new TText(0.5, hBg->GetMaximum() + 5, ss2.str().c_str());
  t->Draw();
}
 
TH1D* LmvmDrawAll::SBgRange(double minMinv, double maxMinv)
{
  stringstream ss;
  ss << "hSBgRatio_" << minMinv << "to" << maxMinv;
  fHMean.CreateH1(ss.str(), "Analysis step", "Cocktail/BG", fHMean.fNofAnaSteps, 0, fHMean.fNofAnaSteps);
  TH1D* hSBg = fHMean.H1(ss.str());
  hSBg->GetXaxis()->SetLabelSize(0.06);
  int x          = 1;
  TH1D* cocktail = GetCocktailMinvH1("hMinv", ELmvmAnaStep::ElId, false);
  int binMin     = cocktail->FindBin(minMinv);
  int binMax     = cocktail->FindBin(maxMinv);
  for (ELmvmAnaStep step : fHMean.fAnaSteps) {
    if (step < ELmvmAnaStep::ElId) continue;
    if (!fUseMvd && (step == ELmvmAnaStep::Mvd1Cut || step == ELmvmAnaStep::Mvd2Cut)) continue;
 
    double intS  = 100. * GetCocktailMinvH1("hMinv", step, false)->Integral(binMin, binMax);
    double intBg = 100. * fHMean.H1("hMinv", ELmvmSrc::Bg, step)->Integral(binMin, binMax);
    double sbg   = intS / intBg;
 
    hSBg->GetXaxis()->SetBinLabel(x, fHMean.fAnaStepLatex[static_cast<int>(step)].c_str());
    hSBg->SetBinContent(x, sbg);
    x++;
  }
  hSBg->GetXaxis()->SetRange(1, x - 1);
  return hSBg;
}
 
void LmvmDrawAll::SBgRangeAll()
{
  TH1D* h1 = SBgRange(0.0, 0.2);
  TH1D* h2 = SBgRange(0.2, 0.6);
  TH1D* h3 = SBgRange(0.6, 1.2);
 
  fHMean.fHM.CreateCanvas("SignalToBg/Ranges", "SignalToBg/Ranges", 1000, 1000);
  DrawH1({h1, h2, h3}, {"0.0<M [GeV/c^{2}]<0.2", "0.2<M [GeV/c^{2}]<0.6", "0.6<M [GeV/c^{2}]<1.2"}, kLinear, kLog, true,
         0.25, 0.83, 0.75, 0.99, "hist");
  h1->SetMinimum(0.9 * std::min({h1->GetMinimum(), h2->GetMinimum(), h3->GetMinimum()}));
  h1->SetMaximum(1.1 * std::max({h1->GetMaximum(), h2->GetMaximum(), h3->GetMaximum()}));
  h1->SetLineWidth(4);
  h2->SetLineWidth(4);
  h3->SetLineWidth(4);
 
  TH1D* h4 = SBgRange(0.5, 0.6);
  fHMean.fHM.CreateCanvas("SignalToBg/Range05to06", "SignalToBg/Range05to06", 1000, 1000);
  DrawH1(h4, kLinear, kLinear);
  h4->SetLineWidth(4);
}
 
void LmvmDrawAll::DrawSBgResults()
{
  TCanvas* cFit = fHMean.fHM.CreateCanvas("SignalToBg/SignalFit", "SignalToBg/SignalFit", 1000, 1000);
  ofstream resultFile(fOutputDir + "/lmvmAll_results.txt");
  for (auto signal : fHMean.fSignals) {
    string signalName = fHMean.fSignalNames[static_cast<int>(signal)];
    fHMean.CreateH1("hSBgRatio_" + signalName, "Analysis steps", "S/BG", fHMean.fNofAnaSteps, 0, fHMean.fNofAnaSteps);
    TH1D* hSBg = fHMean.H1("hSBgRatio_" + signalName);
    hSBg->GetXaxis()->SetLabelSize(0.06);
    hSBg->SetLineWidth(4);
    int x = 1;
    for (ELmvmAnaStep step : fHMean.fAnaSteps) {
      if (step < ELmvmAnaStep::ElId) continue;
      if (!fUseMvd && (step == ELmvmAnaStep::Mvd1Cut || step == ELmvmAnaStep::Mvd2Cut)) continue;
      cFit->cd(x);
      LmvmSBgResultData result = CalculateSBgResult(signal, step);
 
      hSBg->GetXaxis()->SetBinLabel(x, fHMean.fAnaStepLatex[static_cast<int>(step)].c_str());
      if (result.fSBgRatio < 1000.) hSBg->SetBinContent(x, result.fSBgRatio);
      x++;
      resultFile << signalName << " " << fHMean.fAnaStepNames[static_cast<int>(step)] << " " << result.fSignallEff
                 << " " << result.fSBgRatio << " " << result.fFitMean << " " << result.fFitSigma;
    }
    hSBg->GetXaxis()->SetRange(1, x - 1);
    fHMean.fHM.CreateCanvas("SignalToBg/" + signalName, "SignalToBg/" + signalName, 1000, 1000);
    DrawH1(hSBg);
    hSBg->SetLineWidth(4);
  }
  resultFile.close();
}
 
LmvmSBgResultData LmvmDrawAll::CalculateSBgResult(ELmvmSignal signal, ELmvmAnaStep step)
{
  TH1D* s  = H(signal)->H1("hMinv", ELmvmSrc::Signal, step);
  TH1D* bg = H(signal)->H1("hMinv", ELmvmSrc::Bg, step);
 
  if (s->GetEntries() < 10) return LmvmSBgResultData(0., 0., 0., 0.);
 
  TH1D* sClone = static_cast<TH1D*>(s->Clone());
  if (signal == ELmvmSignal::Phi)
    sClone->Fit("gaus", "Q", "", 0.95, 1.05);
  else if (signal == ELmvmSignal::Omega)
    sClone->Fit("gaus", "Q", "", 0.69, 0.81);
  else
    sClone->Fit("gaus", "Q");
 
  TF1* func    = sClone->GetFunction("gaus");
  double mean  = (func != nullptr) ? func->GetParameter("Mean") : 0.;
  double sigma = (func != nullptr) ? func->GetParameter("Sigma") : 0.;
  int minInd   = s->FindBin(mean - 2. * sigma);
  int maxInd   = s->FindBin(mean + 2. * sigma);
 
  double sumSignal = 0.;
  double sumBg     = 0.;
  for (int i = minInd + 1; i <= maxInd - 1; i++) {
    sumSignal += s->GetBinContent(i);
    sumBg += bg->GetBinContent(i);
  }
  double sbg = (sumBg != 0.) ? sumSignal / sumBg : 0.;
 
  double eff = 100. * H(signal)->H1("hPtYPairSignal", step)->GetEntries()
               / H(signal)->H1("hPtYPairSignal", ELmvmAnaStep::Mc)->GetEntries();
 
  return LmvmSBgResultData(sbg, eff, mean, sigma);
}
 
void LmvmDrawAll::CheckMemory(const string& text)
{
  static ProcInfo_t info;
  const float toMB = 1.f / 1024.f;
  gSystem->GetProcInfo(&info);
  cout << Form((text + ": Memory res|vir: %g|%g Mbytes\n").c_str(), info.fMemResident * toMB, info.fMemVirtual * toMB);
  cout << endl;
}
 
void LmvmDrawAll::SaveHist()
{
  if (fOutputDir != "") {
    gSystem->mkdir(fOutputDir.c_str(), true);
    TFile* f = TFile::Open(string(fFileName).c_str(), "RECREATE");
    fHMean.WriteToFile();
    f->Close();
  }
}
 
void LmvmDrawAll::SaveCanvasToImage()
{
  cout << "Images output dir:" << fOutputDir << endl;
  fHMean.fHM.SaveCanvasToImage(fOutputDir, "png");
}