NuXFitAnalysis Class Reference

#include <NuXFitAnalysis.h>

List of all members.

Public Member Functions

 NuXFitAnalysis ()
 NuXFitAnalysis (const NuXMLConfig &xmlConfig)
virtual ~NuXFitAnalysis ()
virtual double operator() (const std::vector< double > &x) const
virtual double Up () const
virtual void SetErrorDef (const Double_t up)
virtual Double_t CalculateLikelihood () const
Double_t CalculateLikelihood (const TH1D *fdPred, const TH1D *fdData) const
virtual void CrossSectionFileName (const std::string xSecFileName)
virtual void DoGridSearch (const Bool_t doGridSearch)
virtual void FDData (const std::string fdDataFileName)
virtual void FDNuMuCCData (const TH1D &fdData)
virtual void FDNuMuBarCCData (const TH1D &fdData)
virtual void FDDataPoT (const Double_t pot)
virtual void FDMC (const std::string fdMCFileName)
virtual void FDRecoENuMuCCBins (const std::vector< Double_t > vFDRecoENuMuCCBins)
virtual void FDRecoENuMuBarCCBins (const std::vector< Double_t > vFDRecoENuMuBarCCBins)
virtual void FillCPTFDPrediction (const std::vector< double > &par) const
virtual void FillTransitionFDPrediction (const vector< double > &par) const
virtual void NDFitResults (const std::vector< Double_t > xSecWeights)
virtual void NDFitBinningNuMuCC (const std::vector< Double_t > trueEBins)
virtual void NDFitBinningNuMuBarCC (const std::vector< Double_t > trueEBins)
virtual void OutputFileName (const std::string outFile)
virtual void SelectionEfficiencyFileName (const std::string selEffFileName)
virtual void SelectionScheme (const NuCuts::NuAnaVersion_t anaVersion=NuCuts::kCC0250Std)
virtual void ConfigureForExternalFit (const NuXFit::NuXAnalysis_t analSetting)
virtual void WriteOutput (const Bool_t writeOutput)
virtual Double_t BestDm2 () const
virtual Double_t BestSn2 () const
virtual Double_t BestDm2Bar () const
virtual Double_t BestSn2Bar () const
virtual Double_t BestTransitionProb () const
virtual void CPTAnalysis ()
virtual void TransitionAnalysis (const Double_t dm2, const Double_t sn2)

Private Member Functions

virtual Bool_t CacheFDMCEvents ()
virtual Bool_t CreateHistograms ()
virtual Bool_t CreateFDNuMuCCDataHisto ()
virtual Bool_t CreateFDNuMuBarCCDataHisto ()
virtual Bool_t CreateFDNuMuCCMCHisto ()
virtual Bool_t CreateFDNuMuBarCCMCHisto ()
virtual Bool_t FillFDDataHistograms ()
virtual Double_t NuBarCCCrossSection (const Double_t trueNuE) const
virtual Double_t NuMuCCCrossSection (const Double_t trueNuE) const
virtual Double_t NuBarCCSelectionEfficiency (const Double_t trueNuE) const
virtual Double_t NuMuCCSelectionEfficiency (const Double_t trueNuE) const
virtual NuXSecFit::NuSelectionResult_t SelectedAs (NuEvent &nuEvent) const
virtual NuCuts::NuAnaVersion_t SelectionScheme () const
virtual void SetupPars ()
virtual void SetupCPTPars ()
virtual void SetupTransitionPars ()
virtual Int_t TruthIndex (const NuEvent &info) const

Private Attributes

Bool_t fdoGridSearch
Bool_t fwriteOutput
NuXFit::NuXAnalysis_t fanalysisSetting
Double_t fUp
Double_t ffdDataPoT
Double_t ffdMCPoT
Double_t fdm2
Double_t fsn2
Double_t fBestDm2
Double_t fBestSn2
Double_t fBestDm2Bar
Double_t fBestSn2Bar
Double_t fBestTransitionProb
NuCuts::NuAnaVersion_t fanaVersion
NuTreeWrapper * ftFDDataTree
NuTreeWrapper * ftFDMCTree
TFitterMinuit * fFitter
TH1D * fhFDDataRecoENuMuCC
TH1D * fhFDDataRecoENuMuBarCC
TH1D * fhFDMCRecoENuMuCC
TH1D * fhFDMCRecoENuMuBarCC
std::string fSelEffFileName
std::string fxsecfilename
TFile * fOutputFile
TH1D * fhFDNuMuCCDataFromFile
TH1D * fhFDNuMuBarCCDataFromFile
TGraph * fNuBarCCCrossSectionGraph
TGraph * fNuMuCCCrossSectionGraph
TH1D * fhNuBarCCSelectionEfficiency
TH1D * fhNuMuCCSelectionEfficiency
TH1F * fhNuBarCCCrossSections
TH1F * fhNuMuCCCrossSections
std::vector< NuEvent > fvFDMCCCNuMuEvents
std::vector< NuEvent > fvFDMCCCNuMuBarEvents
std::vector< Double_t > fvFDRecoENuMuCCBins
std::vector< Double_t > fvFDRecoENuMuBarCCBins
std::vector< Double_t > fvNDFitPars
std::vector< Double_t > fvTrueEBinsNuMuCC
std::vector< Double_t > fvTrueEBinsNuMuBarCC
NuSystematic * fnuSystematic

Detailed Description

Definition at line 29 of file NuXFitAnalysis.h.

Constructor & Destructor Documentation

NuXFitAnalysis::NuXFitAnalysis (  )  [explicit]

Definition at line 127 of file NuXFitAnalysis.cxx.

References NuCuts::kJJE1, and NuXFit::kUnknown.

00128   : fdoGridSearch(false),
00129     fwriteOutput(true),
00130     fUp(1.0),
00131     ffdDataPoT(0.0),
00132     ffdMCPoT(0.0),
00133     fdm2(0.0),
00134     fsn2(0.0),
00135     fBestDm2(-1.0),
00136     fBestSn2(-1.0),
00137     fBestDm2Bar(-1.0),
00138     fBestSn2Bar(-1.0)
00139 {
00140   fanalysisSetting = NuXFit::kUnknown;
00141   fanaVersion = NuCuts::kJJE1;
00142   fnuSystematic = new NuSystematic();
00143 
00144   fSelEffFileName = "";
00145   fxsecfilename = "";
00146 
00147   fOutputFile = 0;
00148 
00149   ftFDDataTree = 0;
00150   ftFDMCTree = 0;
00151 
00152   fhNuBarCCSelectionEfficiency = 0;
00153   fhNuMuCCSelectionEfficiency = 0;
00154   fNuBarCCCrossSectionGraph = 0;
00155   fNuMuCCCrossSectionGraph = 0;
00156   fhNuBarCCCrossSections = 0;
00157   fhNuMuCCCrossSections = 0;
00158 
00159   fhFDNuMuCCDataFromFile = 0;
00160   fhFDNuMuBarCCDataFromFile = 0;
00161 
00162   fhFDDataRecoENuMuCC = 0;
00163   fhFDDataRecoENuMuBarCC = 0;
00164   fhFDMCRecoENuMuCC = 0;
00165   fhFDMCRecoENuMuBarCC = 0;
00166 
00167   fFitter = new TFitterMinuit();
00168   fFitter->CreateMinimizer();
00169   fFitter->SetMinuitFCN(this);
00170 }

NuXFitAnalysis::NuXFitAnalysis ( const NuXMLConfig &  xmlConfig  )  [explicit]

Definition at line 173 of file NuXFitAnalysis.cxx.

References fanalysisSetting, fanaVersion, fFitter, fhFDDataRecoENuMuBarCC, fhFDDataRecoENuMuCC, fhFDMCRecoENuMuBarCC, fhFDMCRecoENuMuCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fhNuBarCCCrossSections, fhNuBarCCSelectionEfficiency, fhNuMuCCCrossSections, fhNuMuCCSelectionEfficiency, fNuBarCCCrossSectionGraph, fNuMuCCCrossSectionGraph, fnuSystematic, fOutputFile, fSelEffFileName, ftFDDataTree, ftFDMCTree, fxsecfilename, NuCuts::kJJE1, and NuXFit::kUnknown.

00174   : fdoGridSearch(false),
00175     fUp(1.0),
00176     ffdDataPoT(0.0),
00177     ffdMCPoT(0.0),
00178     fdm2(0.0),
00179     fsn2(0.0)
00180 {
00181   fanalysisSetting = NuXFit::kUnknown;
00182   fanaVersion = NuCuts::kJJE1;
00183   fnuSystematic = new NuSystematic(xmlConfig);
00184 
00185   fSelEffFileName = "";
00186   fxsecfilename = "";
00187 
00188   fOutputFile = 0;
00189 
00190   ftFDDataTree = 0;
00191   ftFDMCTree = 0;
00192 
00193   fhNuBarCCSelectionEfficiency = 0;
00194   fhNuMuCCSelectionEfficiency = 0;
00195   fNuBarCCCrossSectionGraph = 0;
00196   fNuMuCCCrossSectionGraph = 0;
00197   fhNuBarCCCrossSections = 0;
00198   fhNuMuCCCrossSections = 0;
00199 
00200   fhFDNuMuCCDataFromFile = 0;
00201   fhFDNuMuBarCCDataFromFile = 0;
00202 
00203   fhFDDataRecoENuMuCC = 0;
00204   fhFDDataRecoENuMuBarCC = 0;
00205   fhFDMCRecoENuMuCC = 0;
00206   fhFDMCRecoENuMuBarCC = 0;
00207 
00208   fFitter = new TFitterMinuit();
00209   fFitter->CreateMinimizer();
00210   fFitter->SetMinuitFCN(this);
00211 }

