BCMTF.h

#ifndef __BCMTF__H
#define __BCMTF__H

/*
 * Copyright (C) 2007-2018, 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(const std::string& name = "multi_template_fitter");

    ~BCMTF();

    int GetNChannels() const
    { return fNChannels; };

    int GetNProcesses() const
    { return fNProcesses; };

    int GetNSystematics() const
    { return fNSystematics; };

    int GetChannelIndex(const std::string& name) const;

    int GetProcessIndex(const std::string& name) const;

    int GetSystematicIndex(const std::string& name) const;

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

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

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

    double GetPValue() const
    { return fPValue; }

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

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

    void SetData(const std::string& channelname, TH1D hist, double minimum = -1, double maximum = -1);

    void SetTemplate(const std::string& channelname, const std::string& processname, TH1D hist, double efficiency = 1., double norm = 1.);

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

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

    void SetSystematicVariation(const std::string& channelname, const std::string& processname,  const std::string& systematicname, double variation_up, double variation_down);

    void SetSystematicVariation(const std::string& channelname, const std::string& processname,  const std::string& systematicname, TH1D hist_up, TH1D hist_down);

    void SetSystematicVariation(const std::string& channelname, const std::string& processname,  const std::string& systematicname, TH1D hist, TH1D hist_up, TH1D hist_down);

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

    void AddChannel(const std::string& name);

    void AddProcess(const std::string& name, double nmin = 0., double nmax = 1., int color = -1, int fillstyle = -1, int linestyle = -1);

    void AddSystematic(const std::string& 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);

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

    // avoid accidental hiding
    using BCModel::Probability;

    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);

    void PrintFitSummary();

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

    void PrintStack(const std::string& channelname, const std::vector<double>& parameters, const std::string& filename = "stack.pdf", const std::string& options = "e1b0stack")
    {
        return PrintStack(GetChannelIndex(channelname), parameters, filename, options);
    }

    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;

    double fPValue;

    BCMTF(const BCMTF&);

    BCMTF& operator=(const BCMTF&);

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

#endif