LmvmDrawAll.h

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], Florian Uhlig, Cornelius Feier-Riesen */
 
#ifndef LMVM_DRAW_ALL
#define LMVM_DRAW_ALL
 
#include "FairRootManager.h"
#include "LmvmHist.h"
#include "TObject.h"
 
#include <map>
#include <string>
#include <vector>
 
class TH1;
class TH2D;
class TH1D;
class TFile;
class TCanvas;
class CbmHistManager;
 
class LmvmDrawAll : public TObject {
 
 public:
  LmvmDrawAll() { ; }
  virtual ~LmvmDrawAll() { ; }
 
 
  void DrawHistFromFile(const std::string& fileInmed, const std::string& fileQgp, const std::string& fileOmega,
                        const std::string& filePhi, const std::string& fileOmegaD, const std::string& dataDir = "",
                        bool useMvd = false);
 
 private:
  std::string fDataDir;
  std::string fOutputDir;  // output directory for figures
  std::string fFileName;
 
  bool fUseMvd;  // do you want to draw histograms related to the MVD detector?
 
  std::vector<LmvmHist*> fH;
  LmvmHist fHMean;
  LmvmHist fHFastSim;
  LmvmHist fHEvMix;
 
  double fRebinMinv;  // Rebin for minv histograms
 
  double fNofSimEvents;      // Number of simulated events (analysis)
  double fNofFastSimEvents;  // Number of Fast Simulations (type 'double' because of large value)
  double fNofFastSimJobs;    // Number of jobs of Fast Simulations (for correct scaling)
 
  // Fast Simulation
  bool fDoChargeBased   = false;
  bool fDoParticleBased = false;
 
  // Combinatorial Background (calculated by means of class LmvmEventMix)
  int fNofEvMixJobs;
  int fEvMixDepth;
  double
    fNofEvMixEvents;  // Number of events from LmvmEventMix (ideally equal to fNofSimEvents if all jobs finished successfully)
  double fCbChange       = -1.;       // Threshold for transition from same to mixed events
  double fCbNormRangeMin = -1.;       // Start point for range in which mixed events are normalised to same events
  double fCbNormRangeMax = -1.;       // End point for range in which mixed events are normalised to same events
  std::vector<double> fCbNormFactor;  // Ratio mixed/same event yields, separate for each step
 
  template<typename T>
  T* InitOrFatal(const std::string& name)
  {
    FairRootManager* ioman = FairRootManager::Instance();
    if (ioman == nullptr) LOG(fatal) << "LmvmDrawAll: No FairRootManager!";
    T* array = static_cast<T*>(ioman->GetObject(name.c_str()));
    if (array == nullptr) LOG(fatal) << "LmvmDrawAll: No " << name << "object!";
    return array;
  }
 
  void CheckoutAddFunction();
  void CheckoutAddFunction2();
 
  // Variable bin width

  TH1D* VaryBinWidth(TH1D* h, double nEvents, std::vector<std::pair<double, double>> binValues);

  TH1D* VaryBinWidth(const std::string& option, const std::string& hName, double nEvents,
                     std::vector<std::pair<double, double>> binValues);

  TH1D* VaryBinWidth(const std::string& option, const std::string& hName, ELmvmAnaStep step, double nEvents,
                     std::vector<std::pair<double, double>> binValues);
 
  TH1D* VaryBinWidth(TH1D* h, std::vector<std::pair<double, double>>
                                binValues);  // Same as previous, without nEvents -> Error won't be calculated
  TH1D* VaryBinWidth(const std::string& option, const std::string& hName,
                     std::vector<std::pair<double, double>> binValues);
  TH1D* VaryBinWidth(const std::string& option, const std::string& hName, ELmvmAnaStep step,
                     std::vector<std::pair<double, double>> binValues);
  void CheckVaryBinWidth();
 
