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 <TH1D.h>
#include <TH2D.h>
 
#include <cdc/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; 
    int m_eaB; 
 
    double m_dedxMin;  
    double m_dedxMax;  
    int m_dedxBin;  
 
    double m_ptMax; 
    double m_cosMax; 
 
    double m_truncMin; 
    double m_truncMax; 
 
    int m_binSplit;
 
    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