HpsFitResult.h

Go to the documentation of this file.

#ifndef __HPS_FIT_RESULT_H__
#define __HPS_FIT_RESULT_H__
 
#include <TFitResult.h>
#include <TFitResultPtr.h>
 
#include "ChebyshevFitFunction.h"
#include "LegendreFitFunction.h"
 
class HpsFitResult { 
 
    public: 
 
        HpsFitResult(); 
 
        ~HpsFitResult(); 
 
        TFitResultPtr getBkgFitResult() { return bkg_result_; }; 
        
        TFitResultPtr getBkgToysFitResult() { return bkg_toy_result_; }; 
        
        TFitResultPtr getCompFitResult() { return comp_result_; }; 
 
        void addLikelihood(double likelihood) { _likelihoods.push_back(likelihood); }
 
        void addSignalYield(double signal_yield) { _signal_yields.push_back(signal_yield); }
 
        double getCorrectedMass() const { return _cmass; }; 
 
        double getIntegral() { return _integral; };
 
        double getMass() const { return mass_hypo_; };
 
        double getQ0() { return q0_; };
 
        double getPValue() { return p_value_; };
 
        double getFullBkgRate();
 
        double getFullBkgRateError();
 
        float getSignalYield() { return comp_result_->Parameter(poly_order_ + 1);  };
 
        float getSignalYieldErr() { return comp_result_->ParError(poly_order_ + 1); }; 
 
        double getUpperLimit() { return upper_limit_; };
 
        double getUpperLimitPValue() { return _upper_limit_p_value; };
 
        double getWindowSize() { return window_size_; }; 
 
        std::vector<double> getLikelihoods() { return _likelihoods; }
        
        std::vector<double> getSignalYields() { return _signal_yields; }
 
        //-------------//
        //   Setters   //
        //-------------//
 
        void setIntegral(double integral) { _integral = integral; };
 
        void setQ0(double q0) { q0_ = q0; };
 
        void setPValue(double p_value) { p_value_ = p_value; };  
 
        void setBkgFitResult(TFitResultPtr bkg_result) { bkg_result_ = bkg_result; };
 
        void setBkgToysFitResult(TFitResultPtr bkg_toy_result) { bkg_toy_result_ = bkg_toy_result; };
 
        void setCompFitResult(TFitResultPtr comp_result) { comp_result_ = comp_result; };
 
        void setMass(double mass) { mass_hypo_ = mass; };
 
        void setCorrectedMass(double cmass) { _cmass = cmass; };
 
        void setPolyOrder(int poly_order) { poly_order_ = poly_order; };
 
        void setBkgModelType(FitFunction::BkgModel bkg_model) { bkg_model_ = bkg_model; };
 
        void setUpperLimit(double upper_limit) { upper_limit_ = upper_limit; };
        
        void setUpperLimitPValue(double upper_limit_p_value) { _upper_limit_p_value = upper_limit_p_value; }
 
        void setWindowSize(double window_size) { window_size_ = window_size; }; 
 
        void setBinWidth(double bin_width) { bin_width_ = bin_width; }; 
 
    private: 
        TFitResultPtr bkg_result_{nullptr}; 
 
        TFitResultPtr bkg_toy_result_{nullptr}; 
 
        TFitResultPtr comp_result_{nullptr}; 
 
        std::vector<double> _likelihoods; 
 
        std::vector<double> _signal_yields; 
 
        double _integral{0};
 
        double mass_hypo_; 
 
        double _cmass{0}; 
 
        double q0_;
        
        double p_value_;
 
        double poly_order_{0};
 
        FitFunction::BkgModel bkg_model_{FitFunction::BkgModel::EXP_CHEBYSHEV};
 
        double upper_limit_; 
 
        double _upper_limit_p_value{-9999};
 
        /*** Size of the fit window. */
        double window_size_;
 
        /*** Size of the fit window. */
        double bin_width_;
 
}; // HpsFitResult
class HpsFitResult {…};
 
#endif // __HPS_FIT_RESULT_H__