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:
 
    static constexpr int m_kNGroups = 3; 

    CDCDedx1DCellAlgorithm();

    virtual ~CDCDedx1DCellAlgorithm() {}

    void setEntaRange(double min = -1.0, double max = 1.0) {m_eaMin = min; m_eaMax = max;}

    void setEntaBins(unsigned int value = 316) {m_eaB = value;}

    void setHistBins(int value = 250) {m_dedxBin = value;}

    void setHistRange(double min = 0.0, double max = 5.0) {m_dedxMin = min; m_dedxMax = max;}

    void setPtLimit(double value) {m_ptMax = value;}

    void setCosLimit(double value) {m_cosMax = value;}

    void setTrucationBins(double lowedge, double upedge)
    {
      m_truncMin = lowedge; m_truncMax = upedge ;
    }

    void setSplitFactor(int value) {m_binSplit = value;}

    void setChargeType(int value) {m_chargeType = value;}

    void setAdjustmentFactor(int value) {m_adjustFac = value;}

    void setLayerTrunc(bool value = false) {isFixTrunc = value;}

    void setVariableBins(bool value) {isVarBins = value;}

    void setRotSymmetry(bool value) {isRotSymm = value;}

    void enableExtraPlots(bool value = false) {isMakePlots = value;}

    void setPrintLog(bool value = false) {isPrintLog = value;}

    void setMergePayload(bool value) { isMerge = value;}

    void setSuffix(const std::string& value) {m_suffix = value;}

    unsigned int getRepresentativeLayer(unsigned int il) const
    {
      static const std::array<unsigned int, m_kNGroups> repLayer = {1, 9, 17};
      return repLayer.at(il);
    }

    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::array<std::vector<TH1D*>, 3>& hdedxhit, std::array<TH1D*, 3>& hdedxlay, std::array<TH1D*, 3>& hentalay);

    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::array<std::vector<TH1D*>, m_kNGroups>& hdedxhit);

    void plotLayerDist(std::array<TH1D*, m_kNGroups>& hdedxlay);

    void plotQaPars(std::array<TH1D*, m_kNGroups>& hentalay, 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[m_kNGroups] = {"SL0", "SL1", "SL2-8"}; 
 
    std::vector<int> m_eaBinLocal; 
    std::array<std::vector<int>, m_kNGroups> m_binIndex; 
    std::array<std::vector<double>, m_kNGroups>m_binValue; 
 
    std::vector<std::vector<double>> m_onedcors; 
 
    DBObjPtr<CDCDedx1DCell> m_DBOneDCell; 
 
  };

} // namespace Belle2