Observable.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 */

#ifndef OBSERVABLE_H
#define OBSERVABLE_H

#include "ThObservable.h"
#include <string>
#include <iostream>
#include <TH1D.h>
#include <TMatrixD.h>
#include <boost/tokenizer.hpp>

class Observable {
public:
    Observable(const std::string name_i,
               const std::string thname_i,
               const std::string label_i,
               const bool tMCMC_i,
               const double min_i,
               const double max_i,
               ThObservable * tho_i);
    
    Observable(const Observable& orig);
    
    Observable();
    
    boost::tokenizer<boost::char_separator<char> >::iterator &  ParseObservable(std::string& type,
                                                                                boost::tokenizer<boost::char_separator<char> >* tok, 
                                                                                boost::tokenizer<boost::char_separator<char> >::iterator & beg, 
                                                                                std::string& filepath, 
                                                                                std::string& infilename,
                                                                                int rank);
    
    virtual ~Observable();
    
    double computeTheoryValue();

    virtual double computeWeight(double th);
    
    virtual double computeWeight(double th, double ave_i, double errg_i, double errf_i);
    
    virtual double computeWeight(double th1, double th2)
    {
        return 0.0;
    };

    virtual double computeWeight()
    {
        return computeWeight(computeTheoryValue());
    }

    double getAve() const
    {
        return ave;
    }

    void setAve(double ave)
    {
        this->ave = ave;
    }

    std::string getDistr() const
    {
        return distr;
    }

    void setDistr(std::string distr)
    {
        this->distr = distr;
    }

    double getErrf() const
    {
        return errf;
    }

    void setErrf(double errf)
    {
        this->errf = errf;
    }

    double getErrg() const
    {
        return errg;
    }

    void setErrg(double errg)
    {
        this->errg = errg;
    }

    std::string getFilename() const
    {
        return filename;
    }
    
    void setFilename(std::string filename_i)
    {
        filename = filename_i;
    }
    
    virtual void setLikelihoodFromHisto(std::string filename, std::string histoname);

    virtual void setParametricLikelihood(std::string filename)
    {
        this->filename=filename; //real implementation will be done in extension
    }
    
    virtual void setParametricLikelihood(std::string filename, std::vector<ThObservable*> thObsV)
    {};

    std::string getHistoname() const
    {
        return histoname;
    }
    
    void setHistoname(std::string histoname_i)
    {
        histoname = histoname_i;
    }

    std::string getLabel() const
    {
        return label;
    }

    void setLabel(std::string label)
    {
        this->label = label;
    }

    double getMax() const
    {
        return max;
    }

    void setMax(double max)
    {
        this->max = max;
    }
    
    double getMin() const 
    {
        return min;
    }
    
    void setMin(double min) 
    {
        this->min = min;
    }

    std::string getName() const
    {
        return name;
    }

    void setName(std::string name)
    {
        this->name = name;
    }

    bool isTMCMC() const
    {
        return tMCMC;
    }

    void setTMCMC(bool tMCMC)
    {
        this->tMCMC = tMCMC;
    }

    std::string getThname() const
    {
        return thname;
    }

    void setThname(std::string thname)
    {
        this->thname = thname;
    }

    ThObservable* getTho() const
    {
        return tho;
    }
    
    void setObsType(std::string& obsType_s)
    {
        obsType = obsType_s;
    }
    
    std::string getObsType() const
    {
        return obsType;
    }

    void setTho(ThObservable* tho_i)
    {
        tho = tho_i;
        tho->setBinMin(bin_min);
        tho->setBinMax(bin_max);
    }
    
    void setTho(ThObservable* tho_i, double bmin, double bmax)
    {
        tho = tho_i;
        tho->setBinMin(bmin);
        tho->setBinMax(bmax);
    }
    
    double LogSplitGaussian(double x, double ave, double errl, double errr);
    
    double LogGaussian(double x, double ave, double sigma);
    
    virtual void getTheoryValues(std::vector<double>& theoryValues_i) {}; 
    
    virtual int getNTheoryValues() { return 0; }; 
    
    virtual int getNChannels() { return 0; }; 
    
    virtual bool isNew() { return false; };

    friend std::ostream& operator<<(std::ostream& output, const Observable& o);

protected:
    ThObservable * tho; 
    std::string name; 
    std::string thname; 
    std::string label; 
    std::string distr; 
    std::string filename; 
    std::string histoname; 
    double ave; 
    double errg; 
    double errf; 
    double min; 
    double max; 
    bool tMCMC; 
    TH1D * inhisto; 
    std::string obsType; 
    double bin_min; 
    double bin_max; 
    int iterationNo; 
    double thValue; 
};


#endif  /* OBSERVABLE_H */