CDCDedxCosLayerAlgorithm.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 <cdc/dbobjects/CDCDedxCosineCor.h>
#include <calibration/CalibrationAlgorithm.h>
#include <framework/database/DBObjPtr.h>
#include <TH1D.h>
#include <array>
#include <vector>
#include <TLegend.h>
 
namespace Belle2 {

  class CDCDedxCosLayerAlgorithm : public CalibrationAlgorithm {
 
  public:
 
    static constexpr int m_kNGroups = 3; 

    CDCDedxCosLayerAlgorithm();

    virtual ~CDCDedxCosLayerAlgorithm() {}

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

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

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

    void setMethodSep(bool value = true) {isMethodSep = value;}

    void setUseTruncForInner(bool value = false) { isUseTrunc = value; }

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

    void setCosineBins(unsigned int value = 100) {m_cosBin = value;}

    void setCosineRange(double min = -1.0, double max = 1.0) {m_cosMin = min; m_cosMax = max;}

    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 setSuffix(const std::string& value) {m_suffix = value;}

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

    void getExpRunInfo();

    void defineHisto(std::array<std::vector<TH1D*>, m_kNGroups>& hdedx, const std::string& tag, const std::string& chargeLabel);

    TH1D* defineCosthHist(const std::string& tag, const std::string& chargeLabel);

    void getTruncatedBins(TH1D* hist, int& binlow, int& binhigh);

    double getTruncationMean(TH1D* hist, int binlow, int binhigh);

    double extractCosMean(TH1D*& hist, int fixedLow = 1, int fixedHigh = 1);

    void createPayload();

    void plotdedxHist(std::array<std::vector<TH1D*>, m_kNGroups>& hdedx, const std::string& tag);

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

    void plotQaPars(TH1D* hCosth_all, TH1D* hCosth_pos, TH1D* hCosth_neg);

    void plotRelConst(const std::array<std::vector<double>, m_kNGroups>& cosine, int iter);

    void plotmeanChargeOverlay(const std::array<std::vector<double>, 3>& cosine_pos, const std::string& sltag, int iter);

    void plotConstants();

    void plotEventStats();
 
 
  protected:

    virtual EResult calibrate() override;
 
  private:
    bool isMethodSep; 
    bool isMakePlots; 
    bool isMerge; 
    bool isFixTrunc; 
    bool isUseTrunc; 
 
    double m_truncMin; 
    double m_truncMax; 
 
    unsigned int m_cosBin; 
    double m_cosMin; 
    double m_cosMax; 
 
    int m_dedxBin; 
    double m_dedxMin; 
    double m_dedxMax; 
 
    std::string m_suffix; 
    std::string m_runExp; 
 
    const std::array<std::string, m_kNGroups> m_label = {"SL0", "SL1", "SL2-8"}; 
 
    std::vector<std::vector<double>> m_coscors; 
 
    DBObjPtr<CDCDedxCosineCor> m_DBCosineCor; 
 
  };

} // namespace Belle2