SpaceResolutionCalibration.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.                  *
 **************************************************************************/
#include <TH1F.h>
#include <TH2F.h>
#include <TGraphErrors.h>
#include <TF1.h>
#include <framework/database/DBObjPtr.h>
#include <cdc/dbobjects/CDCSpaceResols.h>
 
namespace Belle2 {
  namespace CDC {
 
    class SpaceResolutionCalibration {
      //      typedef std::array<float, 3> array3; /**< angle bin info. */
    public:
      SpaceResolutionCalibration();
      virtual ~SpaceResolutionCalibration() {}
      virtual void setDebug(bool debug = false) {m_debug = debug; }
      virtual void setUseDB(bool useDB = false) {m_useDB = useDB; }
      virtual void setMinimumNDF(double minndf) {m_ndfmin = minndf;}
      virtual void setMinimumPval(double minPval) {m_Pvalmin = minPval;}
      virtual void setBinWidth(double bw) {m_binWidth = bw;}
      virtual void BField(bool bfield) {m_BField = bfield;}
      virtual void inputFileNames(std::string inputname)
      {
        m_inputRootFileNames.assign(inputname);
      }
      virtual void setStoreHisto(bool storeHist = false) {m_storeHisto = storeHist;}
      virtual void ProfileFileNames(std::string profileFileName)
      {
        m_ProfileFileName.assign(profileFileName);
      }
      virtual void useProfileFromInputSigma(bool useProfileFromInputSigma)
      {
        m_useProfileFromInputSigma = useProfileFromInputSigma;
      }
      virtual void setSigmaFileName(std::string name) {m_sigmafile.assign(name);}
      //      virtual void setMode(unsigned short mode=1){m_SigmaParamMode = mode;}
      void execute()
      {
        calibrate();
      }
 
    protected:
      virtual bool calibrate();
      virtual void createHisto();
      virtual void readProfile();
      virtual void readSigma();
      virtual void readSigmaFromDB();
      virtual void readSigmaFromText();
      virtual void storeHisto();
      virtual void write();
 
    private:
      static const int Max_nalpha = 18; 
      static const int Max_ntheta = 7; 
      static const unsigned short Max_np = 40; 
      double m_ndfmin = 5; 
      double m_Pvalmin = 0.; 
      double m_binWidth = 0.05; 
      bool m_debug = false;   
      //bool m_draw = false;    /**< print out histogram in pdf file or not*/
      bool m_storeHisto = false; 
      bool m_useDB = false;     
      bool m_useProfileFromInputSigma = true; 
      bool m_BField = true;                   
      //      bool m_LRseparate = true;
      double sigma_old[56][2][18][7][8]; 
      double sigma_new[56][2][18][7][8]; 
      //TF1* ffit[56][2][18][7];           /**< fitting function*/
      TGraphErrors* gfit[56][2][18][7];  
      TGraphErrors* gr[56][2][18][7];    
      TH2F* hist_b[56][2][Max_nalpha][Max_ntheta]; 
      TH2F* hist_u[56][2][Max_nalpha][Max_ntheta]; 
      TH1F* hu_m[56][2][Max_nalpha][Max_ntheta]; 
      TH1F* hu_s[56][2][Max_nalpha][Max_ntheta]; 
      TH1F* hb_m[56][2][Max_nalpha][Max_ntheta]; 
      TH1F* hb_s[56][2][Max_nalpha][Max_ntheta]; 
      int m_fitflag[56][2][Max_nalpha][Max_ntheta] = {{{{0}}}} ; 
      std::string m_outputSigmaFileName = "sigma_new.dat"; 
      std::string m_inputRootFileNames = "rootfile/output*"; 
      std::string m_ProfileFileName = "sigma_profile"; 
      DBObjPtr<CDCSpaceResols>* m_sResolFromDB ;         
      std::string m_sigmafile = "cdc/data/sigma.dat";    
      //int m_firstExperiment; /**< First experiment. */
      //int m_firstRun; /**< First run. */
      //int m_lastExperiment; /**< Last experiment */
      //int m_lastRun; /**< Last run. */
 
      int m_nalpha; 
      int m_ntheta;
      double l_alpha[18];
      double u_alpha[18];
      double ialpha[18]; 
      double l_theta[7]; 
      double u_theta[7];
      double itheta[7]; 
      int nalpha_old; 
      int ntheta_old;
      double l_alpha_old[18];
      double u_alpha_old[18];
      double ialpha_old[18]; 
      double l_theta_old[7]; 
      double u_theta_old[7];
      double itheta_old[7]; 
      unsigned short m_sigmaParamMode_old; 
      //unsigned short m_sigmaParamMode = 1; /**< sigma mode for this calibration.*/
 
      double getUpperBoundaryForFit(TGraphErrors* graph)
      {
        double ymax = 0;
        double xmax = 0;
        int imax = 0;
        double x, y;
        int unCount = floor(0.05 / m_binWidth);
        int N = graph->GetN();
        int Nstart = floor(0.5 * (N - unCount));
        int Nend = N - unCount;
        for (int i  = Nstart; i < Nend; ++i) {
          graph->GetPoint(i, x, y);
          if (graph->GetErrorY(i) > 0.06E-3) continue;
          if (y > ymax) {
            xmax = x; ymax = y;
            imax = i;
          }
        }
        if (imax <= Nstart) {
          graph->GetPoint(Nend, x, y);
          xmax = x;
        }
        return xmax;
      }
 
    };
  }
}