  // Templates for variabel bin width vectors
  std::vector<std::pair<double, double>> fBwVarOrig = {std::make_pair(2.5, 0.01)};  // 250+2 bins
  std::vector<std::pair<double, double>> fBwVarReg  = {std::make_pair(2.5, 0.1)};   // 25+2 bins
  std::vector<std::pair<double, double>> fBwVarBg   = {std::make_pair(1.5, 0.1), std::make_pair(2.0, 0.25),
                                                     std::make_pair(2.5, 0.5)};  // 18+2 bins
  std::vector<std::pair<double, double>> fBwVarBg2  = {std::make_pair(1.5, 0.1), std::make_pair(1.75, 0.25),
                                                      std::make_pair(2.5, 0.75)};  // 17+2 bins
  std::vector<std::pair<double, double>> fBwVarBg3  = {std::make_pair(1.6, 0.2), std::make_pair(2.0, 0.4),
                                                      std::make_pair(2.5, 0.5)};  // 10+2 bins
  std::vector<std::pair<double, double>> fBwVarBg4  = {std::make_pair(1.6, 0.4), std::make_pair(2.5, 0.9)};  // 5+2 bins
  std::vector<std::pair<double, double>> fBwVarBg5  = {std::make_pair(1.5, 0.3), std::make_pair(2.5, 1.0)};  // 6+2 bins
  std::vector<std::pair<double, double>> fBwVarSig  = {std::make_pair(0.5, 0.1), std::make_pair(1.1, 0.05),
                                                      std::make_pair(1.5, 0.2), std::make_pair(2.5, 1.0)};  // 20+2 bins
  std::vector<std::pair<double, double>> fBwVarSig3 = {std::make_pair(1.1, 0.1), std::make_pair(1.5, 0.2),
                                                       std::make_pair(2.5, 1.0)};  // 20+2 bins
  std::vector<std::pair<double, double>> fBwVarSig2 = {std::make_pair(0.5, 0.1), std::make_pair(1.1, 0.05),
                                                       std::make_pair(1.5, 0.2),
                                                       std::make_pair(2.5, 0.5)};  // 21+2 bins
  std::vector<std::pair<double, double>> fBwVarRat  = {std::make_pair(1.0, 0.1), std::make_pair(2.0, 0.2),
                                                      std::make_pair(2.5, 0.5)};  // 16+2 bins
  std::vector<std::pair<double, double>> fBwVarCock = {std::make_pair(0.75, 0.05), std::make_pair(0.8, 0.01),
                                                       std::make_pair(0.95, 0.05), std::make_pair(1.05, 0.01),
                                                       std::make_pair(2.5, 0.05)};  // 62+2 bins
  std::vector<std::pair<double, double>> fBwVarOmega            = {std::make_pair(0.65, 0.05),
                                                        std::make_pair(2.5, 0.01)};  // 198+2 bins
  std::vector<std::pair<double, double>> fBwVarPhi              = {std::make_pair(0.85, 0.05),
                                                      std::make_pair(2.5, 0.01)};  // 182+2 bins
  std::vector<std::vector<std::pair<double, double>>> fBwVarAll = {fBwVarOrig, fBwVarReg,  fBwVarBg,
                                                                   fBwVarSig,  fBwVarSig2, fBwVarSig3};
  std::vector<std::string> fBwVarAllTags = {"bwvOrig", "bwvReg", "bwvBg", "bwvSig", "bwvSig2", "bwvSig3"};
  int fBwVarCounter                      = 0.;  // to prevent same names for copies of same histograms (needed?)
 
 
  LmvmHist* H(ELmvmSignal signal);
 
  template<class T>
  T* GetCocktailMinv(const std::string& name, ELmvmAnaStep step, bool scaleAll);
 
  TH1D* GetCocktailMinvH1(const std::string& name, ELmvmAnaStep step, bool scaleAll);

  void CalculateHistErrors(TH1D* h, double nofEvents);

  TH1D* CalculateHistRatioWithErrors(TH1D* hNom, TH1D* hDenom, double nEvNom, double nEvDenom);

  void LoadFastSimHistos();

  void CalculateCombBGHistos();
  void CalculateCBFromFastSimEvents();
 
  TH1D* GetCBForNormRange(const std::string hName, ELmvmAnaStep step, double rangeStart, double rangeEnd);

  void CalculateSignal();

  TH1D* GetSignal(ELmvmAnaStep step, std::vector<std::pair<double, double>> bwVar);

  void DrawSBgVsMinv();
 
