BCModel.h

Go to the documentation of this file.

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

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

#ifndef __BCMODEL__H
#define __BCMODEL__H

#include <vector>
#include <string>

#include <TROOT.h>
#include <TGraph.h>
#include <TCanvas.h>
#include <TPostScript.h>

#include "BCDataPoint.h"
#include "BCDataSet.h"
#include "BCParameter.h"
#include "BCH1D.h"
#include "BCH2D.h"
#include "BCIntegrate.h"

const int MAXNDATAPOINTVALUES = 20;

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

class BCModel : public BCIntegrate
{
  
 public:
  
   /* @{ */ 

   BCModel(); 

   BCModel(const char * name); 

   virtual ~BCModel(); 

   /* @} */ 

   /* @{ */ 

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

   int GetIndex()
   { return fIndex; }; 

   double GetModelAPrioriProbability()
   { return fModelAPriori; }; 

   double GetModelAPosterioriProbability() 
   { return fModelAPosteriori; }; 

   double GetNormalization()
   { return fNormalization; };

   BCDataSet* GetDataSet()
      { return fDataSet; }; 

   BCDataPoint* GetDataPointLowerBoundaries() 
      { return fDataPointLowerBoundaries; }; 

   BCDataPoint* GetDataPointUpperBoundaries() 
      { return fDataPointUpperBoundaries; }; 

   double GetDataPointLowerBoundary(int index)
   { return fDataPointLowerBoundaries -> GetValue(index); }; 

   double GetDataPointUpperBoundary(int index)
   { return fDataPointUpperBoundaries -> GetValue(index); }; 

   /*
    * Checks if the boundaries have been defined 
    * @return true, if the boundaries have been set, false otherwise 
    */ 
   bool GetFlagBoundaries(); 

   int GetNDataPoints(); 

   BCDataPoint* GetDataPoint(int index); 

   int GetNDataPointsMinimum()
   { return fNDataPointsMinimum; }; 

   int GetNDataPointsMaximum()
   { return fNDataPointsMaximum; }; 

   int GetNParameters()
   { return fParameterSet -> size(); }; 

   BCParameter* GetParameter(int index); 

   BCParameter* GetParameter(const char * name); 

   double GetBestFitParameter(int index)
   { return fBestFitParameters.at(index); }; 

   std::vector <double> GetBestFitParameters() 
      { return fBestFitParameters; }; 

   double GetBestFitParameterMarginalized(int index) 
   { return fBestFitParametersMarginalized.at(index); }; 

   std::vector <double> GetBestFitParametersMarginalized() 
      { return fBestFitParametersMarginalized; }; 

   TH2D * GetErrorBandXY()
      { return fErrorBandXY; };

   std::vector <double> GetErrorBand(double level); 

   TGraph * GetErrorBandGraph(double level1, double level2); 

   TGraph * GetFitFunctionGraph(std::vector <double> parameters);

   TGraph * GetFitFunctionGraph()
      { return this -> GetFitFunctionGraph(this -> GetBestFitParameters()); };

   TGraph * GetFitFunctionGraph(std::vector <double> parameters, double xmin, double xmax, int n=1000);

   bool GetFixedDataAxis(int index); 

   /* @} */ 

   /* @{ */ 

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

   void SetIndex(int index) 
   { fIndex = index; }; 

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

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

   void SetNormalization(double norm)
   { fNormalization = norm; };

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

   void SetSingleDataPoint(BCDataPoint * datapoint); 

   void SetSingleDataPoint(BCDataSet * dataset, int index); 

   void SetNDataPointsMinimum(int minimum)
   { fNDataPointsMinimum = minimum; }; 

   void SetNDataPointsMaximum(int maximum)
   { fNDataPointsMaximum = maximum; }; 

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

   void SetErrorBandContinuous(bool flag); 

   /* @} */ 

   /* @{ */ 

   int AddParameter(const char * name, double lowerlimit, double upperlimit); 

   int AddParameter(BCParameter* parameter); 

   virtual void DefineParameters() 
   { ;}; 

   double APrioriProbability(std::vector <double> parameters) 
   { return exp( this->LogAPrioriProbability(parameters) ); };

   virtual double LogAPrioriProbability(std::vector <double> parameters) 
   { return 1.0; };

   double Likelihood(std::vector <double> parameter)
   { return exp( this->LogLikelihood(parameter) ); };

   virtual double LogLikelihood(std::vector <double> parameter); 

   double ProbabilityNN(std::vector <double> parameter)
   { return exp( this->LogProbabilityNN(parameter) ); };

   double LogProbabilityNN(std::vector <double> parameter); 