NuXFitAnalysis::~NuXFitAnalysis (  )  [virtual]

Definition at line 215 of file NuXFitAnalysis.cxx.

References fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fnuSystematic, and fOutputFile.

00216 {
00217   if (fOutputFile){
00218     fOutputFile->Close();
00219     delete fOutputFile;
00220     fOutputFile = 0;
00221   }
00222 
00223   if (fnuSystematic){delete fnuSystematic; fnuSystematic = 0;}
00224 
00225   if (fhFDNuMuCCDataFromFile){
00226     delete fhFDNuMuCCDataFromFile; fhFDNuMuCCDataFromFile = 0;
00227   }
00228   if (fhFDNuMuBarCCDataFromFile){
00229     delete fhFDNuMuBarCCDataFromFile; fhFDNuMuBarCCDataFromFile = 0;
00230   }
00231 }

Member Function Documentation

virtual Double_t NuXFitAnalysis::BestDm2 (  )  const [inline, virtual]

Definition at line 80 of file NuXFitAnalysis.h.

References fBestDm2.

00080 {return fBestDm2;}

virtual Double_t NuXFitAnalysis::BestDm2Bar (  )  const [inline, virtual]

Definition at line 82 of file NuXFitAnalysis.h.

References fBestDm2Bar.

00082 {return fBestDm2Bar;}

virtual Double_t NuXFitAnalysis::BestSn2 (  )  const [inline, virtual]

Definition at line 81 of file NuXFitAnalysis.h.

References fBestSn2.

00081 {return fBestSn2;}

virtual Double_t NuXFitAnalysis::BestSn2Bar (  )  const [inline, virtual]

Definition at line 83 of file NuXFitAnalysis.h.

References fBestSn2Bar.

00083 {return fBestSn2Bar;}

virtual Double_t NuXFitAnalysis::BestTransitionProb (  )  const [inline, virtual]

Definition at line 84 of file NuXFitAnalysis.h.

References fBestTransitionProb.

00085     {return fBestTransitionProb;}

Bool_t NuXFitAnalysis::CacheFDMCEvents (  )  [private, virtual]

Definition at line 1254 of file NuXFitAnalysis.cxx.

References ffdDataPoT, ffdMCPoT, fhFDDataRecoENuMuBarCC, fhFDDataRecoENuMuCC, fnuSystematic, fOutputFile, ftFDMCTree, fvFDMCCCNuMuBarEvents, fvFDMCCCNuMuEvents, fvNDFitPars, fwriteOutput, NuTreeWrapper::GetEntries(), NuTreeWrapper::GetInfoObject(), NuXSecFit::kCCNuMu, NuXSecFit::kCCNuMuBar, Msg::kInfo, Msg::kWarning, MSG, NuEvent::rw, SelectedAs(), NuSystematic::Shift(), and TruthIndex().

01255 {
01256   if (!ftFDMCTree){
01257     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01258       << "FD MC not supplied"
01259       << endl;
01260     return false;
01261   }
01262 
01263   TH1D hFDRawMCRecoECCNuMuBar(*fhFDDataRecoENuMuBarCC);
01264   TH1D hFDRawMCRecoECCNuMu(*fhFDDataRecoENuMuCC);
01265   TH1D hFDNoOscPredRecoECCNuMuBar(*fhFDDataRecoENuMuBarCC);
01266   TH1D hFDNoOscPredRecoECCNuMu(*fhFDDataRecoENuMuCC);
01267 
01268   fvFDMCCCNuMuEvents.clear();
01269   fvFDMCCCNuMuBarEvents.clear();
01270 
01271   MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01272     << "Looping over FD MC:"
01273     << endl;
01274   Int_t mcEntries = ftFDMCTree->GetEntries();
01275   for (Int_t counter = 0;
01276        counter < mcEntries;
01277        ++counter){
01278     if (!(counter%10000)){
01279       MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01280         << counter << " of " << mcEntries
01281         << endl;
01282     }
01283     NuEvent currentEvent = ftFDMCTree->GetInfoObject(counter);
01284     fnuSystematic->Shift(currentEvent);
01285     NuSelectionResult_t recoType = this->SelectedAs(currentEvent);
01286     Double_t eventWeight = currentEvent.rw;
01287 
01288     Int_t truthpar = this->TruthIndex(currentEvent);
01289     Double_t eventWeightPred = eventWeight;
01290     if (truthpar>=0){
01291       eventWeightPred *= fvNDFitPars[truthpar];
01292     }
01293 
01294     if (NuXSecFit::kCCNuMu==recoType){
01295       fvFDMCCCNuMuEvents.push_back(currentEvent);
01296       hFDRawMCRecoECCNuMu.Fill(currentEvent.energy,eventWeight);
01297       hFDNoOscPredRecoECCNuMu.Fill(currentEvent.energy,eventWeightPred);
01298     }
01299     if (NuXSecFit::kCCNuMuBar==recoType){
01300       fvFDMCCCNuMuBarEvents.push_back(currentEvent);
01301       hFDRawMCRecoECCNuMuBar.Fill(currentEvent.energy,eventWeight);
01302       hFDNoOscPredRecoECCNuMuBar.Fill(currentEvent.energy,eventWeightPred);
01303     }
01304   }
01305   
01306   if (ffdMCPoT){
01307     hFDNoOscPredRecoECCNuMu.Scale(ffdDataPoT/ffdMCPoT);
01308     hFDNoOscPredRecoECCNuMuBar.Scale(ffdDataPoT/ffdMCPoT);
01309     hFDRawMCRecoECCNuMu.Scale(ffdDataPoT/ffdMCPoT);
01310     hFDRawMCRecoECCNuMuBar.Scale(ffdDataPoT/ffdMCPoT);
01311   }
01312   
01313   if (fwriteOutput){
01314     fOutputFile->cd();
01315     hFDNoOscPredRecoECCNuMu.Write("NoOscPredRecoECCNuMu");
01316     hFDNoOscPredRecoECCNuMuBar.Write("NoOscPredRecoECCNuMuBar");
01317     hFDRawMCRecoECCNuMu.Write("RawMCRecoECCNuMu");
01318     hFDRawMCRecoECCNuMuBar.Write("RawMCRecoECCNuMuBar");
01319   }
01320 
01321   return true;
01322 }

Double_t NuXFitAnalysis::CalculateLikelihood ( const TH1D *  fdPred,
const TH1D *  fdData 
) const

Definition at line 257 of file NuXFitAnalysis.cxx.

00260 {
00261   //Aim to minimise -2lnL. That's what I'm returning.
00262 
00263   Double_t like = 0;
00264 
00265   for (Int_t i=1; i<=fdPred->GetNbinsX(); ++i){
00266     //Bizarre limits because root histograms are silly
00267     Double_t mnu = fdPred->GetBinContent(i);
00268     Double_t dnu = fdData->GetBinContent(i);
00269     if (mnu<0.0001){mnu = 0.0001;}
00270     if (dnu){
00271       like += 2*(mnu - dnu + dnu*log(dnu/mnu));
00272     }
00273     else{like += 2*(mnu - dnu);}
00274   }
00275 //   cout << "Like = " << like << endl;
00276   return like;
00277 }

Double_t NuXFitAnalysis::CalculateLikelihood (  )  const [virtual]

Definition at line 280 of file NuXFitAnalysis.cxx.

References fhFDDataRecoENuMuBarCC, fhFDDataRecoENuMuCC, fhFDMCRecoENuMuBarCC, and fhFDMCRecoENuMuCC.

Referenced by CPTAnalysis(), and TransitionAnalysis().

00281 {
00282   //Aim to minimise -2lnL. That's what I'm returning.
00283 
00284   Double_t like = 0;
00285 
00286   for (Int_t i=1; i<=fhFDMCRecoENuMuCC->GetNbinsX(); ++i){
00287     //Bizarre limits because root histograms are silly
00288     Double_t mnu = fhFDMCRecoENuMuCC->GetBinContent(i);
00289     Double_t dnu = fhFDDataRecoENuMuCC->GetBinContent(i);
00290     if (mnu<0.0001){mnu = 0.0001;}
00291     if (dnu){
00292       like += 2*(mnu - dnu + dnu*log(dnu/mnu));
00293     }
00294     else{like += 2*(mnu - dnu);}
00295   }
00296 
00297   for (Int_t i=1; i<=fhFDMCRecoENuMuBarCC->GetNbinsX(); ++i){
00298     Double_t mbar = fhFDMCRecoENuMuBarCC->GetBinContent(i);
00299     Double_t dbar = fhFDDataRecoENuMuBarCC->GetBinContent(i);
00300     if (mbar<0.0001){mbar = 0.0001;}
00301     if (dbar){
00302       like += 2*(mbar - dbar + dbar*log(dbar/mbar));
00303     }
00304     else{like += 2*(mbar - dbar);}
00305   }
00306 //   cout << "Like = " << like << endl;
00307   return like;
00308 }

