CDCDedx2DCellAlgorithm.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 <calibration/CalibrationAlgorithm.h>
 
#include <TH1F.h>
 
#include <iostream>
 
namespace Belle2 {
  class CDCDedx2DCellAlgorithm : public CalibrationAlgorithm {
 
  public:

    CDCDedx2DCellAlgorithm();

    virtual ~CDCDedx2DCellAlgorithm() {}

    void setGlobalEntaBins(int value) {fnEntaBinG = value;}

    void setGlobalDocaBins(int value) {fnDocaBinG = value;}

    void setAsymmetricBins(bool value) {IsLocalBin = value;}

    void setRotationSymmetry(bool value) {IsRS = value;}

    void setOutFilePrefix(const std::string& value) {fSetPrefix = value;}

    void setMonitoringPlots(bool value = false) {IsMakePlots = value;}
    int GetRotationSymmericBin(int nbin, int ibin)
    {
 
      if (nbin % 4 != 0)return -1;
      int jbin;
      if (ibin <= nbin / 4) jbin = ibin + nbin / 2 ;
      else if (ibin > 3 * nbin / 4) jbin = ibin - nbin / 2 ;
      else jbin = ibin;
 
      return jbin;
    }

    void GetVariableBin(int nbin, std::vector<int>& nBinEnta0to100Per)
    {
 
      if (nbin % 8 != 0) {
        std::cout << "Please select global in multiple of 8 " << std::endl;
        return ;
      }
 
      int jbin = -1;
      std::vector<int> nBinEnta0to25Per;
      for (int ibin = 0; ibin < nbin / 4; ibin++) {
        if (ibin < nbin / 8) jbin++;
        else if (TMath::Abs(ibin - nbin / 8) % 2 == 0)jbin++;
        nBinEnta0to25Per.push_back(jbin);
      }
 
      std::vector<int> temp = nBinEnta0to25Per;
      std::reverse(temp.begin(), temp.end());
 
      std::vector<int> nBinEnta25to50Per; //second half (0 to pi/2)
      for (unsigned int it = 0; it < temp.size(); ++it)nBinEnta25to50Per.push_back(2 * jbin - temp.at(it) + 1);
 
      std::vector<int> nBinEnta0to50Per = nBinEnta0to25Per;
      nBinEnta0to50Per.insert(nBinEnta0to50Per.end(), nBinEnta25to50Per.begin(), nBinEnta25to50Per.end());
 
      std::vector<int> nBinEnta50to100Per;
      for (unsigned int it = 0; it < nBinEnta0to50Per.size(); ++it) {
        nBinEnta50to100Per.push_back(nBinEnta0to50Per.at(nBinEnta0to50Per.size() - 1) + nBinEnta0to50Per.at(it) + 1);
      }
 
      nBinEnta0to100Per = nBinEnta0to50Per;
      nBinEnta0to100Per.insert(nBinEnta0to100Per.end(), nBinEnta50to100Per.begin(), nBinEnta50to100Per.end());
 
      TH1F* tempEnta = new TH1F("tempEnta", "tempEnta", fnEntaBinG, feaLE, feaUE);
      fEntaBinValues.push_back(tempEnta->GetBinLowEdge(1)); //first and last manual
      for (unsigned int i = 0; i < nBinEnta0to100Per.size() - 1; ++i) {
        if (nBinEnta0to100Per.at(i) < nBinEnta0to100Per.at(i + 1)) {
          double binval = tempEnta->GetBinLowEdge(i + 1) + tempEnta->GetBinWidth(i + 1);
          if (TMath::Abs(binval) < 10e-5)binval = 0; //avoid infinite deep
          fEntaBinValues.push_back(binval);
        } else continue;
      }
      fEntaBinValues.push_back(tempEnta->GetBinLowEdge(fnEntaBinG) + tempEnta->GetBinWidth(fnEntaBinG));
      delete tempEnta;
    }
 
 
  protected:

    virtual EResult calibrate() override;
 
  private:

    int fnEntaBinG; 
    int fnDocaBinG; 
    int fnEntaBinL; 
    int fnDocaBinL;  
 
    Double_t feaLE; 
    Double_t feaUE; 
    Double_t feaBS; 
 
    Double_t fdocaLE; 
    Double_t fdocaUE; 
    Double_t fdocaBS; 
 
    std::string fSetPrefix; 
    std::vector<int> fDocaBinNums; 
    std::vector<double> fDocaBinValues;  
 
    std::vector<int> fEntaBinNums;  
    std::vector<double> fEntaBinValues;  
 
    bool IsLocalBin;  
    bool IsMakePlots; 
    bool IsRS; 
  };

} // namespace Belle2