BCMTF.h

#ifndef __BCMTF__H
#define __BCMTF__H

/*
 * Copyright (C) 2007-2014, the BAT core developer team
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 * For documentation see http://mpp.mpg.de/bat
 */

// ---------------------------------------------------------

#include "../../BAT/BCModel.h"

#include <TH1D.h>

class BCMTFChannel;
class BCMTFProcess;
class BCMTFSystematic;
class TF1;

// ---------------------------------------------------------
class BCMTF : public BCModel
{

public:

        BCMTF();

        BCMTF(const char * name);

        ~BCMTF();

        int GetNChannels()
        { return fNChannels; };

        int GetNProcesses()
        { return fNProcesses; };

        int GetNSystematics()
        { return fNSystematics; };

        int GetChannelIndex(const char * name);

        int GetProcessIndex(const char * name);

        int GetSystematicIndex(const char * name);

        int GetParIndexProcess(int index)
        { return fProcessParIndexContainer.at(index); };

        int GetParIndexSystematic(int index)
        { return fSystematicParIndexContainer.at(index); };

        BCMTFChannel * GetChannel(int index)
        { return fChannelContainer.at(index); };

        BCMTFProcess * GetProcess(int index)
        { return fProcessContainer.at(index); };

        BCMTFSystematic * GetSystematic(int index)
        { return fSystematicContainer.at(index); };

        int SetData(const char * channelname, TH1D hist, double minimum=-1, double maximum=-1);

        int SetTemplate(const char * channelname, const char * processname, TH1D hist, double efficiency = 1., double norm = 1.);

        int SetTemplate(const char * channelname, const char * processname, std::vector<TF1 *> * funccont, int nbins, double efficiency = 1.);

        void SetExpectationFunction(int parindex, TF1 * func)
        { fExpectationFunctionContainer[parindex] = func; };

        int SetSystematicVariation(const char * channelname, const char * processname,  const char * systematicname, double variation_up, double variation_down);

        int SetSystematicVariation(const char * channelname, const char * processname,  const char * systematicname, TH1D hist_up, TH1D hist_down);

        int SetSystematicVariation(const char * channelname, const char * processname,  const char * systematicname, TH1D hist, TH1D hist_up, TH1D hist_down);

        void SetFlagEfficiencyConstraint(bool flag)
        { fFlagEfficiencyConstraint = flag; };

        int AddChannel(const char * name);

        int AddProcess(const char * name, double nmin = 0., double nmax = 1., int color = -1, int fillstyle = -1, int linestyle = -1);

        int AddSystematic(const char * name, double min = -5., double max = 5.);

        double Expectation(int channelindex, int binindex, const std::vector<double> & parameters);

        double ExpectationFunction(int parindex, int channelindex, int processindex, const std::vector<double> & parameters);

        // return efficiency for a channel, process and bin
        double Efficiency(int channelindex, int processindex, int binindex, const std::vector<double> & parameters);

        double Probability(int channelindex, int processindex, int binindex, const std::vector<double> & parameters);

        double CalculateChi2(int channelindex, const std::vector<double> & parameters);

        double CalculateChi2(const std::vector<double> & parameters);

        double CalculateCash(int channelindex, const std::vector<double> & parameters);

        double CalculateCash(const std::vector<double> & parameters);

        double CalculatePValue(int channelindex, const std::vector<double> & parameters);

        double CalculatePValue(const std::vector<double> & parameters);

        int PrintSummary(const char * filename = "summary.txt");

        int PrintStack(int channelindex, const std::vector<double> & parameters, const char * filename = "stack.pdf", const char * options = "e1b0stack");

        int PrintStack(const char * channelname, const std::vector<double> & parameters, const char * filename = "stack.pdf", const char * options = "e1b0stack");

        double LogLikelihood(const std::vector<double> & parameters);

        void MCMCUserIterationInterface();

private:

        std::vector<BCMTFChannel *> fChannelContainer;

        std::vector<BCMTFProcess *> fProcessContainer;

        std::vector<BCMTFSystematic *> fSystematicContainer;

        int fNChannels;

        int fNProcesses;

        int fNSystematics;

        std::vector<int> fProcessParIndexContainer;

        std::vector<int> fSystematicParIndexContainer;

        bool fFlagEfficiencyConstraint;

        std::vector<TF1 *> fExpectationFunctionContainer;

};
// ---------------------------------------------------------

#endif