void NuXFitAnalysis::ConfigureForExternalFit ( const NuXFit::NuXAnalysis_t  analSetting  )  [virtual]

Definition at line 811 of file NuXFitAnalysis.cxx.

00812 {
00813   fanalysisSetting = analSetting;
00814   this->CreateHistograms();
00815   this->FillFDDataHistograms();
00816   this->CacheFDMCEvents();
00817 
00818   this->SetupPars();
00819 }

void NuXFitAnalysis::CPTAnalysis (  )  [virtual]

Definition at line 822 of file NuXFitAnalysis.cxx.

References CalculateLikelihood(), fanalysisSetting, fBestDm2, fBestDm2Bar, fBestSn2, fBestSn2Bar, fdoGridSearch, fFitter, fhFDDataRecoENuMuBarCC, fhFDMCRecoENuMuBarCC, fhFDMCRecoENuMuCC, FillCPTFDPrediction(), fOutputFile, fwriteOutput, NuXFit::kCPT, Msg::kInfo, MSG, and SetupPars().

00823 {
00824   fanalysisSetting = NuXFit::kCPT;
00825 
00826   if (!this->CreateHistograms()){return;}
00827   if (!this->FillFDDataHistograms()){return;}
00828   if (!this->CacheFDMCEvents()){return;}
00829 
00830   if (!fdoGridSearch){
00831     this->SetupPars();
00832     
00833     fFitter->FixParameter(0);
00834     fFitter->FixParameter(1);
00835     
00836     fFitter->Minimize();
00837     fFitter->PrintResults(0,0);
00838     
00839     fBestDm2 = fFitter->GetParameter(0);
00840     fBestSn2 = fFitter->GetParameter(1);
00841     fBestDm2Bar = fFitter->GetParameter(2);
00842     fBestSn2Bar = fFitter->GetParameter(3);
00843   }
00844 
00845   if (fdoGridSearch){
00846     Double_t bestChi2 = 1.0e10;
00847     Double_t bestsn2bar = 0.0;
00848     Double_t bestdm2bar = 0.0;
00849     
00850     Double_t sn2BarLow = 0.8;
00851     Double_t sn2BarHigh = 1.0;
00852     Double_t sn2BarGranularity = 0.001;
00853     Double_t dm2BarLow = 1.0e-3;
00854     Double_t dm2BarHigh = 4.0e-3;
00855     Double_t dm2BarGranularity = 0.005e-3; 
00856     
00857     //Create the Chi2 histogram
00858     Int_t numSn2BarBins = (Int_t) round((sn2BarHigh-sn2BarLow)/sn2BarGranularity) + 1;
00859     Int_t numDm2BarBins = (Int_t) round((dm2BarHigh-dm2BarLow)/dm2BarGranularity) + 1;
00860     TH2D hChi2Bar("hChi2Bar",
00861                   "",
00862                   numSn2BarBins,
00863                   sn2BarLow-sn2BarGranularity/2.0,
00864                   sn2BarHigh+sn2BarGranularity/2.0,
00865                   numDm2BarBins,
00866                   dm2BarLow-dm2BarGranularity/2.0,
00867                   dm2BarHigh+dm2BarGranularity/2.0); 
00868     
00869     for (Double_t sn2bar = sn2BarLow;
00870          sn2bar <= sn2BarHigh+sn2BarGranularity/2.0;
00871          sn2bar += sn2BarGranularity){
00872       MSG("NuMatrixFitter.cxx",Msg::kInfo) << "sn2bar = " << sn2bar << endl;
00873       for (Double_t dm2bar = dm2BarLow;
00874            dm2bar <= dm2BarHigh+dm2BarGranularity/2.0;
00875            dm2bar += dm2BarGranularity){
00876         
00877         vector<Double_t> vParameters;
00878         vParameters.push_back(2.38);
00879         vParameters.push_back(1.0);
00880         vParameters.push_back(dm2bar);
00881         vParameters.push_back(sn2bar);
00882         this->FillCPTFDPrediction(vParameters);
00883         
00884         Double_t chi2 = this->CalculateLikelihood(fhFDMCRecoENuMuBarCC,
00885                                                   fhFDDataRecoENuMuBarCC);
00886         
00887         //       chi2 += this->CalculateLikelihood(numufdPred,numufdData);
00888         Int_t xBin = hChi2Bar.GetXaxis()->FindBin(sn2bar);
00889         Int_t yBin = hChi2Bar.GetYaxis()->FindBin(dm2bar);
00890         Int_t bin2D = hChi2Bar.GetBin(xBin,yBin);
00891         hChi2Bar.SetBinContent(bin2D,chi2);
00892         if (chi2 < bestChi2){
00893           bestChi2 = chi2;
00894           bestsn2bar = sn2bar;
00895           bestdm2bar = dm2bar;
00896         }//if
00897       }//dm2bar
00898     }//sn2bar
00899 
00900     fBestDm2 = 2.38;
00901     fBestSn2 = 1.0;
00902     fBestDm2Bar = bestdm2bar;
00903     fBestSn2Bar = bestsn2bar;
00904   }
00905 
00906   vector<Double_t> vBestFit;
00907   vBestFit.push_back(fBestDm2);
00908   vBestFit.push_back(fBestSn2);
00909   vBestFit.push_back(fBestDm2Bar);
00910   vBestFit.push_back(fBestSn2Bar);
00911   this->FillCPTFDPrediction(vBestFit);
00912   if (fwriteOutput){
00913     fOutputFile->cd();
00914     fhFDMCRecoENuMuCC->Write("BestFitFDMCRecoENuMuCC");
00915     fhFDMCRecoENuMuBarCC->Write("BestFitFDMCRecoENuMuBarCC");
00916   }
00917 
00918 
00919 
00920   
00921 //   ROOT::Minuit2::MnUserParameters mnPars;
00922 //   mnPars.Add("Dm2",0.003,0.2,0.0e-3,10.0e-3);
00923 //   mnPars.Add("Sn2",1.0,0.2,0.0,2.0);
00924 //   mnPars.Add("Dm2Bar",0.003,0.2,4.0e-3,8.0e-3);
00925 //   mnPars.Add("Sn2Bar",1.0,0.2,0.4,1.6);
00926 //   ROOT::Minuit2::MnMigrad mnMigrad(*this,mnPars);
00927 //   cout << "Beginning second fit" << endl;
00928 //   ROOT::Minuit2::FunctionMinimum funcMin = mnMigrad();
00929 //   cout << "Function minimum is " << funcMin.UserParameters().Parameters()[2].Value() << ", " << funcMin.UserParameters().Parameters()[3].Value() << endl;
00930   
00931 //   ROOT::Minuit2::FCNBase& fcnBase = *this;
00932 //   ROOT::Minuit2::MnContours contours(fcnBase,funcMin);
00933 //   this->SetErrorDef(4);
00934 //   ContoursError contErr = contours.Contour(2,3,20);
00935 //   //  cout << contErr << endl;
00936 //   cout << "Contour:" << endl;
00937 
00938 //   std::vector<std::pair<Double_t,Double_t> > vContPoints = contErr();
00939 
00940 //   Double_t* x = new Double_t[vContPoints.size()];
00941 //   for (UInt_t pointCount = 0; pointCount<vContPoints.size(); ++pointCount){
00942 //     x[pointCount] = vContPoints[pointCount].first;
00943 //   }
00944 //   Double_t* y = new Double_t[vContPoints.size()];
00945 //   for (UInt_t pointCount = 0; pointCount<vContPoints.size(); ++pointCount){
00946 //     y[pointCount] = vContPoints[pointCount].second;
00947 //   }
00948 //   TGraph* gCont = new TGraph(vContPoints.size(),y,x);
00949 //   TCanvas* cCont;
00950 //   gCont->Draw("AL");
00951   //  cout << contours << endl;
00952 
00953   /*
00954   TGraph2DErrors* gConf = new TGraph2DErrors(100);
00955   fFitter->FixParameter(0);
00956   fFitter->FixParameter(1);
00957   fFitter->GetFitter()->GetConfidenceIntervals(gConf,0.66);
00958   if (fwriteOutput){
00959     fOutputFile->cd();
00960     gConf->Write("OneSigmaContour");
00961   }
00962   */
00963 }

Bool_t NuXFitAnalysis::CreateFDNuMuBarCCDataHisto (  )  [private, virtual]

Definition at line 322 of file NuXFitAnalysis.cxx.

References fhFDDataRecoENuMuBarCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fvFDRecoENuMuBarCCBins, Msg::kWarning, and MSG.

00323 {
00324   if (fhFDDataRecoENuMuBarCC) {
00325     delete fhFDDataRecoENuMuBarCC; fhFDDataRecoENuMuBarCC = 0;
00326   }
00327 
00328   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00329     fhFDDataRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
00330     fhFDDataRecoENuMuBarCC->Reset();
00331     return true;
00332   }
00333 
00334   Int_t size = fvFDRecoENuMuBarCCBins.size();
00335   if (!size){
00336     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00337       << "FD reconstructed energy binning not supplied."
00338       << endl;
00339     return false;
00340   }
00341 
00342   Double_t* recoEBinEdges = new Double_t[size];
00343 
00344   Int_t i=0;
00345   for (vector<Double_t>::const_iterator it =
00346          fvFDRecoENuMuBarCCBins.begin();
00347        it != fvFDRecoENuMuBarCCBins.end();
00348        ++it, ++i){
00349     recoEBinEdges[i] = *it;
00350   }
00351 
00352   fhFDDataRecoENuMuBarCC = new TH1D("fhFDDataRecoENuMuBarCC",
00353                                "FD NuMuBar CC data",
00354                                size-1,
00355                                recoEBinEdges);
00356 
00357   if (!fhFDDataRecoENuMuBarCC) return false;
00358   return true;
00359 }

