CDCDedxHadBGAlgorithm.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 <map>
#include <vector>
#include <iostream>
#include <fstream>
 
#include <calibration/CalibrationAlgorithm.h>
#include <framework/database/DBObjPtr.h>
#include <framework/gearbox/Const.h>
 
#include <cdc/utilities/CDCDedxMeanPred.h>
#include <cdc/utilities/CDCDedxSigmaPred.h>
#include <cdc/utilities/CDCDedxHadSat.h>
 
#include <cdc/dbobjects/CDCDedxMeanPars.h>
#include <cdc/dbobjects/CDCDedxSigmaPars.h>
 
#include <cdc/calibration/CDCdEdx/HadronBgPrep.h>
#include <cdc/calibration/CDCdEdx/HadronCalibration.h>
 
namespace Belle2 {

  class CDCDedxHadBGAlgorithm : public CalibrationAlgorithm {
 
  public:

    CDCDedxHadBGAlgorithm();

    virtual ~CDCDedxHadBGAlgorithm() override {}

    void setMonitoringPlots(bool value) {m_ismakePlots = value;}

    void setNumIterations(int value) {m_iter = value;}

    void setProtonCut(double value) {m_cut = value;}

    void setBGPars(const std::string& particle, double nbin, double min, double max)
    {
      m_bgpar[particle][0] = nbin;
      m_bgpar[particle][1] = min;
      m_bgpar[particle][2] = max;
    }

    void setInjectionPars(const std::string& particle, double nbin, double min, double max)
    {
      m_injpar[particle][0] = nbin;
      m_injpar[particle][1] = min;
      m_injpar[particle][2] = max;
    }

    void setCosBin(const std::string& particle, double nbin) { m_cospar[particle] = nbin; }

    void setCosPars(double min, double max) { m_cosMin = min; m_cosMax = max; }

    void getExpRunInfo();

    void createPayload();

    void SigmaFits(const std::vector<std::string >& particles, const std::string& sfx, const std::string& svar,
                   const bool makeIterationSummary);

    void prepareSample(const std::vector<std::string >& particles, const std::string& filename, const std::string& sfx,
                       const bool makeIterationSummary);
 
  protected:

    virtual EResult calibrate() override;
 
  private:
 
    std::map<std::string, std::array<double, 3>> m_bgpar = {
      {"muon", {12, 2.85, 28.85}},
      {"pion", {12, 0.9, 14.90}},
      {"kaon", {11, 1.0, 6.5}},
      {"proton", {20, 0.33, 0.85}},
      {"electron", {60, 500.0, 12500.0}}
    };  
 
    std::map<std::string, std::array<double, 3>> m_injpar = {
      {"electron", {40, 0, 80000}},
      {"pion", {10, 0, 48000}},
      {"kaon", {6, 0, 48000}},
      {"muon", {40, 0, 80000}},
      {"proton", {20, 0, 80000}}
    };  
 
    std::map<std::string, double> m_cospar = {
      {"electron", 24},
      {"pion", 18},
      {"kaon", 18},
      {"muon", 24},
      {"proton", 20}
    };  
 
    double m_cosMin = -0.84; 
    double m_cosMax = 0.96; 
 
    int m_nhitBins = 10; 
    double m_nhitMin = 7; 
    double m_nhitMax = 39; 
 
    double m_cut = 0.5;    
 
    bool m_ismakePlots; 
 
    std::string m_bgsigma;  
    std::string m_bgcurve;  
    std::string m_suffix; 
 
    int m_iter = 5;  
 
    DBObjPtr<CDCDedxMeanPars> m_DBMeanPars; 
    DBObjPtr<CDCDedxSigmaPars> m_DBSigmaPars; 
 
  };

} // namespace Belle2