BCModel.h

#ifndef __BCMODEL__H
#define __BCMODEL__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 "BCIntegrate.h"

#include <string>

// ROOT classes
class TNamed;
class TH1;
class TH2D;
class TGraph;
class TCanvas;
class TPostscript;
class TF1;

//BAT classes
class BCDataPoint;
class BCDataSet;
class BCParameter;
class BCH1D;
class BCH2D;

const int MAXNDATAPOINTVALUES = 20;

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

class BCModel : public BCIntegrate
{

   public:

      BCModel(const char * name="model");

      BCModel(const BCModel & bcmodel);

      virtual ~BCModel();

      BCModel & operator = (const BCModel & bcmodel);

      const std::string & GetName() const
         { return fName; }

      double GetModelAPrioriProbability() const
         { return fModelAPriori; }

      double GetModelAPosterioriProbability() const
         { return fModelAPosteriori; }

      BCDataSet* GetDataSet() const
         { return fDataSet; }

      BCDataPoint * GetDataPointLowerBoundaries() const
         { return fDataPointLowerBoundaries; }

      BCDataPoint* GetDataPointUpperBoundaries() const
         { return fDataPointUpperBoundaries; }

      double GetDataPointLowerBoundary(unsigned int index) const;

      double GetDataPointUpperBoundary(unsigned int index) const;

      bool GetFlagBoundaries() const;

      unsigned GetNDataPoints() const;

      BCDataPoint * GetDataPoint(unsigned int index) const;

      void SetName(const char * name)
         { fName = name; }

      void SetModelAPrioriProbability(double probability)
         { fModelAPriori = probability; }

      void SetModelAPosterioriProbability(double probability)
         { fModelAPosteriori = probability; }

      using BCEngineMCMC::AddParameter;

      virtual int AddParameter(BCParameter * parameter);

      void SetDataSet(BCDataSet* dataset)
         { fDataSet = dataset; }

      void SetSingleDataPoint(BCDataPoint * datapoint);

      void SetSingleDataPoint(BCDataSet * dataset, unsigned int index);

      void SetDataBoundaries(unsigned int index, double lowerboundary, double upperboundary, bool fixed=false);

      void SetDataPointLowerBoundaries(BCDataPoint * datasetlowerboundaries)
      { fDataPointLowerBoundaries = datasetlowerboundaries; }

      void SetDataPointUpperBoundaries(BCDataPoint * datasetupperboundaries)
      { fDataPointUpperBoundaries = datasetupperboundaries; }

      void SetDataPointLowerBoundary(int index, double lowerboundary);

      void SetDataPointUpperBoundary(int index, double upperboundary);

      int SetPrior(int index, TF1* f);

      int SetPrior(const char* name, TF1* f);

      int SetPriorDelta(int index, double value);

      int SetPriorDelta(const char* name, double value);

      int SetPriorGauss(int index, double mean, double sigma);

      int SetPriorGauss(const char* name, double mean, double sigma);

      int SetPriorGauss(int index, double mean, double sigmadown, double sigmaup);

      int SetPriorGauss(const char* name, double mean, double sigmadown, double sigmaup);

      int SetPrior(int index, TH1 * h, bool flag=false);

      int SetPrior(const char* name, TH1 * h, bool flag=false);

      int SetPriorConstant(int index);

      int SetPriorConstant(const char* name)
      { return SetPriorConstant(fParameters.Index(name)); }

      int SetPriorConstantAll();

      void Copy(const BCModel & bcmodel);

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

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

      virtual double Likelihood(const std::vector<double> &params);

      virtual double LogLikelihood(const std::vector<double> &params) = 0;

      double ProbabilityNN(const std::vector<double> &params);

      double LogProbabilityNN(const std::vector<double> &parameters)
      { return LogLikelihood(parameters) + LogAPrioriProbability(parameters); }

      double Probability(const std::vector<double> &parameter);

      double LogProbability(const std::vector<double> &parameter);

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

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

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

      virtual void CorrelateDataPointValues(std::vector<double> &x);

      double GetPvalueFromChi2(const std::vector<double> &par, int sigma_index);

      double GetPvalueFromKolmogorov(const std::vector<double>& par, int index);

      double GetPvalueFromChi2NDoF(std::vector<double> par, int sigma_index);

      BCH1D * CalculatePValue(std::vector<double> par, bool flag_histogram=false);

      double GetPValue()
         { return fPValue; }

      double GetPValueNDoF()
         { return fPValueNDoF; }

      double GetChi2NDoF()
         { return fChi2NDoF; }

      std::vector<double> GetChi2Runs(int dataIndex, int sigmaIndex);

      void SetGoFNIterationsMax(int n)
         { fGoFNIterationsMax=n; }

      void SetGoFNIterationsRun(int n)
         { fGoFNIterationsRun=n; }

      void SetGoFNChains(int n)
         { fGoFNChains=n; }

      double HessianMatrixElement(const BCParameter * parameter1, const BCParameter * parameter2, std::vector<double> point);

      void PrintSummary();

      void PrintResults(const char * file);

      void PrintShortFitSummary(int chi2flag=0);

      void PrintHessianMatrix(std::vector<double> parameters);

      virtual double CDF(const std::vector<double>& /*parameters*/,  int /*index*/, bool /*lower=false*/)
      {return 0.0;}

   protected:
      std::string fName;

      double fModelAPriori;

      double fModelAPosteriori;

      BCDataSet * fDataSet;

      BCDataPoint * fDataPointLowerBoundaries;

      BCDataPoint * fDataPointUpperBoundaries;

      std::vector<bool> fDataFixedValues;

      double fPValue;

      double fChi2NDoF;
      double fPValueNDoF;

      bool flag_discrete;

      int fGoFNIterationsMax;

      int fGoFNIterationsRun;

      int fGoFNChains;

      std::vector<TNamed*> fPriorContainer;

      bool fPriorConstantAll;

      std::vector<bool> fPriorContainerConstant;

      std::vector<bool> fPriorContainerInterpolate;

   private:

      int CompareStrings(const char * string1, const char * string2);

      BCDataPoint * VectorToDataPoint(const std::vector<double> &data);
};

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

typedef std::vector<BCModel*> BCModelContainer;

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

#endif