Bool_t NuXFitAnalysis::CreateFDNuMuBarCCMCHisto (  )  [private, virtual]

Definition at line 402 of file NuXFitAnalysis.cxx.

References fhFDMCRecoENuMuBarCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fvFDRecoENuMuBarCCBins, Msg::kWarning, and MSG.

00403 {
00404   if (fhFDMCRecoENuMuBarCC) {
00405     delete fhFDMCRecoENuMuBarCC; fhFDMCRecoENuMuBarCC = 0;
00406   }
00407 
00408   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00409     fhFDMCRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
00410     fhFDMCRecoENuMuBarCC->Reset();
00411     return true;
00412   }
00413 
00414   Int_t size = fvFDRecoENuMuBarCCBins.size();
00415   if (!size){
00416     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00417       << "FD reconstructed energy binning not supplied."
00418       << endl;
00419     return false;
00420   }
00421 
00422   Double_t* recoEBinEdges = new Double_t[size];
00423 
00424   Int_t i=0;
00425   for (vector<Double_t>::const_iterator it =
00426          fvFDRecoENuMuBarCCBins.begin();
00427        it != fvFDRecoENuMuBarCCBins.end();
00428        ++it, ++i){
00429     recoEBinEdges[i] = *it;
00430   }
00431 
00432   fhFDMCRecoENuMuBarCC = new TH1D("fhFDMCRecoENuMuBarCC",
00433                                "FD NuMuBar CC prediction",
00434                                size-1,
00435                                recoEBinEdges);
00436 
00437   if (!fhFDMCRecoENuMuBarCC) return false;
00438   return true;
00439 }

Bool_t NuXFitAnalysis::CreateFDNuMuCCDataHisto (  )  [private, virtual]

Definition at line 362 of file NuXFitAnalysis.cxx.

References fhFDDataRecoENuMuCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fvFDRecoENuMuCCBins, Msg::kWarning, and MSG.

00363 {
00364   if (fhFDDataRecoENuMuCC) {
00365     delete fhFDDataRecoENuMuCC; fhFDDataRecoENuMuCC = 0;
00366   }
00367 
00368   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00369     fhFDDataRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
00370     fhFDDataRecoENuMuCC->Reset();
00371     return true;
00372   }
00373 
00374   Int_t size = fvFDRecoENuMuCCBins.size();
00375   if (!size){
00376     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00377       << "FD reconstructed energy binning not supplied."
00378       << endl;
00379     return false;
00380   }
00381 
00382   Double_t* recoEBinEdges = new Double_t[size];
00383 
00384   Int_t i=0;
00385   for (vector<Double_t>::const_iterator it =
00386          fvFDRecoENuMuCCBins.begin();
00387        it != fvFDRecoENuMuCCBins.end();
00388        ++it, ++i){
00389     recoEBinEdges[i] = *it;
00390   }
00391 
00392   fhFDDataRecoENuMuCC = new TH1D("fhFDDataRecoENuMuCC",
00393                                "FD NuMu CC data",
00394                                size-1,
00395                                recoEBinEdges);
00396 
00397   if (!fhFDDataRecoENuMuCC) return false;
00398   return true;
00399 }

Bool_t NuXFitAnalysis::CreateFDNuMuCCMCHisto (  )  [private, virtual]

Definition at line 442 of file NuXFitAnalysis.cxx.

References fhFDMCRecoENuMuCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fvFDRecoENuMuCCBins, Msg::kWarning, and MSG.

00443 {
00444   if (fhFDMCRecoENuMuCC) {
00445     delete fhFDMCRecoENuMuCC; fhFDMCRecoENuMuCC = 0;
00446   }
00447 
00448   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00449     fhFDMCRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
00450     fhFDMCRecoENuMuCC->Reset();
00451     return true;
00452   }
00453 
00454   Int_t size = fvFDRecoENuMuCCBins.size();
00455   if (!size){
00456     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00457       << "FD reconstructed energy binning not supplied."
00458       << endl;
00459     return false;
00460   }
00461 
00462   Double_t* recoEBinEdges = new Double_t[size];
00463 
00464   Int_t i=0;
00465   for (vector<Double_t>::const_iterator it =
00466          fvFDRecoENuMuCCBins.begin();
00467        it != fvFDRecoENuMuCCBins.end();
00468        ++it, ++i){
00469     recoEBinEdges[i] = *it;
00470   }
00471 
00472   fhFDMCRecoENuMuCC = new TH1D("fhFDMCRecoENuMuCC",
00473                                "FD NuMu CC prediction",
00474                                size-1,
00475                                recoEBinEdges);
00476 
00477   if (!fhFDMCRecoENuMuCC) return false;
00478   return true;
00479 }

Bool_t NuXFitAnalysis::CreateHistograms (  )  [private, virtual]

Definition at line 799 of file NuXFitAnalysis.cxx.

00800 {
00801   Bool_t goodConfig = true;
00802   if (!this->CreateFDNuMuCCDataHisto()) goodConfig = false;
00803   if (!this->CreateFDNuMuBarCCDataHisto()) goodConfig = false;
00804   if (!this->CreateFDNuMuCCMCHisto()) goodConfig = false;
00805   if (!this->CreateFDNuMuBarCCMCHisto()) goodConfig = false;
00806   return goodConfig;
00807 }

virtual void NuXFitAnalysis::CrossSectionFileName ( const std::string  xSecFileName  )  [inline, virtual]

Definition at line 43 of file NuXFitAnalysis.h.

References fxsecfilename.

00044     {fxsecfilename = xSecFileName;}

virtual void NuXFitAnalysis::DoGridSearch ( const Bool_t  doGridSearch  )  [inline, virtual]

Definition at line 45 of file NuXFitAnalysis.h.

References fdoGridSearch.

00045 {fdoGridSearch=doGridSearch;}

virtual void NuXFitAnalysis::FDData ( const std::string  fdDataFileName  )  [virtual]

virtual void NuXFitAnalysis::FDDataPoT ( const Double_t  pot  )  [inline, virtual]

Definition at line 49 of file NuXFitAnalysis.h.

References ffdDataPoT.

00050     {ffdDataPoT = pot;}

virtual void NuXFitAnalysis::FDMC ( const std::string  fdMCFileName  )  [virtual]

void NuXFitAnalysis::FDNuMuBarCCData ( const TH1D &  fdData  )  [virtual]

Definition at line 765 of file NuXFitAnalysis.cxx.

References fhFDNuMuBarCCDataFromFile.

00766 {
00767   if (fhFDNuMuBarCCDataFromFile){
00768     delete fhFDNuMuBarCCDataFromFile; fhFDNuMuBarCCDataFromFile = 0;
00769   }
00770   fhFDNuMuBarCCDataFromFile = new TH1D(fdData);
00771   fhFDNuMuBarCCDataFromFile->SetDirectory(0);
00772 }

void NuXFitAnalysis::FDNuMuCCData ( const TH1D &  fdData  )  [virtual]

Definition at line 775 of file NuXFitAnalysis.cxx.

References fhFDNuMuCCDataFromFile.

00776 {
00777   if (fhFDNuMuCCDataFromFile){
00778     delete fhFDNuMuCCDataFromFile; fhFDNuMuCCDataFromFile = 0;
00779   }
00780   fhFDNuMuCCDataFromFile = new TH1D(fdData);
00781   fhFDNuMuCCDataFromFile->SetDirectory(0);
00782 }

virtual void NuXFitAnalysis::FDRecoENuMuBarCCBins ( const std::vector< Double_t >  vFDRecoENuMuBarCCBins  )  [inline, virtual]

Definition at line 56 of file NuXFitAnalysis.h.

References fvFDRecoENuMuBarCCBins.

00057     {fvFDRecoENuMuBarCCBins = vFDRecoENuMuBarCCBins;}

virtual void NuXFitAnalysis::FDRecoENuMuCCBins ( const std::vector< Double_t >  vFDRecoENuMuCCBins  )  [inline, virtual]

Definition at line 53 of file NuXFitAnalysis.h.

References fvFDRecoENuMuCCBins.

00054     {fvFDRecoENuMuCCBins = vFDRecoENuMuCCBins;}

virtual void NuXFitAnalysis::FillCPTFDPrediction ( const std::vector< double > &  par  )  const [virtual]

Referenced by CPTAnalysis().

Bool_t NuXFitAnalysis::FillFDDataHistograms (  )  [private, virtual]

Definition at line 1148 of file NuXFitAnalysis.cxx.

References NuEvent::energy, fhFDDataRecoENuMuBarCC, fhFDDataRecoENuMuCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fOutputFile, ftFDDataTree, fwriteOutput, NuTreeWrapper::GetEntries(), NuTreeWrapper::GetInfoObject(), NuEvent::iaction, NuEvent::inu, NuXSecFit::kCCNuMu, NuXSecFit::kCCNuMuBar, Msg::kInfo, Msg::kWarning, MSG, NuEvent::neuEnMC, NuOscProb::OscillationWeight(), NuEvent::rw, and SelectedAs().

