HadronBgPrep.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <map>
#include <vector>
#include <iostream>
#include <fstream>
 
#include <TH1D.h>
#include <TF1.h>
#include <TCanvas.h>
#include <TLine.h>
#include <TLegend.h>
#include <TGraphErrors.h>
#include <TTree.h>
 
#include <calibration/CalibrationAlgorithm.h>
#include <framework/database/DBObjPtr.h>
#include <cdc/utilities/CDCDedxMeanPred.h>
#include <cdc/utilities/CDCDedxSigmaPred.h>
#include <cdc/utilities/CDCDedxHadSat.h>
 
#include <framework/gearbox/Const.h>
 
enum gstatus {OK, Failed};
 
namespace Belle2 {
  class HadronBgPrep {
 
  public:
 
    HadronBgPrep();
 
    virtual ~HadronBgPrep() {};
 
    HadronBgPrep(int bgbins, double upperbg, double lowerbg, int cosbins, double uppercos, double lowercos, int injbins,
                 double lowerinj, double upperinj, int nhitbins, double lowernhit, double uppernhit, double cut);
 
    void prepareSample(std::shared_ptr<TTree> hadron, TFile*& outfile, const std::string& suffix, const std::string& bgcurvefile,
                       const std::string& bgsigmafile, const std::string& pdg, bool ismakePlots);
 
    void defineHisto(std::vector<TH1F*>& htemp, const std::string& svar, const std::string& stype, const std::string& pdg);
 
    void plotDist(std::map<int, std::vector<TH1F*>>& hist, const std::string& suffix, int bins);
 
    void plotDist(std::vector<TH1F*>& hist, const std::string& suffix, int nbins);
 
    void setPars(TFile*& outfile, std::string pdg, std::vector<TH1F*>& hdedx_bg, std::vector<TH1F*>& hchi_bg,
                 std::vector<TH1F*>& hionzsigma_bg, std::map<int, std::vector<TH1F*>>& hchi_inj);
 
    void fitGaussianWRange(TH1F*& temphist, gstatus& status, double sigmaR);
 
    void fit(TH1F*& hist, const std::string& pdg);
 
    void printCanvasCos(std::map<int, std::vector<TH1F*>>& hchicos_allbg, std::map<int, std::vector<TH1F*>>& hchicos_1by3bg,
                        std::map<int, std::vector<TH1F*>>& hchicos_2by3bg, std::map<int, std::vector<TH1F*>>& hchicos_3by3bg, const std::string& particle,
                        const std::string& suffix);
 
    void FormatGraph(TGraphErrors& gr, int flag, const std::string& name = "")
    {
      if (flag == 0) {
        gr.SetTitle(Form("%s;cos(#theta);#chi_{mean}", name.data()));
        gr.SetMarkerStyle(24);
        gr.SetMarkerColor(2);
        gr.SetMarkerSize(.7);
        gr.SetMaximum(1.0);
        gr.SetMinimum(-1.0);
        gr.GetXaxis()->SetRangeUser(-1, 1);
      } else if (flag == 1) {
        gr.SetMarkerStyle(22);
        gr.SetMarkerColor(9);
        gr.SetMarkerSize(.7);
      } else if (flag == 2) {
        gr.SetTitle(Form("%s;cos(#theta);#sigma", name.data()));
        gr.SetMarkerStyle(24);
        gr.SetMarkerColor(2);
        gr.SetMarkerSize(.7);
        gr.SetMaximum(2);
        gr.SetMinimum(0);
        gr.GetXaxis()->SetRangeUser(-1, 1);
      }
    }
 
    void clearVars()
    {
      m_sumcos.clear();
      m_sumbg.clear();
      m_sumres_square.clear();
      m_sumsize.clear();
      m_means.clear();
      m_errors.clear();
      m_suminj.clear();
    }
 
    void deleteHistos(std::vector<TH1F*>& htemp)
    {
      for (auto& hist : htemp) hist->Delete();
    }
 
    double getParticleMass(const std::string& particle)
    {
      double mass;
      if (particle == "pion") mass = Const::pion.getMass();
      else if (particle == "kaon") mass = Const::kaon.getMass();
      else if (particle == "proton") mass = Const::proton.getMass();
      else if (particle == "muon") mass = Const::muon.getMass();
      else if (particle == "electron") mass = Const::electron.getMass();
      else mass = 0.0;
      return mass;
    }
 
  private:
 
    std::vector<double> m_sumcos; 
    std::vector<double> m_sumbg;  
    std::vector<double> m_sumres_square;  
    std::vector<double> m_suminj; 
    std::vector<double> m_means;  
    std::vector<double> m_errors; 
    std::vector<int> m_sumsize; 
    std::vector<int> m_injsize; 
    int m_bgBins; 
    double m_bgMin; 
    double m_bgMax; 
    int m_injBins; 
    double m_injMin; 
    double m_injMax; 
    int m_cosBins; 
    double m_cosMin; 
    double m_cosMax; 
    int m_nhitBins; 
    double m_nhitMin; 
    double m_nhitMax; 
    double m_cut;  
  };
} // namespace Belle2