CDCDedx1DCellAlgorithm.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 <algorithm>
#include <iostream>
#include <fstream>
 
#include <TMath.h>
#include <TH1D.h>
#include <TCanvas.h>
#include <TH2D.h>
#include <TTree.h>
#include <TStyle.h>
#include <TLegend.h>
#include <TRandom.h>
 
 
#include <reconstruction/dbobjects/CDCDedx1DCell.h>
#include <calibration/CalibrationAlgorithm.h>
#include <framework/database/DBObjPtr.h>
 
namespace Belle2 {
  class CDCDedx1DCellAlgorithm : public CalibrationAlgorithm {
 
  public:
 
    CDCDedx1DCellAlgorithm();
 
    virtual ~CDCDedx1DCellAlgorithm() {}
 
    void setSuffix(const std::string& value) {m_suffix = value;}
 
    void setVariableBins(bool value) {isVarBins = value;}
 
    void setLayerTrunc(bool value = false) {isFixTrunc = value;}
 
    void setMergePayload(bool value) { isMerge = value;}
 
    void setSplitFactor(int value) {m_binSplit = value;}
 
    void setRotSymmetry(bool value) {isRotSymm = value;}
 
    void setTrucationBins(double lowedge, double upedge)
    {
      m_truncMin = lowedge; m_truncMax = upedge ;
    }
 
    void enableExtraPlots(bool value = false) {isMakePlots = value;}
 
    void setPtLimit(double value) {m_ptMax = value;}
 
    void setCosLimit(double value) {m_cosMax = value;}
 
    void setBaselineFactor(double charge, double factor)
    {
 
      m_adjustFac = factor;
      if (charge < 0)m_chargeType = -1.0;
      else if (charge > 0)m_chargeType = 1.0;
      else if (charge == 0)m_chargeType = 0.0;
      else
        B2FATAL("Choose charge value either +/-1 or 0");
    }
 
    int rotationalBin(int nbin, int ibin)
    {
      if (nbin % 4 != 0)return ibin;
      int jbin = ibin;
      if (ibin < nbin / 4) jbin = ibin + nbin / 2 ;
      else if (ibin >= 3 * nbin / 4) jbin = ibin - nbin / 2 ;
      return jbin;
    }
 
    void getExpRunInfo();
 
    void CreateBinMapping();
 
    void defineHisto(std::vector<TH1D*>  hdedxhit[2],  TH1D* hdedxlay[2], TH1D* hentalay[2]);
 
    void getTruncatedBins(TH1D* hist, int& binlow, int& binhigh);
 
    double getTruncationMean(TH1D* hist, int binlow, int binhigh);
 
    void createPayload();
 
    void plotMergeFactor(std::map<int, std::vector<double>> bounds, const std::array<int, 2> nDev,
                         std::map<int, std::vector<int>> steps);
 
    void plotdedxHist(std::vector<TH1D*> hdedxhit[2]);
 
    void plotLayerDist(TH1D* hdedxL[2]);
 
    void plotQaPars(TH1D* hentalay[2], TH2D* hptcosth);
 
    void plotRelConst(std::vector<double>tempconst, std::vector<double>layerconst, int il);
 
    void plotConstants();
 
    void plotEventStats();
 
  protected:
    virtual EResult calibrate() override;
 
 
  private:
 
    double m_eaMin; 
    double m_eaMax; 
    double m_eaBW; 
    int m_eaBin; 
    double m_dedxMin;  
    double m_dedxMax;  
    int m_dedxBin;  
    double m_ptMax; 
    double m_cosMax; 
    double m_truncMin; 
    double m_truncMax; 
    int m_binSplit;
    int m_binMerge;
    double m_chargeType; 
    double m_adjustFac;
    bool isFixTrunc; 
    bool isVarBins;  
    bool isRotSymm; 
    bool isMakePlots; 
    bool isPrintLog; 
    bool isMerge; 
    std::string m_suffix; 
    std::string m_runExp; 
    std::string m_label[2] = {"IL", "OL"}; 
    std::vector<int> m_eaBinLocal; 
    std::array<std::vector<int>, 2> m_binIndex; 
    std::array<std::vector<double>, 2>m_binValue; 
    std::vector<std::vector<double>> m_onedcors; 
    DBObjPtr<CDCDedx1DCell> m_DBOneDCell; 
  };
} // namespace Belle2