01149 {
01150   //Preferentially take data from histograms if they've been supplied
01151   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
01152     if (fhFDDataRecoENuMuCC){
01153       delete fhFDDataRecoENuMuCC; fhFDDataRecoENuMuCC = 0;
01154     }
01155     if (fhFDDataRecoENuMuBarCC){
01156       delete fhFDDataRecoENuMuBarCC; fhFDDataRecoENuMuBarCC = 0;
01157     }
01158     fhFDDataRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
01159     fhFDDataRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
01160 
01161     if (fwriteOutput){
01162       fOutputFile->cd();
01163       fhFDDataRecoENuMuCC->Write("InputFDNuMuCCData");
01164       fhFDDataRecoENuMuBarCC->Write("InputFDNuMuBarCCData");
01165     }
01166     return true;
01167   }
01168 
01169   if (!fhFDDataRecoENuMuCC){
01170     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01171       << "FD numu data histogram not created"
01172       << endl;
01173     return false;
01174   }
01175   if (!fhFDDataRecoENuMuBarCC){
01176     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01177       << "FD numubar data histogram not created"
01178       << endl;
01179     return false;
01180   }
01181   if (!ftFDDataTree){
01182     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01183       << "FD data not supplied"
01184       << endl;
01185     return false;
01186   }
01187 
01188   fhFDDataRecoENuMuCC->Reset();
01189   fhFDDataRecoENuMuBarCC->Reset();
01190   
01191   Double_t Sn2 = 1.0;
01192   Double_t Sn2Bar = 1.0;
01193   Double_t Dm2 = 0.003;
01194   Double_t Dm2Bar = 0.003;
01195   /*
01196   Double_t Sn2 = 0.0;
01197   Double_t Sn2Bar = 0.0;
01198   Double_t Dm2 = 0.0;
01199   Double_t Dm2Bar = 0.0;
01200   */
01201   MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01202     << "Looping over FD data:"
01203     << endl;
01204   Int_t dataEntries = ftFDDataTree->GetEntries();
01205   for (Int_t counter = 0;
01206        counter < dataEntries;
01207        ++counter){
01208     if (!(counter%10000)){
01209       MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01210         << counter << " of " << dataEntries
01211         << endl;
01212     }
01213     NuEvent currentEvent = ftFDDataTree->GetInfoObject(counter);
01214     NuSelectionResult_t recoType = this->SelectedAs(currentEvent);
01215     Double_t recoEnergy = currentEvent.energy;
01216     Double_t nuweight = 1.0;
01217     nuweight *= currentEvent.rw;
01218     
01219     //Fake oscillations
01220     Double_t thisSn2 = 0.0;
01221     Double_t thisDm2 = 0.0;
01222     if (1==currentEvent.iaction){
01223       if (-14==currentEvent.inu){
01224         thisSn2 = Sn2Bar;
01225         thisDm2 = Dm2Bar;
01226       }
01227       if (14==currentEvent.inu){
01228         thisSn2 = Sn2;
01229         thisDm2 = Dm2;
01230       }
01231     }
01232     Double_t oscweight = NuOscProb::OscillationWeight(currentEvent.neuEnMC,
01233                                                         thisDm2, thisSn2);
01234     nuweight *= oscweight;
01235     
01236     if (recoType==NuXSecFit::kCCNuMu){
01237       fhFDDataRecoENuMuCC->Fill(recoEnergy,nuweight);
01238     }
01239     if (recoType==NuXSecFit::kCCNuMuBar){
01240       fhFDDataRecoENuMuBarCC->Fill(recoEnergy,nuweight);
01241     }
01242   }
01243 
01244   if (fwriteOutput){
01245     fOutputFile->cd();
01246     fhFDDataRecoENuMuCC->Write("InputFDNuMuCCData");
01247     fhFDDataRecoENuMuBarCC->Write("InputFDNuMuBarCCData");
01248   }
01249 
01250   return true;
01251 }

void NuXFitAnalysis::FillTransitionFDPrediction ( const vector< double > &  par  )  const [virtual]

Definition at line 566 of file NuXFitAnalysis.cxx.

References NuOscProb::OscillationWeight().

Referenced by TransitionAnalysis().

00567 {
00568   //Reset recoE histograms
00569   fhFDMCRecoENuMuCC->Reset();
00570   fhFDMCRecoENuMuBarCC->Reset();
00571 
00572   Double_t shwEShift=1.0;
00573   Double_t trkEShift = 1.0;
00574 
00575   Double_t Dm2 = fdm2;
00576   Double_t Sn2 = fsn2;
00577   Double_t Dm2Bar = fdm2;
00578   Double_t Sn2Bar = fsn2;
00579   Double_t transitionProb = par[0];
00580 
00581   //Fill the nubar histogram, weighted with truth parameters
00582   for (vector<NuEvent>::const_iterator itBar
00583          = fvFDMCCCNuMuBarEvents.begin();
00584        itBar!=fvFDMCCCNuMuBarEvents.end();
00585        ++itBar){
00586     NuEvent barEvent = *itBar;
00587     Int_t truthpar = this->TruthIndex(barEvent);
00588     Double_t barweight = 1.0;
00589     barweight *= barEvent.rw;
00590     if (truthpar>=0){
00591       barweight *= fvNDFitPars[truthpar];
00592     }
00593     Double_t thisSn2 = 0.0;
00594     Double_t thisDm2 = 0.0;
00595     if (1==barEvent.iaction){
00596       if (-14==barEvent.inu){
00597         thisSn2 = Sn2Bar;
00598         thisDm2 = Dm2Bar;
00599       }
00600       if (14==barEvent.inu){
00601         thisSn2 = Sn2;
00602         thisDm2 = Dm2;
00603       }
00604     }
00605     Double_t oscweightbar = NuOscProb::OscillationWeight(barEvent.neuEnMC,
00606                                                            thisDm2, thisSn2);
00607     Double_t transitionWeight = barweight;
00608     barweight *= oscweightbar;
00609     Double_t recoNuE = shwEShift*(barEvent.shwEn)
00610       + trkEShift*(barEvent.trkEn);
00611     Double_t trueNuE = barEvent.neuEnMC;
00612     fhFDMCRecoENuMuBarCC->Fill(recoNuE,barweight);
00613     if (1==barEvent.iaction){
00614       if (-14==barEvent.inu){
00615         transitionWeight *= 1.0-oscweightbar;
00616         transitionWeight *= transitionProb;
00617         Double_t nuBarSelEff = this->NuBarCCSelectionEfficiency(trueNuE);
00618         Double_t nuBarXSec = this->NuBarCCCrossSection(trueNuE);
00619         if (nuBarSelEff && nuBarXSec){
00620           transitionWeight /= nuBarSelEff;
00621           transitionWeight /= nuBarXSec;
00622         }
00623         transitionWeight *= this->NuMuCCSelectionEfficiency(trueNuE);
00624         transitionWeight *= this->NuMuCCCrossSection(trueNuE);
00625         fhFDMCRecoENuMuCC->Fill(recoNuE,transitionWeight);
00626       }
00627     }
00628   }
00629   if (ffdMCPoT){fhFDMCRecoENuMuBarCC->Scale(ffdDataPoT/ffdMCPoT);}
00630 
00631   //Fill the numu histogram, weighted with truth parameters
00632   for (vector<NuEvent>::const_iterator itNu
00633          = fvFDMCCCNuMuEvents.begin();
00634        itNu!=fvFDMCCCNuMuEvents.end();
00635        ++itNu){
00636     NuEvent nuEvent = *itNu;
00637     Int_t truthpar = this->TruthIndex(nuEvent);
00638     Double_t nuweight = 1.0;
00639     nuweight *= nuEvent.rw;
00640     if (truthpar>=0){
00641       nuweight *= fvNDFitPars[truthpar];
00642     }
00643     Double_t thisSn2 = 0.0;
00644     Double_t thisDm2 = 0.0;
00645     if (1==nuEvent.iaction){
00646       if (-14==nuEvent.inu){
00647         thisSn2 = Sn2Bar;
00648         thisDm2 = Dm2Bar;
00649       }
00650       if (14==nuEvent.inu){
00651         thisSn2 = Sn2;
00652         thisDm2 = Dm2;
00653       }
00654     }
00655     Double_t oscweight = NuOscProb::OscillationWeight(nuEvent.neuEnMC,
00656                                                         thisDm2, thisSn2);
00657     Double_t transitionWeight = nuweight;
00658     nuweight *= oscweight;
00659     Double_t recoNuE = shwEShift*(nuEvent.shwEn)
00660       + trkEShift*(nuEvent.trkEn);
00661     Double_t trueNuE = nuEvent.neuEnMC;
00662     fhFDMCRecoENuMuCC->Fill(recoNuE,nuweight);
00663     if (1==nuEvent.iaction){
00664       if (14==nuEvent.inu){
00665         transitionWeight *= 1.0-oscweight;
00666         transitionWeight *= transitionProb;
00667         transitionWeight *= this->NuBarCCSelectionEfficiency(trueNuE);
00668         transitionWeight *= this->NuBarCCCrossSection(trueNuE);
00669         Double_t nuMuSelEff = this->NuMuCCSelectionEfficiency(trueNuE);
00670         Double_t nuMuXSec = this->NuMuCCCrossSection(trueNuE);
00671         if (nuMuSelEff && nuMuXSec){
00672           transitionWeight /= nuMuSelEff;
00673           transitionWeight /= nuMuXSec;
00674         }
00675         fhFDMCRecoENuMuBarCC->Fill(recoNuE,transitionWeight);
00676       }
00677     }
00678   }
00679   if (ffdMCPoT){fhFDMCRecoENuMuCC->Scale(ffdDataPoT/ffdMCPoT);}
00680 }

