NueCCIncGlobalFitter.h

Go to the documentation of this file.

#pragma once 

#include "CAFAna/Analysis/Plots.h"

//ROOT Includes
#include "TH1.h"
#include "TH2.h"
#include "THStack.h"
#include "TCanvas.h"
#include "TLegend.h"
#include "TStyle.h"
#include "TFile.h"
#include <vector> 
#include <math.h>
#include "TLine.h"
#include "TFile.h"
#include "TTree.h"
#include "TCanvas.h"
#include "TF1.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TF2.h"
#include "TH2.h"
#include "TCutG.h"
#include "TMath.h"
#include "TCanvas.h"
#include "TStyle.h"
#include "TRandom.h"
#include "TGraph.h"
#include "TColor.h"
#include "TF3.h"
#include "TH3.h"
#include "TH3F.h"
#include "TMinuit.h"
#include "TLegend.h"
#include "THStack.h"
#include "TMatrix.h"
#include "TGraphErrors.h"
#include "TGraph.h"
#include "TDecompLU.h"
#include "TDecompSVD.h"
#include "TRandom.h"

//C++
#include <iostream>
#include <fstream>
#include <iomanip> 
#include <vector>
#include <cmath>
#include <math.h> 
#include <string>
#include <stdint.h>
#include <sstream>
#include <functional>
#include <stdexcept>

namespace nueccinc_test
{
  const int TotalXBins       = 8;
  const int TotalYBins       = 13;
  const int TotalZBins       = 17;
  const int TotalYZBins      = TotalYBins * TotalZBins;
  const int numPIDBins       = 1768;
  const int numberParameters = 40;

  class NueCCIncGlobalFitter{
  public:
    NueCCIncGlobalFitter(TH1F* da,
                         std::vector<TH1F*> templates,
                         std::vector<TH3F*> analysis,
                         TH1F* cv,
                         std::vector<TH1F*> systs_up,
                         std::vector<TH1F*> systs_down,
                         std::vector<TH1F*> systs_oneside,
                         std::vector<TH1F*> multiverse);
    virtual ~NueCCIncGlobalFitter() {};

    void FCNMinuit();
    std::vector<TH3F*> doFullFit();
    std::vector<TH1F*> getFullTemplates(bool isReduced);
    std::vector<TH1F*> getFullFitTemplates();
    TH2F* getCovarianceMatrix();
    TH2F* getCovarianceMatrixReduced();
    TH2F* getCorrelationMatrix();
    TH2F* getCorrelationMatrixReduced();
    TH2F* getFitParameterCovariance();
    TH2F* getFitParameterCorrelation();
    std::vector<std::pair<TH2F*,TH2F*>> GetTemplateWeightsAndErrors();



    TH2F* parNumMin;
    TH2F* parNumMax;
    TH2F* reducedBinsMin;
    TH2F* numu_normalization;
    TH2F* numu_uncertainty;
    TH2F* nue_normalization;
    TH2F* nue_uncertainty;
    TH2F* nc_normalization;
    TH2F* nc_uncertainty;
    double chisquared; 

    std::vector<std::vector<double>> parCovariance;
    std::vector<std::vector<double>> parCorrelation;    


  private:
    bool CheckSystsSize();
    void FillValueHolders();
    std::vector<TH1F*> CalculateOneSigmaShiftFull();
    void FillCovarianceMatrixFull(bool makePlots = false);
    void FillStatisticalCovarianceMatrixFull();
    double GetCovarianceMatrixFullValue(int binx, int biny);
    double GetStatisticMatrixFullValue(int binx, int biny);
    void ReducePhaseSpace();
    std::vector<TH1F*> CalculateOneSigmaShiftReduced();
    void FillCovarianceMatrixReduced(bool makePlots = false);
    void FillStatisticalCovarianceMatrixReduced();
    double GetCovarianceMatrixReducedValue(int binx, int biny);
    double GetStatisticMatrixReducedValue(int binx, int biny);
    void InvertCovarianceMatrix();
    void InitializeFitParameters();
    std::pair<float,float> searchFitInfo(float parNum,
                                         std::string fitSearch);
    static void fcn(Int_t &npar, Double_t *gin,Double_t &f,
                    Double_t *par,Int_t iflag);
    double myFunction(std::vector<double> par);
    void FillParameterCovariance(std::vector<std::vector<double>> cov);
    void PropagateFitUncertainty();
    std::vector<TH1F*> GetTemplates();
    std::vector<TH1F*> GetTemplatesReduced();
    std::vector<TH1F*> GetTemplatesReducedPostFit();
    std::vector<TH3F*> GetAnalysisTemplates();


    TH1F* hData1D;
    std::vector<TH1F*> hTemplates1D;
    std::vector<TH3F*> hAnalysis3D;
    TH1F* hCV1D;
    std::vector<TH1F*> hSystsUp1D;
    std::vector<TH1F*> hSystsDown1D;
    std::vector<TH1F*> hSystsOneSided;
    std::vector<TH1F*> hSystsMultiverse;

    std::vector<float> vDataValues;
    std::vector<float> vMCValues;
    std::vector<float> vSignalLike_Values;
    std::vector<float> vNC_Values;    
    std::vector<float> vNumuLike_Values;
    std::vector<float> vOther_Values;

    std::vector<std::vector<float>> vCovarianceMatrixFull;
    std::vector<std::vector<float>> vStatCovarianceMatrixFull;

    //Reduced Phase Space Histograms
    TH1F* hData1DReduced;
    std::vector<TH1F*> hTemplates1DReduced;
    TH1F* hCV1DReduced;
    std::vector<TH1F*> hSystsUp1DReduced;
    std::vector<TH1F*> hSystsDown1DReduced;
    std::vector<TH1F*> hSystsOneSidedReduced;
    std::vector<TH1F*> hSystsMultiverseReduced;

    std::vector<float> vDataValuesReduced;
    std::vector<float> vMCValuesReduced;
    std::vector<float> vSignalLike_ValuesReduced;
    std::vector<float> vNC_ValuesReduced;    
    std::vector<float> vNumuLike_ValuesReduced;
    std::vector<float> vOther_ValuesReduced;

    std::vector<std::vector<float>> vCovarianceMatrixReduced;
    std::vector<std::vector<float>> vStatCovarianceMatrixReduced;
    std::vector<std::vector<float>> vInvertedCovarianceMatrixReduced;


  };//end class
}