BCMTF.h

Go to the documentation of this file.

#ifndef __BCMTF__H
#define __BCMTF__H

/*
 * Copyright (C) 2008-2012, Daniel Kollar and Kevin Kroeninger.
 * All rights reserved.
 *
 * For the licensing terms see doc/COPYING.
 */

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

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

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

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

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

      int PrintStack(const char * channelname, const std::vector<double> & parameters, const char * filename = "stack.eps", 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