virtual void NuXFitAnalysis::NDFitBinningNuMuBarCC ( const std::vector< Double_t >  trueEBins  )  [inline, virtual]

Definition at line 64 of file NuXFitAnalysis.h.

References fvTrueEBinsNuMuBarCC.

00065     {fvTrueEBinsNuMuBarCC = trueEBins;}

virtual void NuXFitAnalysis::NDFitBinningNuMuCC ( const std::vector< Double_t >  trueEBins  )  [inline, virtual]

Definition at line 62 of file NuXFitAnalysis.h.

References fvTrueEBinsNuMuCC.

00063     {fvTrueEBinsNuMuCC = trueEBins;}

virtual void NuXFitAnalysis::NDFitResults ( const std::vector< Double_t >  xSecWeights  )  [inline, virtual]

Definition at line 60 of file NuXFitAnalysis.h.

References fvNDFitPars.

00061     {fvNDFitPars = xSecWeights;}

Double_t NuXFitAnalysis::NuBarCCCrossSection ( const Double_t  trueNuE  )  const [private, virtual]

Definition at line 684 of file NuXFitAnalysis.cxx.

00685 {
00686   //  return fNuBarCCCrossSectionGraph->Eval(trueNuE,0,"");
00687   return fhNuBarCCCrossSections->
00688     GetBinContent(fhNuBarCCCrossSections->FindBin(trueNuE));
00689 }

Double_t NuXFitAnalysis::NuBarCCSelectionEfficiency ( const Double_t  trueNuE  )  const [private, virtual]

Definition at line 693 of file NuXFitAnalysis.cxx.

00694 {
00695   return fhNuBarCCSelectionEfficiency->
00696     GetBinContent(fhNuBarCCSelectionEfficiency->FindBin(trueNuE));
00697 }

Double_t NuXFitAnalysis::NuMuCCCrossSection ( const Double_t  trueNuE  )  const [private, virtual]

Definition at line 701 of file NuXFitAnalysis.cxx.

00702 {
00703   //  return fNuMuCCCrossSectionGraph->Eval(trueNuE,0,"");
00704   return fhNuMuCCCrossSections->
00705     GetBinContent(fhNuMuCCCrossSections->FindBin(trueNuE));
00706 }

Double_t NuXFitAnalysis::NuMuCCSelectionEfficiency ( const Double_t  trueNuE  )  const [private, virtual]

Definition at line 710 of file NuXFitAnalysis.cxx.

00711 {
00712   return fhNuMuCCSelectionEfficiency->
00713     GetBinContent(fhNuMuCCSelectionEfficiency->FindBin(trueNuE));
00714 }

virtual double NuXFitAnalysis::operator() ( const std::vector< double > &  x  )  const [virtual]

virtual void NuXFitAnalysis::OutputFileName ( const std::string  outFile  )  [virtual]

NuSelectionResult_t NuXFitAnalysis::SelectedAs ( NuEvent &  nuEvent  )  const [private, virtual]

Definition at line 1326 of file NuXFitAnalysis.cxx.

References NuEvent::anaVersion, NuEvent::charge, NuCuts::IsGoodBeam(), NuCuts::IsGoodDataQuality(), NuCuts::IsGoodDirCos(), NuCuts::IsGoodFitProb(), NuCuts::IsGoodMajorityCurvature(), NuCuts::IsGoodNumberOfTracks(), NuCuts::IsGoodPID(), NuCuts::IsGoodSigmaQP_QP(), NuCuts::IsGoodTimeToNearestSpill(), NuCuts::IsGoodTrackFitPass(), NuCuts::IsInFidVolTrk(), NuCuts::IsLI(), NuXSecFit::kCCNuMu, NuXSecFit::kCCNuMuBar, NuXSecFit::kUnknown, and SelectionScheme().

Referenced by CacheFDMCEvents(), and FillFDDataHistograms().

01327 {
01328   NuCuts nuCuts;
01329   nuEvent.anaVersion = this->SelectionScheme();
01330   
01331   //cut on LI
01332   if (nuCuts.IsLI(nuEvent)) return NuXSecFit::kUnknown;
01333   //cut on the data quality
01334   if (!nuCuts.IsGoodDataQuality(nuEvent)) return NuXSecFit::kUnknown;
01335   //cut on the spill time
01336   if (!nuCuts.IsGoodTimeToNearestSpill(nuEvent)) return NuXSecFit::kUnknown;
01337   //cut on the beam
01338   if (!nuCuts.IsGoodBeam(nuEvent)) return NuXSecFit::kUnknown;
01339   
01340   //cut on whether event vtx is in fid vol (does nothing for CC ana)
01341   //    if (!nuCuts.IsInFidVol(evt,nu)) continue;
01342   //ensure good number of tracks in event (note preselection above)
01343   if (!nuCuts.IsGoodNumberOfTracks(nuEvent)) return NuXSecFit::kUnknown;
01344   //check trk is in fiducial volume (note preselection above)
01345   if (!nuCuts.IsInFidVolTrk(nuEvent)) return NuXSecFit::kUnknown;
01346   
01347   //require a good trk fit
01348   if (!nuCuts.IsGoodTrackFitPass(nuEvent)) return NuXSecFit::kUnknown;
01349   //require a forward going neutrino about beam direction
01350   if (!nuCuts.IsGoodDirCos(nuEvent)) return NuXSecFit::kUnknown;
01351   
01352   //cut on the PID
01353   if (!nuCuts.IsGoodPID(nuEvent)) {
01354     return NuXSecFit::kUnknown;
01355   }
01356   //cut on the fractional track momentum and sign error      
01357   if (!nuCuts.IsGoodSigmaQP_QP(nuEvent)) {
01358     return NuXSecFit::kUnknown;
01359   }
01360   //cut on the track fit probability      
01361   if (!nuCuts.IsGoodFitProb(nuEvent)) {
01362     return NuXSecFit::kUnknown;
01363   }
01364   if (!nuCuts.IsGoodMajorityCurvature(nuEvent)){
01365     return NuXSecFit::kUnknown;
01366   }
01367   
01368   if (-1==nuEvent.charge){return NuXSecFit::kCCNuMu;}
01369   if (1==nuEvent.charge){return NuXSecFit::kCCNuMuBar;}
01370   return NuXSecFit::kUnknown;
01371 }

virtual void NuXFitAnalysis::SelectionEfficiencyFileName ( const std::string  selEffFileName  )  [inline, virtual]

Definition at line 67 of file NuXFitAnalysis.h.

References fSelEffFileName.

00068     {fSelEffFileName = selEffFileName;}

virtual NuCuts::NuAnaVersion_t NuXFitAnalysis::SelectionScheme (  )  const [inline, private, virtual]

Definition at line 106 of file NuXFitAnalysis.h.

References fanaVersion.

Referenced by SelectedAs().

00107     {return fanaVersion;}

virtual void NuXFitAnalysis::SelectionScheme ( const NuCuts::NuAnaVersion_t  anaVersion = NuCuts::kCC0250Std  )  [inline, virtual]

Definition at line 69 of file NuXFitAnalysis.h.

References fanaVersion.

00071     {fanaVersion = anaVersion;}

virtual void NuXFitAnalysis::SetErrorDef ( const Double_t  up  )  [inline, virtual]

Definition at line 37 of file NuXFitAnalysis.h.

References fUp.

00037 {fUp = up;}

void NuXFitAnalysis::SetupCPTPars (  )  [private, virtual]

Definition at line 1054 of file NuXFitAnalysis.cxx.

References fFitter.

Referenced by SetupPars().

01055 {
01056   fFitter->SetParameter(0,
01057                         "Dm2",
01058                         0.00238,0.2,1.0,0.0);
01059   fFitter->SetParameter(1,
01060                         "Sn2",
01061                         1.0,0.2,1.0,0.0);
01062   fFitter->SetParameter(2,
01063                         "Dm2Bar",
01064                         0.00238,0.2,1.0,0.0);
01065   fFitter->SetParameter(3,
01066                         "Sn2Bar",
01067                         1.0,0.2,1.0,0.0);
01068 }

void NuXFitAnalysis::SetupPars (  )  [private, virtual]

Definition at line 1036 of file NuXFitAnalysis.cxx.

References fanalysisSetting, NuXFit::kCPT, Msg::kFatal, NuXFit::kTransition, MSG, SetupCPTPars(), and SetupTransitionPars().

Referenced by CPTAnalysis(), and TransitionAnalysis().

01037 {
01038   if (NuXFit::kCPT == fanalysisSetting){
01039     this->SetupCPTPars();
01040     return;
01041   }
01042   else if (NuXFit::kTransition == fanalysisSetting){
01043     this->SetupTransitionPars();
01044     return;
01045   }
01046   else{
01047     MSG("NuXFitAnalysis.cxx",Msg::kFatal)
01048       << "Incorrect analysis setting" << endl;
01049     return;
01050   }
01051 }

