Observable2D.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef OBSERVABLE2D_H
#define OBSERVABLE2D_H
 
#include "Observable.h"
#include <TH2D.h>
 
class Observable2D : public Observable {
public:
    
    Observable2D(const std::string name_i,
                 const std::string thname_i,
                 const std::string thname2_i,
                 const std::string label_i,
                 const std::string label2_i,
                 const bool tMCMC_i,
                 const double min_i,
                 const double max_i,
                 const double min2_i,
                 const double max2_i,
                 ThObservable * tho_i,
                 ThObservable * tho2_i);
    
    Observable2D();
    
    Observable2D(const Observable& o1d);
    
    Observable2D(const Observable2D& orig);
    
    virtual ~Observable2D();
    
    int ParseObservable2D(std::string& type, 
                           boost::tokenizer<boost::char_separator<char> >* tok, 
                           boost::tokenizer<boost::char_separator<char> >::iterator& beg,
                           std::string& infilename,
                           std::ifstream& ifile, 
                           int lineNo,
                           int rank);
 
    virtual void setLikelihoodFromHisto(std::string filename, std::string histoname);
 
    double computeTheoryValue2();
 
    std::string getLabel2() const
    {
        return label2;
    }
 
    void setLabel2(std::string label2)
    {
        this->label2 = label2;
    }
 
    double getMax2() const
    {
        return max2;
    }
 
    void setMax2(double max2)
    {
        this->max2 = max2;
    }
 
    double getMin2() const
    {
        return min2;
    }
 
    void setMin2(double min2)
    {
        this->min2 = min2;
    }
 
    std::string getThname2() const
    {
        return thname2;
    }
 
    void setThname2(std::string thname2)
    {
        this->thname2 = thname2;
    }
 
    ThObservable* getTho2() const
    {
        return tho2;
    }
 
    void setTho2(ThObservable* tho2_i)
    {
        tho2 = tho2_i;
        tho2->setBinMin(bin_min[1]);
        tho2->setBinMax(bin_max[1]);
    }
    
    void setTho1Tho2(ThObservable* tho1_i, ThObservable* tho2_i)
    {
        setTho(tho1_i, bin_min[0], bin_max[0]);
        setTho2(tho2_i);
    }
 
    virtual double computeWeight(double th1, double th2);
 
    virtual double computeWeight()
    {
        return computeWeight(computeTheoryValue(),computeTheoryValue2());
    }
    
    void setObsType2(std::string& obsType2_i)
    {
        obsType2 = obsType2_i;
    }
    
    std::string getObsType2() const
    {
        return obsType2;
    }
    
    double getAve2() const
    {
        return ave2;
    }
 
    void setAve2(double ave2)
    {
        this->ave2 = ave2;
    }
 
    double getErrf2() const
    {
        return errf2;
    }
 
    void setErrf2(double errf2)
    {
        this->errf2 = errf2;
    }
 
    double getErrg2() const
    {
        return errg2;
    }
 
    void setErrg2(double errg2)
    {
        this->errg2 = errg2;
    }
    
    bool isEOF()
    {
        return IsEOF;
    }
    
private:
    std::string thname2; 
    std::string label2; 
    double min2; 
    double max2; 
    double ave2; 
    double errg2; 
    double errf2; 
    double errgl2; 
    double errgr2; 
    std::string obsType2; 
    ThObservable * tho2; 
    TH2D * inhisto2d;  
    std::vector<double> bin_min; 
    std::vector<double> bin_max; 
    std::string filepath; 
    int iterationNo2; 
    double thValue2; 
    bool IsEOF; 
};
 
#endif  /* OBSERVABLE2D_H */