InnerDetector/InDetValidation/InDetPhysValMonitoring/InDetPhysValMonitoring/ResolutionHelper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef IDPVM_ResolutionHelper_h
#define IDPVM_ResolutionHelper_h
 
#include <vector>
#include <string>
#include <utility>
 
#include "AthenaBaseComps/AthMessaging.h"
 
class TH1;
class TH2;
class TH1D;
/*
  Helper class to evaluate mean and RMS using dedicated methods
  useful eg for histograms with long tails etc.
*/
namespace IDPVM {
  
  class ResolutionHelper : public AthMessaging {
  public:
    ResolutionHelper();
    ~ResolutionHelper() {
      // nop
    };
    
    enum methods { iterRMS_convergence, Gauss_fit, fusion_iterRMS_Gaussfit };
 
    struct resolutionResultInBin{
      double width{0.};     
      double widthError{0.};  
      double mean{0.};    
      double meanError{0.};  
      double outlierFrac{0.};   
      double outlierFracError{0.};  
    };
 
    void makeResolutions(const TH2* h_input2D, TH1* hwidth, TH1* hmean, TH1* hproj[], bool saveProjections, IDPVM::ResolutionHelper::methods theMethod=IDPVM::ResolutionHelper::iterRMS_convergence);
    
    void makeResolutions(const TH2* h_input2D, TH1* hwidth, TH1* hmean, IDPVM::ResolutionHelper::methods theMethod=IDPVM::ResolutionHelper::iterRMS_convergence);
 
    resolutionResultInBin ResolutionHelperResultsModUnits(TH1D* p_input_hist, IDPVM::ResolutionHelper::methods theMethod=IDPVM::ResolutionHelper::iterRMS_convergence);
 
    
    void setResults(TH1* p_input_hist, methods p_method);
 
    double getMean() { return m_mean; };
    double getMeanError() { return m_meanError; };
    double getRMS() { return m_RMS; };
    double getRMSError() { return m_RMSError; };
    double getFracOut() { return m_FracOut; };
    double getFracOutUnc() { return m_FracOutUnc; };
    double getFracUOflow() { return m_FracUOflow; };
    static std::string reportUOBinVal(const std::string& p_histName, const std::vector< std::pair<unsigned int,double> >& p_vecBinVal);
 
    const std::vector<std::string>& getDebugs() { return m_debugs; };
    const std::vector<std::string>& getInfos() { return m_infos; };
    const std::vector<std::string>& getWarnings() { return m_warnings; };
    const std::vector<std::string>& getErrors() { return m_errors; };
  private:
    // use gaussian fit, return 0 in case of successful fit
    int setGaussFit(TH1* p_input_hist);
    int setIterativeConvergence(TH1* p_input_hist);
    void setFout(double p_nsig,double p_ntot);    
    void setLargeError();   
    bool initialize(TH1* p_input_hist);
 
 
 
    double m_mean{0.};
    double m_meanError{0.};
    double m_RMS{0.};
    double m_RMSError{0.};
    double m_FracOut{0.};
    double m_FracOutUnc{0.};
    double m_FracUOflow{0.};
 
    std::vector<std::string> m_debugs;
    std::vector<std::string> m_infos;
    std::vector<std::string> m_warnings;
    std::vector<std::string> m_errors;
    static void cloneHistogram(TH1D* h, TH1* hcopy);
    
    //helpers 
    std::string m_inHistName{""};
    // increase mean and RMS errors by this factor in case of ambiguous evaluation
    // ... eg in case we eg. exclude too many events during evaluation
    double m_largeErrorFact{10.};
    // maximum fraction of Under- and Overflow events we tolerate
    double m_maxUOflowFrac{0.05};
 
  };
} // end of namespace
#endif