void NuXFitAnalysis::SetupTransitionPars (  )  [private, virtual]

Definition at line 1071 of file NuXFitAnalysis.cxx.

References fFitter, fhNuBarCCCrossSections, fhNuBarCCSelectionEfficiency, fhNuMuCCCrossSections, fhNuMuCCSelectionEfficiency, fNuBarCCCrossSectionGraph, fNuMuCCCrossSectionGraph, fSelEffFileName, and fxsecfilename.

Referenced by SetupPars().

01072 {
01073   //Get cross-sections
01074   TFile *xsecfile = new TFile(fxsecfilename.c_str(),"READ");
01075 
01076   if (fNuMuCCCrossSectionGraph){
01077     delete fNuMuCCCrossSectionGraph;
01078     fNuMuCCCrossSectionGraph = 0;
01079   }
01080   if (fhNuMuCCCrossSections){
01081     delete fhNuMuCCCrossSections;
01082     fhNuMuCCCrossSections = 0;
01083   }
01084   TH1F* XSec_CC = (TH1F*) xsecfile->Get("h_numu_cc_tot");
01085   fhNuMuCCCrossSections = new TH1F(*XSec_CC);
01086   fhNuMuCCCrossSections->SetDirectory(0);
01087   Float_t *x = new Float_t[XSec_CC->GetNbinsX()];
01088   Float_t *y = new Float_t[XSec_CC->GetNbinsX()];
01089   for(int i=0;i<XSec_CC->GetNbinsX();i++) {
01090     x[i] = XSec_CC->GetBinCenter(i+1);
01091     y[i] = XSec_CC->GetBinContent(i+1);
01092   }
01093   fNuMuCCCrossSectionGraph = new TGraph(XSec_CC->GetNbinsX(),x,y);
01094   if (x) {delete[] x; x = 0;}
01095   if (y) {delete[] y; y = 0;}
01096 
01097   if (fNuBarCCCrossSectionGraph){
01098     delete fNuBarCCCrossSectionGraph;
01099     fNuBarCCCrossSectionGraph = 0;
01100   }
01101   if (fhNuBarCCCrossSections){
01102     delete fhNuBarCCCrossSections;
01103     fhNuBarCCCrossSections = 0;
01104   }
01105   XSec_CC = (TH1F*) xsecfile->Get("h_numubar_cc_tot");
01106   fhNuBarCCCrossSections = new TH1F(*XSec_CC);
01107   fhNuBarCCCrossSections->SetDirectory(0);
01108   x = new Float_t[XSec_CC->GetNbinsX()];
01109   y = new Float_t[XSec_CC->GetNbinsX()];
01110   for(int i=0;i<XSec_CC->GetNbinsX();i++) {
01111     x[i] = XSec_CC->GetBinCenter(i+1);
01112     y[i] = XSec_CC->GetBinContent(i+1);
01113   }
01114   fNuBarCCCrossSectionGraph = new TGraph(XSec_CC->GetNbinsX(),x,y);
01115   if (x) {delete[] x; x = 0;}
01116   if (y) {delete[] y; y = 0;}
01117   
01118   xsecfile->Close();
01119   if (xsecfile){delete xsecfile; xsecfile = 0;}
01120   
01121   //Get selection efficiencies
01122   TFile* selEffFile = new TFile(fSelEffFileName.c_str(),"READ");
01123 
01124   if (fhNuBarCCSelectionEfficiency){
01125     delete fhNuBarCCSelectionEfficiency;
01126     fhNuBarCCSelectionEfficiency = 0;
01127   }
01128   fhNuBarCCSelectionEfficiency = (TH1D*) selEffFile->Get("EfficiencyPQ_FD");
01129   fhNuBarCCSelectionEfficiency->SetDirectory(0);
01130 
01131   if (fhNuMuCCSelectionEfficiency){
01132     delete fhNuMuCCSelectionEfficiency;
01133     fhNuMuCCSelectionEfficiency = 0;
01134   }
01135   fhNuMuCCSelectionEfficiency = (TH1D*) selEffFile->Get("Efficiency_FD");
01136   fhNuMuCCSelectionEfficiency->SetDirectory(0);
01137 
01138   selEffFile->Close();
01139   if (selEffFile){delete selEffFile; selEffFile = 0;}
01140 
01141   //Setup fit parameters
01142   fFitter->SetParameter(0,
01143                         "transitionProb",
01144                         0.0,0.2,1.0,0.0);
01145 }

void NuXFitAnalysis::TransitionAnalysis ( const Double_t  dm2,
const Double_t  sn2 
) [virtual]

Definition at line 966 of file NuXFitAnalysis.cxx.

References CalculateLikelihood(), fanalysisSetting, fBestTransitionProb, fdm2, fdoGridSearch, fFitter, fhFDDataRecoENuMuBarCC, fhFDMCRecoENuMuBarCC, fhFDMCRecoENuMuCC, FillTransitionFDPrediction(), fOutputFile, fsn2, fwriteOutput, Msg::kInfo, NuXFit::kTransition, MSG, and SetupPars().

00968 {
00969   fanalysisSetting = NuXFit::kTransition;
00970   fdm2 = dm2;
00971   fsn2 = sn2;
00972 
00973   if (!this->CacheFDMCEvents()){return;}
00974   if (!this->FillFDDataHistograms()){return;}
00975 
00976   if (!fdoGridSearch){
00977     this->SetupPars();
00978     
00979     fFitter->Minimize();
00980     fFitter->PrintResults(0,0);
00981     
00982     fBestTransitionProb = fFitter->GetParameter(0);
00983   }
00984 
00985   if (fdoGridSearch){
00986     Double_t bestChi2 = 1.0e10;
00987     Double_t bestTransitionProb = 0.0;
00988     
00989     Double_t transitionProbLow = 0.0;
00990     Double_t transitionProbHigh = 1.0;
00991     Double_t transitionProbGranularity = 0.05;
00992     
00993     //Create the chi2 histogram
00994     Int_t numTransitionProbBins =
00995       (Int_t) round((transitionProbHigh-transitionProbLow)/
00996                     transitionProbGranularity) + 1;
00997     TH1D hChi2Trans("hChi2Trans",
00998                     "",
00999                     numTransitionProbBins,
01000                     transitionProbLow-transitionProbGranularity/2.0,
01001                     transitionProbHigh+transitionProbGranularity/2.0);
01002     for (Double_t transitionProb = transitionProbLow;
01003          transitionProb <= transitionProbHigh+transitionProbGranularity/2.0;
01004          transitionProb += transitionProbGranularity){
01005       MSG("NuMatrixFitter.cxx",Msg::kInfo)
01006         << "Fitting transitionProb = " << transitionProb << endl;
01007 
01008       vector<Double_t> vParams;
01009       vParams.push_back(transitionProb);
01010       this->FillTransitionFDPrediction(vParams);
01011       
01012       Double_t chi2 = this->CalculateLikelihood(fhFDMCRecoENuMuBarCC,
01013                                                 fhFDDataRecoENuMuBarCC);
01014       
01015       Int_t xBin = hChi2Trans.GetXaxis()->FindBin(transitionProb);
01016       hChi2Trans.SetBinContent(xBin,chi2);
01017       if (chi2 < bestChi2){
01018         bestChi2 = chi2;
01019         bestTransitionProb = transitionProb;
01020       }
01021     } //transitionProb
01022     fBestTransitionProb = bestTransitionProb;
01023   }
01024   
01025   vector<Double_t> vBestFit;
01026   vBestFit.push_back(fBestTransitionProb);
01027   this->FillTransitionFDPrediction(vBestFit);
01028   if (fwriteOutput){
01029     fOutputFile->cd();
01030     fhFDMCRecoENuMuCC->Write("BestFitFDMCRecoENuMuCC");
01031     fhFDMCRecoENuMuBarCC->Write("BestFitFDMCRecoENuMuBarCC");
01032   }
01033 }

Int_t NuXFitAnalysis::TruthIndex ( const NuEvent &  info  )  const [private, virtual]

Definition at line 717 of file NuXFitAnalysis.cxx.

References fvTrueEBinsNuMuBarCC, fvTrueEBinsNuMuCC, NuEvent::inu, and NuEvent::neuEnMC.

Referenced by CacheFDMCEvents().

00718 {
00719   Int_t numnubins = fvTrueEBinsNuMuCC.size();
00720   Int_t numbarbins = fvTrueEBinsNuMuBarCC.size();
00721 
00722   Int_t type = info.inu;
00723   const vector<Double_t>* truthbins;
00724   Int_t offset = 0;
00725   Int_t numbins = 0;
00726   if (14 == type){
00727     truthbins = &fvTrueEBinsNuMuCC;
00728     numbins = numnubins;
00729     offset = 0;
00730   }
00731   else if (-14 == type){
00732     truthbins = &fvTrueEBinsNuMuBarCC;
00733     numbins = numbarbins;
00734     offset = numnubins;
00735   }
00736   else{
00737     return numnubins + numbarbins;
00738   }
00739   for (Int_t i=1; i<numbins; ++i){
00740     if ((*truthbins)[i]>info.neuEnMC){
00741       return i - 1 + offset;
00742     }
00743   }
00744   if ((14 == type) || (-14 == type)){
00745     return (numbins + offset);
00746   }
00747   return numnubins + numbarbins;
00748 }