   double Probability(std::vector <double> parameter)
   { return exp( this->LogProbability(parameter) ); };

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

   double ConditionalProbabilityEntry(BCDataPoint * datapoint, std::vector <double> parameters)
   { return exp( this->LogConditionalProbabilityEntry(datapoint, parameters) ); };

   virtual double LogConditionalProbabilityEntry(BCDataPoint * datapoint, std::vector <double> parameters)
   { flag_ConditionalProbabilityEntry = false; return 0.; };

   double PoissonProbability(int nentries, std::vector <double> parameters) 
   { return exp( this->LogPoissonProbability(nentries, parameters) ); }; 

   virtual double LogPoissonProbability(int nentries, std::vector <double> parameters) 
   { return .0; }; 

   void CalculateErrorBandXY(int nx, double xmin, double xmax, int ny, double ymin, double ymax, int niter); 

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

   double Eval(std::vector <double> parameters)
   { return exp( this->LogEval(parameters) ); };

  double LogEval(std::vector <double> parameters);

   double EvalSampling(std::vector <double> parameters);

   double Normalize();

   int CheckParameters(std::vector <double> parameters);

   void FindMode();
// void FindMode(int flag = 0);

   void WriteMode(const char * file);

   int ReadMode(const char * file);

   int ReadMarginalizedFromFile(const char * file);

   int ReadErrorBandFromFile(const char * file);

   BCH1D * MarginalizeProbability(BCParameter* parameter);

   BCH1D * MarginalizeProbability(const char * name) 
      { return this -> MarginalizeProbability(this -> GetParameter(name)); }; 

   BCH2D * MarginalizeProbability(BCParameter * parameter1, BCParameter * parameter2);

   BCH2D * MarginalizeProbability(const char * name1, const char * name2)
      { return this -> MarginalizeProbability(this -> GetParameter(name1), this -> GetParameter(name2)); };

   int MarginalizeAll();

   BCH1D * GetMarginalized(BCParameter * parameter);

   BCH1D * GetMarginalized(const char * name)
      { return this -> GetMarginalized(this -> GetParameter(name)); };

   BCH2D * GetMarginalized(BCParameter * parameter1, BCParameter * parameter2);

   BCH2D * GetMarginalized(const char * name1, const char * name2)
      { return this -> GetMarginalized(this -> GetParameter(name1), this -> GetParameter(name2)); };

   int PrintAllMarginalized1D(const char * filebase);
   int PrintAllMarginalized2D(const char * filebase);
   int PrintAllMarginalized(const char * file, int hdiv=1, int ndiv=1);

   void CreateData(int ndatasets, std::vector <double> parameters); 

   void CreateDataGrid(int ndatasets, std::vector <double> parameters, std::vector <bool> grid, std::vector <double> limits); 


   void CreateDataGridROOT(int ndatasets, std::vector <double> parameters, std::vector <bool> grid, std::vector <double> limits); 

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

   BCH1D * GoodnessOfFitTest(const char * filenname, std::vector <double> parameters);

   BCH1D * DoGoodnessOfFitTest(int ndatasets, std::vector<double> parameters, std::vector <bool> grid, std::vector <double> limits);
   BCH1D * DoGoodnessOfFitTest(int ndatasets, std::vector<double> parameters);
   BCH1D * DoGoodnessOfFitTest(int ndatasets);
   BCH1D * DoGoodnessOfFitTest(const char * filename);
   BCH1D * DoGoodnessOfFitTest(const char * filename, std::vector<double> parameters); 
   BCH1D * DoGoodnessOfFitTestROOT(int ndatasets, std::vector<double> parameters, std::vector <bool> grid, std::vector <double> limits);
   BCH1D * GoodnessOfFitTestROOT(int ndatasets, const char * filename, std::vector <double> parameters); 

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

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

   /*
    * @return The p-value 
    */ 
   double GetPValue() 
   { return fPValue; }; 

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

   void PrintSummary(); 

   void PrintResults(const char * file); 

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

   void FixDataAxis(int index, bool fixed); 

   /* @} */ 

 protected:

   int fIndex; 

   std::string fName; 

   double fModelAPriori;

   double fModelAPosteriori; 

   BCParameterSet * fParameterSet;

   BCDataSet * fDataSet;
  
   int fNDataPointsMinimum; 

   int fNDataPointsMaximum; 

   /*
    * A flag for overloading ConditionalProbabilityEntry
    */ 
   bool flag_ConditionalProbabilityEntry;

   double fPValue; 

 private:

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

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

   double fNormalization; 

}; 

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

typedef std::vector<BCModel*> BCModelContainer; 

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

#endif 

---