  void ChargeSymmetry();
  void DrawSignal();
  void DrawSignalCBNormRangeDependent(std::string hName, std::string cName, ELmvmAnaStep step);
  void DrawNumbers();
  void DrawMinvAll();
  void DrawMinv(ELmvmAnaStep step);
  void DrawMinvPtAll();
  void DrawMomRecoPrecision();
  void DrawBackground();
  void DrawPtY();
  void DrawBgPairs();
  void DrawElidCuts();
  void DrawMomentumUrqmd();
  void DrawCandProperties();
  void DrawRichProperties();
  void DrawLikeSignCorrelations();
  void DrawRapidity();
  bool IsCloseTo(double value, double refValue, double tol);
 
  // Temperature Calculation
  void DrawTemperature();
  void DrawTemperatureGraph(TH1D* h, ELmvmAnaStep step, double startfit, double endfit,
                            bool DoCorrectX);  // TODO: delete this method if not needed anymore
  void DrawTemperatureGraph(TH1D* h, ELmvmAnaStep step, double startfit, double endfit);
  void DrawTemperature(TH1D* h, double startfit, double endfit);
  void InitialiseCocktailFitParams();
  void CheckoutTemperatureParamB();
  void CheckoutTemperatureParams();
  void CheckoutTemperatureFitRangeAll();
  void CheckoutTemperatureFitRange(TH1D* h, std::string name);
  void CheckoutTemperatureInitParams();
  std::vector<double> fParamB;  // Parameter for correct x-position in temperature histograms
  int fTempGraphCounter = 0.;   // to prevent same names for copies of same histograms (needed?)
 

  void DrawCombinatorialBackground();

  void DrawMinvOfficialStyle();
 
  template<class T>
  void CreateMeanHist(const std::string& name, int nofRebins = -1);  // if nRebin = -1, no rebin
 
  template<class T>
  void CreateMeanHistSparse(const std::string& name);
 
  void CreateMeanHistAll();

  void SaveHist();

  void CalcCutEffRange(double minMinv, double maxMinv);

  TH1D* SBgRange(double minMinv, double maxMinv);

  void SBgRangeAll();

  void InvestigateMisid();
 
  void DrawPtY(TH2D* hMc, TH2D* h, const std::string cName, double zMin, double zMax);
  void DrawStudies();
 
  void DrawBetaMomSpectra();
 
  void DrawMomPluto();
 
  void DrawTofM2();
 
  void DrawGTrackVertex();
 
  void DrawSignificancesAll();
  void DrawSignificance(TH2D* hEl, TH2D* hBg, const std::string& name, double minZ, double maxZ,
                        const std::string& option);
 
  void DrawEfficiency();
  void DrawEfficiencyCorrection();
 
 
  void DrawSuppression();
 
  // investigate misidentifications
  void DrawMomentum();
  void DrawMomentumMisidVsTrue();
  void DrawPtYAndTofM2Misid();
  void DrawPurity();
  void DrawPurityHistText(TH2D* h);
  void DrawChi2();
  void DrawMinvScaleValues();
  void DrawNofHits();
  void DrawFastSimHistos();
  void DrawFastSimHistosParticleBased();
  void DrawMultiplicities(TH1D* plus, TH1D* minus, TH1D* plusrandom, TH1D* minusrandom, std::string cName,
                          std::string hText);
  void DrawSystematicErrorFsSignal();
  TH1D* GetSymmetry(TH1D* h);
  TH1D* GetSymmetry(TH1D* h1, std::string opt1, TH1D* h2, std::string opt2,
                    const std::string& label);  // label to prevent same hName for several histos
  TH1D* GetHalfHisto(TH1D* h, std::string opt, const std::string& label);

 
  void DrawSBgResults();
 
  LmvmSBgResultData CalculateSBgResult(ELmvmSignal signal, ELmvmAnaStep step);

  void SaveCanvasToImage();
 
  double fZ = -44.;  // z-position of target
 
  LmvmDrawAll(const LmvmDrawAll&);
  LmvmDrawAll operator=(const LmvmDrawAll&);
 
  void CheckMemory(const std::string& text);
 
  ClassDef(LmvmDrawAll, 1);
};
 
#endif