virtual double NuXFitAnalysis::Up (  )  const [inline, virtual]

Definition at line 36 of file NuXFitAnalysis.h.

References fUp.

00036 {return fUp;}//Chi2 errors; 0.5 for likelihood

virtual void NuXFitAnalysis::WriteOutput ( const Bool_t  writeOutput  )  [inline, virtual]

Definition at line 76 of file NuXFitAnalysis.h.

References fwriteOutput.

00077     {fwriteOutput = writeOutput;}

Member Data Documentation

NuXFit::NuXAnalysis_t NuXFitAnalysis::fanalysisSetting [private]

Definition at line 115 of file NuXFitAnalysis.h.

Referenced by CPTAnalysis(), NuXFitAnalysis(), SetupPars(), and TransitionAnalysis().

NuCuts::NuAnaVersion_t NuXFitAnalysis::fanaVersion [private]

Definition at line 126 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), and SelectionScheme().

Double_t NuXFitAnalysis::fBestDm2 [private]

Definition at line 121 of file NuXFitAnalysis.h.

Referenced by BestDm2(), and CPTAnalysis().

Double_t NuXFitAnalysis::fBestDm2Bar [private]

Definition at line 123 of file NuXFitAnalysis.h.

Referenced by BestDm2Bar(), and CPTAnalysis().

Double_t NuXFitAnalysis::fBestSn2 [private]

Definition at line 122 of file NuXFitAnalysis.h.

Referenced by BestSn2(), and CPTAnalysis().

Double_t NuXFitAnalysis::fBestSn2Bar [private]

Definition at line 124 of file NuXFitAnalysis.h.

Referenced by BestSn2Bar(), and CPTAnalysis().

Double_t NuXFitAnalysis::fBestTransitionProb [private]

Definition at line 125 of file NuXFitAnalysis.h.

Referenced by BestTransitionProb(), and TransitionAnalysis().

Double_t NuXFitAnalysis::fdm2 [private]

Definition at line 119 of file NuXFitAnalysis.h.

Referenced by TransitionAnalysis().

Bool_t NuXFitAnalysis::fdoGridSearch [private]

Definition at line 113 of file NuXFitAnalysis.h.

Referenced by CPTAnalysis(), DoGridSearch(), and TransitionAnalysis().

Double_t NuXFitAnalysis::ffdDataPoT [private]

Definition at line 117 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), and FDDataPoT().

Double_t NuXFitAnalysis::ffdMCPoT [private]

Definition at line 118 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents().

TFitterMinuit* NuXFitAnalysis::fFitter [private]

Definition at line 129 of file NuXFitAnalysis.h.

Referenced by CPTAnalysis(), NuXFitAnalysis(), SetupCPTPars(), SetupTransitionPars(), and TransitionAnalysis().

TH1D* NuXFitAnalysis::fhFDDataRecoENuMuBarCC [private]

Definition at line 131 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), CalculateLikelihood(), CPTAnalysis(), CreateFDNuMuBarCCDataHisto(), FillFDDataHistograms(), NuXFitAnalysis(), and TransitionAnalysis().

TH1D* NuXFitAnalysis::fhFDDataRecoENuMuCC [private]

Definition at line 130 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), CalculateLikelihood(), CreateFDNuMuCCDataHisto(), FillFDDataHistograms(), and NuXFitAnalysis().

TH1D* NuXFitAnalysis::fhFDMCRecoENuMuBarCC [private]

Definition at line 133 of file NuXFitAnalysis.h.

Referenced by CalculateLikelihood(), CPTAnalysis(), CreateFDNuMuBarCCMCHisto(), NuXFitAnalysis(), and TransitionAnalysis().

TH1D* NuXFitAnalysis::fhFDMCRecoENuMuCC [private]

Definition at line 132 of file NuXFitAnalysis.h.

Referenced by CalculateLikelihood(), CPTAnalysis(), CreateFDNuMuCCMCHisto(), NuXFitAnalysis(), and TransitionAnalysis().

TH1D* NuXFitAnalysis::fhFDNuMuBarCCDataFromFile [private]

Definition at line 142 of file NuXFitAnalysis.h.

Referenced by CreateFDNuMuBarCCDataHisto(), CreateFDNuMuBarCCMCHisto(), CreateFDNuMuCCDataHisto(), CreateFDNuMuCCMCHisto(), FDNuMuBarCCData(), FillFDDataHistograms(), NuXFitAnalysis(), and ~NuXFitAnalysis().

TH1D* NuXFitAnalysis::fhFDNuMuCCDataFromFile [private]

Definition at line 141 of file NuXFitAnalysis.h.

Referenced by CreateFDNuMuBarCCDataHisto(), CreateFDNuMuBarCCMCHisto(), CreateFDNuMuCCDataHisto(), CreateFDNuMuCCMCHisto(), FDNuMuCCData(), FillFDDataHistograms(), NuXFitAnalysis(), and ~NuXFitAnalysis().

TH1F* NuXFitAnalysis::fhNuBarCCCrossSections [private]

Definition at line 149 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), and SetupTransitionPars().

TH1D* NuXFitAnalysis::fhNuBarCCSelectionEfficiency [private]

Definition at line 147 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), and SetupTransitionPars().

TH1F* NuXFitAnalysis::fhNuMuCCCrossSections [private]

Definition at line 150 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), and SetupTransitionPars().

TH1D* NuXFitAnalysis::fhNuMuCCSelectionEfficiency [private]

Definition at line 148 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), and SetupTransitionPars().

TGraph* NuXFitAnalysis::fNuBarCCCrossSectionGraph [private]

Definition at line 145 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), and SetupTransitionPars().

TGraph* NuXFitAnalysis::fNuMuCCCrossSectionGraph [private]

Definition at line 146 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), and SetupTransitionPars().

NuSystematic* NuXFitAnalysis::fnuSystematic [private]

Definition at line 165 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), NuXFitAnalysis(), and ~NuXFitAnalysis().

TFile* NuXFitAnalysis::fOutputFile [private]

Definition at line 138 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), CPTAnalysis(), FillFDDataHistograms(), NuXFitAnalysis(), TransitionAnalysis(), and ~NuXFitAnalysis().

std::string NuXFitAnalysis::fSelEffFileName [private]

Definition at line 134 of file NuXFitAnalysis.h.

Referenced by NuXFitAnalysis(), SelectionEfficiencyFileName(), and SetupTransitionPars().

Double_t NuXFitAnalysis::fsn2 [private]

Definition at line 120 of file NuXFitAnalysis.h.

Referenced by TransitionAnalysis().

NuTreeWrapper* NuXFitAnalysis::ftFDDataTree [private]

Definition at line 127 of file NuXFitAnalysis.h.

Referenced by FillFDDataHistograms(), and NuXFitAnalysis().

NuTreeWrapper* NuXFitAnalysis::ftFDMCTree [private]

Definition at line 128 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), and NuXFitAnalysis().

Double_t NuXFitAnalysis::fUp [private]

Definition at line 116 of file NuXFitAnalysis.h.

Referenced by SetErrorDef(), and Up().

std::vector<NuEvent> NuXFitAnalysis::fvFDMCCCNuMuBarEvents [private]

Definition at line 154 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents().

std::vector<NuEvent> NuXFitAnalysis::fvFDMCCCNuMuEvents [private]

Definition at line 153 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents().

std::vector<Double_t> NuXFitAnalysis::fvFDRecoENuMuBarCCBins [private]

Definition at line 158 of file NuXFitAnalysis.h.

Referenced by CreateFDNuMuBarCCDataHisto(), CreateFDNuMuBarCCMCHisto(), and FDRecoENuMuBarCCBins().

std::vector<Double_t> NuXFitAnalysis::fvFDRecoENuMuCCBins [private]

Definition at line 157 of file NuXFitAnalysis.h.

Referenced by CreateFDNuMuCCDataHisto(), CreateFDNuMuCCMCHisto(), and FDRecoENuMuCCBins().

std::vector<Double_t> NuXFitAnalysis::fvNDFitPars [private]

Definition at line 161 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), and NDFitResults().

std::vector<Double_t> NuXFitAnalysis::fvTrueEBinsNuMuBarCC [private]

Definition at line 163 of file NuXFitAnalysis.h.

Referenced by NDFitBinningNuMuBarCC(), and TruthIndex().

std::vector<Double_t> NuXFitAnalysis::fvTrueEBinsNuMuCC [private]

Definition at line 162 of file NuXFitAnalysis.h.

Referenced by NDFitBinningNuMuCC(), and TruthIndex().

Bool_t NuXFitAnalysis::fwriteOutput [private]

Definition at line 114 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), CPTAnalysis(), FillFDDataHistograms(), TransitionAnalysis(), and WriteOutput().

std::string NuXFitAnalysis::fxsecfilename [private]

Definition at line 135 of file NuXFitAnalysis.h.

Referenced by CrossSectionFileName(), NuXFitAnalysis(), and SetupTransitionPars().

The documentation for this class was generated from the following files:
Generated on Mon Nov 5 22:01:45 2012 for loon by  doxygen 1.4.7