Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

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 const Double_t CalculateLikelihood () const
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 const Double_t BestDm2 () const
virtual const Double_t BestSn2 () const
virtual const Double_t BestDm2Bar () const
virtual const Double_t BestSn2Bar () const
virtual const Double_t BestTransitionProb () const
virtual void CPTAnalysis ()
virtual void TransitionAnalysis (const Double_t dm2, const Double_t sn2)

Private Member Functions

virtual const Bool_t CacheFDMCEvents ()
virtual const Bool_t CreateHistograms ()
virtual const Bool_t CreateFDNuMuCCDataHisto ()
virtual const Bool_t CreateFDNuMuBarCCDataHisto ()
virtual const Bool_t CreateFDNuMuCCMCHisto ()
virtual const Bool_t CreateFDNuMuBarCCMCHisto ()
virtual const Bool_t FillFDDataHistograms ()
virtual const Double_t NuBarCCCrossSection (const Double_t trueNuE) const
virtual const Double_t NuMuCCCrossSection (const Double_t trueNuE) const
virtual const Double_t NuBarCCSelectionEfficiency (const Double_t trueNuE) const
virtual const Double_t NuMuCCSelectionEfficiency (const Double_t trueNuE) const
virtual const NuXSecFit::NuSelectionResult_t SelectedAs (NuEvent &nuEvent) const
virtual const NuCuts::NuAnaVersion_t SelectionScheme () const
virtual void SetupPars ()
virtual void SetupCPTPars ()
virtual void SetupTransitionPars ()
virtual const 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

Constructor & Destructor Documentation

NuXFitAnalysis::NuXFitAnalysis (   )  [explicit]
 

Definition at line 112 of file NuXFitAnalysis.cxx.

00113   : fdoGridSearch(false),
00114     fwriteOutput(true),
00115     fUp(1.0),
00116     ffdDataPoT(0.0),
00117     ffdMCPoT(0.0),
00118     fdm2(0.0),
00119     fsn2(0.0),
00120     fBestDm2(-1.0),
00121     fBestSn2(-1.0),
00122     fBestDm2Bar(-1.0),
00123     fBestSn2Bar(-1.0)
00124 {
00125   fanalysisSetting = NuXFit::kUnknown;
00126   fanaVersion = NuCuts::kJJE1;
00127   fnuSystematic = new NuSystematic();
00128 
00129   fSelEffFileName = "";
00130   fxsecfilename = "";
00131 
00132   fOutputFile = 0;
00133 
00134   ftFDDataTree = 0;
00135   ftFDMCTree = 0;
00136 
00137   fhNuBarCCSelectionEfficiency = 0;
00138   fhNuMuCCSelectionEfficiency = 0;
00139   fNuBarCCCrossSectionGraph = 0;
00140   fNuMuCCCrossSectionGraph = 0;
00141   fhNuBarCCCrossSections = 0;
00142   fhNuMuCCCrossSections = 0;
00143 
00144   fhFDNuMuCCDataFromFile = 0;
00145   fhFDNuMuBarCCDataFromFile = 0;
00146 
00147   fhFDDataRecoENuMuCC = 0;
00148   fhFDDataRecoENuMuBarCC = 0;
00149   fhFDMCRecoENuMuCC = 0;
00150   fhFDMCRecoENuMuBarCC = 0;
00151 
00152   fFitter = new TFitterMinuit();
00153   fFitter->CreateMinimizer();
00154   fFitter->SetMinuitFCN(this);
00155 }

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

Definition at line 158 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, and fxsecfilename.

00159   : fdoGridSearch(false),
00160     fUp(1.0),
00161     ffdDataPoT(0.0),
00162     ffdMCPoT(0.0),
00163     fdm2(0.0),
00164     fsn2(0.0)
00165 {
00166   fanalysisSetting = NuXFit::kUnknown;
00167   fanaVersion = NuCuts::kJJE1;
00168   fnuSystematic = new NuSystematic(xmlConfig);
00169 
00170   fSelEffFileName = "";
00171   fxsecfilename = "";
00172 
00173   fOutputFile = 0;
00174 
00175   ftFDDataTree = 0;
00176   ftFDMCTree = 0;
00177 
00178   fhNuBarCCSelectionEfficiency = 0;
00179   fhNuMuCCSelectionEfficiency = 0;
00180   fNuBarCCCrossSectionGraph = 0;
00181   fNuMuCCCrossSectionGraph = 0;
00182   fhNuBarCCCrossSections = 0;
00183   fhNuMuCCCrossSections = 0;
00184 
00185   fhFDNuMuCCDataFromFile = 0;
00186   fhFDNuMuBarCCDataFromFile = 0;
00187 
00188   fhFDDataRecoENuMuCC = 0;
00189   fhFDDataRecoENuMuBarCC = 0;
00190   fhFDMCRecoENuMuCC = 0;
00191   fhFDMCRecoENuMuBarCC = 0;
00192 
00193   fFitter = new TFitterMinuit();
00194   fFitter->CreateMinimizer();
00195   fFitter->SetMinuitFCN(this);
00196 }

NuXFitAnalysis::~NuXFitAnalysis (   )  [virtual]
 

Definition at line 200 of file NuXFitAnalysis.cxx.

References fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fnuSystematic, and fOutputFile.

00201 {
00202   if (fOutputFile){
00203     fOutputFile->Close();
00204     delete fOutputFile;
00205     fOutputFile = 0;
00206   }
00207 
00208   if (fnuSystematic){delete fnuSystematic; fnuSystematic = 0;}
00209 
00210   if (fhFDNuMuCCDataFromFile){
00211     delete fhFDNuMuCCDataFromFile; fhFDNuMuCCDataFromFile = 0;
00212   }
00213   if (fhFDNuMuBarCCDataFromFile){
00214     delete fhFDNuMuBarCCDataFromFile; fhFDNuMuBarCCDataFromFile = 0;
00215   }
00216 }

Member Function Documentation

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

Definition at line 80 of file NuXFitAnalysis.h.

00080 {return fBestDm2;}

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

Definition at line 82 of file NuXFitAnalysis.h.

00082 {return fBestDm2Bar;}

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

Definition at line 81 of file NuXFitAnalysis.h.

00081 {return fBestSn2;}

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

Definition at line 83 of file NuXFitAnalysis.h.

00083 {return fBestSn2Bar;}

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

Definition at line 84 of file NuXFitAnalysis.h.

00085     {return fBestTransitionProb;}

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

Definition at line 1239 of file NuXFitAnalysis.cxx.

References NuEvent::energy, ffdDataPoT, ffdMCPoT, fhFDDataRecoENuMuBarCC, fhFDDataRecoENuMuCC, fnuSystematic, fOutputFile, ftFDMCTree, fvFDMCCCNuMuBarEvents, fvFDMCCCNuMuEvents, fvNDFitPars, NuTreeWrapper::GetEntries(), NuTreeWrapper::GetInfoObject(), MSG, NuXSecFit::NuSelectionResult_t, NuEvent::rw, SelectedAs(), NuSystematic::Shift(), and TruthIndex().

Referenced by CPTAnalysis(), and TransitionAnalysis().

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

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

Definition at line 242 of file NuXFitAnalysis.cxx.

00245 {
00246   //Aim to minimise -2lnL. That's what I'm returning.
00247 
00248   Double_t like = 0;
00249 
00250   for (Int_t i=1; i<=fdPred->GetNbinsX(); ++i){
00251     //Bizarre limits because root histograms are silly
00252     Double_t mnu = fdPred->GetBinContent(i);
00253     Double_t dnu = fdData->GetBinContent(i);
00254     if (mnu<0.0001){mnu = 0.0001;}
00255     if (dnu){
00256       like += 2*(mnu - dnu + dnu*log(dnu/mnu));
00257     }
00258     else{like += 2*(mnu - dnu);}
00259   }
00260 //   cout << "Like = " << like << endl;
00261   return like;
00262 }

const Double_t NuXFitAnalysis::CalculateLikelihood (   )  const [virtual]
 

Definition at line 265 of file NuXFitAnalysis.cxx.

References fhFDDataRecoENuMuBarCC, fhFDDataRecoENuMuCC, fhFDMCRecoENuMuBarCC, and fhFDMCRecoENuMuCC.

Referenced by CPTAnalysis(), and TransitionAnalysis().

00266 {
00267   //Aim to minimise -2lnL. That's what I'm returning.
00268 
00269   Double_t like = 0;
00270 
00271   for (Int_t i=1; i<=fhFDMCRecoENuMuCC->GetNbinsX(); ++i){
00272     //Bizarre limits because root histograms are silly
00273     Double_t mnu = fhFDMCRecoENuMuCC->GetBinContent(i);
00274     Double_t dnu = fhFDDataRecoENuMuCC->GetBinContent(i);
00275     if (mnu<0.0001){mnu = 0.0001;}
00276     if (dnu){
00277       like += 2*(mnu - dnu + dnu*log(dnu/mnu));
00278     }
00279     else{like += 2*(mnu - dnu);}
00280   }
00281 
00282   for (Int_t i=1; i<=fhFDMCRecoENuMuBarCC->GetNbinsX(); ++i){
00283     Double_t mbar = fhFDMCRecoENuMuBarCC->GetBinContent(i);
00284     Double_t dbar = fhFDDataRecoENuMuBarCC->GetBinContent(i);
00285     if (mbar<0.0001){mbar = 0.0001;}
00286     if (dbar){
00287       like += 2*(mbar - dbar + dbar*log(dbar/mbar));
00288     }
00289     else{like += 2*(mbar - dbar);}
00290   }
00291 //   cout << "Like = " << like << endl;
00292   return like;
00293 }

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

Definition at line 796 of file NuXFitAnalysis.cxx.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

00797 {
00798   fanalysisSetting = analSetting;
00799   this->CreateHistograms();
00800   this->FillFDDataHistograms();
00801   this->CacheFDMCEvents();
00802 
00803   this->SetupPars();
00804 }

void NuXFitAnalysis::CPTAnalysis (   )  [virtual]
 

Definition at line 807 of file NuXFitAnalysis.cxx.

References CacheFDMCEvents(), CalculateLikelihood(), CreateHistograms(), fanalysisSetting, fBestDm2, fBestDm2Bar, fBestSn2, fBestSn2Bar, fFitter, fhFDDataRecoENuMuBarCC, fhFDMCRecoENuMuBarCC, fhFDMCRecoENuMuCC, FillCPTFDPrediction(), FillFDDataHistograms(), fOutputFile, MSG, SetupPars(), and NuTreeWrapper::Write().

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

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

Definition at line 307 of file NuXFitAnalysis.cxx.

References fhFDDataRecoENuMuBarCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fvFDRecoENuMuBarCCBins, and MSG.

Referenced by CreateHistograms().

00308 {
00309   if (fhFDDataRecoENuMuBarCC) {
00310     delete fhFDDataRecoENuMuBarCC; fhFDDataRecoENuMuBarCC = 0;
00311   }
00312 
00313   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00314     fhFDDataRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
00315     fhFDDataRecoENuMuBarCC->Reset();
00316     return true;
00317   }
00318 
00319   Int_t size = fvFDRecoENuMuBarCCBins.size();
00320   if (!size){
00321     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00322       << "FD reconstructed energy binning not supplied."
00323       << endl;
00324     return false;
00325   }
00326 
00327   Double_t* recoEBinEdges = new Double_t[size];
00328 
00329   Int_t i=0;
00330   for (vector<Double_t>::const_iterator it =
00331          fvFDRecoENuMuBarCCBins.begin();
00332        it != fvFDRecoENuMuBarCCBins.end();
00333        ++it, ++i){
00334     recoEBinEdges[i] = *it;
00335   }
00336 
00337   fhFDDataRecoENuMuBarCC = new TH1D("fhFDDataRecoENuMuBarCC",
00338                                "FD NuMuBar CC data",
00339                                size-1,
00340                                recoEBinEdges);
00341 
00342   if (!fhFDDataRecoENuMuBarCC) return false;
00343   return true;
00344 }

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

Definition at line 387 of file NuXFitAnalysis.cxx.

References fhFDMCRecoENuMuBarCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fvFDRecoENuMuBarCCBins, and MSG.

Referenced by CreateHistograms().

00388 {
00389   if (fhFDMCRecoENuMuBarCC) {
00390     delete fhFDMCRecoENuMuBarCC; fhFDMCRecoENuMuBarCC = 0;
00391   }
00392 
00393   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00394     fhFDMCRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
00395     fhFDMCRecoENuMuBarCC->Reset();
00396     return true;
00397   }
00398 
00399   Int_t size = fvFDRecoENuMuBarCCBins.size();
00400   if (!size){
00401     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00402       << "FD reconstructed energy binning not supplied."
00403       << endl;
00404     return false;
00405   }
00406 
00407   Double_t* recoEBinEdges = new Double_t[size];
00408 
00409   Int_t i=0;
00410   for (vector<Double_t>::const_iterator it =
00411          fvFDRecoENuMuBarCCBins.begin();
00412        it != fvFDRecoENuMuBarCCBins.end();
00413        ++it, ++i){
00414     recoEBinEdges[i] = *it;
00415   }
00416 
00417   fhFDMCRecoENuMuBarCC = new TH1D("fhFDMCRecoENuMuBarCC",
00418                                "FD NuMuBar CC prediction",
00419                                size-1,
00420                                recoEBinEdges);
00421 
00422   if (!fhFDMCRecoENuMuBarCC) return false;
00423   return true;
00424 }

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

Definition at line 347 of file NuXFitAnalysis.cxx.

References fhFDDataRecoENuMuCC, fhFDNuMuCCDataFromFile, fvFDRecoENuMuCCBins, and MSG.

Referenced by CreateHistograms().

00348 {
00349   if (fhFDDataRecoENuMuCC) {
00350     delete fhFDDataRecoENuMuCC; fhFDDataRecoENuMuCC = 0;
00351   }
00352 
00353   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00354     fhFDDataRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
00355     fhFDDataRecoENuMuCC->Reset();
00356     return true;
00357   }
00358 
00359   Int_t size = fvFDRecoENuMuCCBins.size();
00360   if (!size){
00361     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00362       << "FD reconstructed energy binning not supplied."
00363       << endl;
00364     return false;
00365   }
00366 
00367   Double_t* recoEBinEdges = new Double_t[size];
00368 
00369   Int_t i=0;
00370   for (vector<Double_t>::const_iterator it =
00371          fvFDRecoENuMuCCBins.begin();
00372        it != fvFDRecoENuMuCCBins.end();
00373        ++it, ++i){
00374     recoEBinEdges[i] = *it;
00375   }
00376 
00377   fhFDDataRecoENuMuCC = new TH1D("fhFDDataRecoENuMuCC",
00378                                "FD NuMu CC data",
00379                                size-1,
00380                                recoEBinEdges);
00381 
00382   if (!fhFDDataRecoENuMuCC) return false;
00383   return true;
00384 }

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

Definition at line 427 of file NuXFitAnalysis.cxx.

References fhFDMCRecoENuMuCC, fhFDNuMuCCDataFromFile, fvFDRecoENuMuCCBins, and MSG.

Referenced by CreateHistograms().

00428 {
00429   if (fhFDMCRecoENuMuCC) {
00430     delete fhFDMCRecoENuMuCC; fhFDMCRecoENuMuCC = 0;
00431   }
00432 
00433   if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00434     fhFDMCRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
00435     fhFDMCRecoENuMuCC->Reset();
00436     return true;
00437   }
00438 
00439   Int_t size = fvFDRecoENuMuCCBins.size();
00440   if (!size){
00441     MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00442       << "FD reconstructed energy binning not supplied."
00443       << endl;
00444     return false;
00445   }
00446 
00447   Double_t* recoEBinEdges = new Double_t[size];
00448 
00449   Int_t i=0;
00450   for (vector<Double_t>::const_iterator it =
00451          fvFDRecoENuMuCCBins.begin();
00452        it != fvFDRecoENuMuCCBins.end();
00453        ++it, ++i){
00454     recoEBinEdges[i] = *it;
00455   }
00456 
00457   fhFDMCRecoENuMuCC = new TH1D("fhFDMCRecoENuMuCC",
00458                                "FD NuMu CC prediction",
00459                                size-1,
00460                                recoEBinEdges);
00461 
00462   if (!fhFDMCRecoENuMuCC) return false;
00463   return true;
00464 }

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

Definition at line 784 of file NuXFitAnalysis.cxx.

References CreateFDNuMuBarCCDataHisto(), CreateFDNuMuBarCCMCHisto(), CreateFDNuMuCCDataHisto(), and CreateFDNuMuCCMCHisto().

Referenced by CPTAnalysis().

00785 {
00786   Bool_t goodConfig = true;
00787   if (!this->CreateFDNuMuCCDataHisto()) goodConfig = false;
00788   if (!this->CreateFDNuMuBarCCDataHisto()) goodConfig = false;
00789   if (!this->CreateFDNuMuCCMCHisto()) goodConfig = false;
00790   if (!this->CreateFDNuMuBarCCMCHisto()) goodConfig = false;
00791   return goodConfig;
00792 }

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

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

Definition at line 736 of file NuXFitAnalysis.cxx.

References ffdDataPoT, ftFDDataTree, NuTreeWrapper::GetPoT(), and MSG.

00737 {
00738   if (ftFDDataTree){delete ftFDDataTree; ftFDDataTree = 0;}
00739   ftFDDataTree = new NuTreeWrapper(fdDataFileName);
00740 
00741   //Get the total PoT
00742   ffdDataPoT = ftFDDataTree->GetPoT();
00743   
00744   MSG("NuXFitAnalysis.cxx",Msg::kInfo)
00745     << "fdDataPoT: " << ffdDataPoT
00746     << endl;
00747 }

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

Definition at line 49 of file NuXFitAnalysis.h.

References ffdDataPoT.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

00050     {ffdDataPoT = pot;}

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

Definition at line 770 of file NuXFitAnalysis.cxx.

References ffdMCPoT, ftFDMCTree, NuTreeWrapper::GetPoT(), and MSG.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

00771 {
00772   if (ftFDMCTree){delete ftFDMCTree; ftFDMCTree = 0;}
00773   ftFDMCTree = new NuTreeWrapper(fdMCFileName);
00774 
00775   //Get the total PoT
00776   ffdMCPoT = ftFDMCTree->GetPoT();
00777   
00778   MSG("NuXFitAnalysis.cxx",Msg::kInfo)
00779     << "fdMCPoT: " << ffdMCPoT
00780     << endl;
00781 }

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

Definition at line 750 of file NuXFitAnalysis.cxx.

References fhFDNuMuBarCCDataFromFile.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

00751 {
00752   if (fhFDNuMuBarCCDataFromFile){
00753     delete fhFDNuMuBarCCDataFromFile; fhFDNuMuBarCCDataFromFile = 0;
00754   }
00755   fhFDNuMuBarCCDataFromFile = new TH1D(fdData);
00756   fhFDNuMuBarCCDataFromFile->SetDirectory(0);
00757 }

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

Definition at line 760 of file NuXFitAnalysis.cxx.

References fhFDNuMuCCDataFromFile.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

00761 {
00762   if (fhFDNuMuCCDataFromFile){
00763     delete fhFDNuMuCCDataFromFile; fhFDNuMuCCDataFromFile = 0;
00764   }
00765   fhFDNuMuCCDataFromFile = new TH1D(fdData);
00766   fhFDNuMuCCDataFromFile->SetDirectory(0);
00767 }

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

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

Definition at line 468 of file NuXFitAnalysis.cxx.

References NuEvent::iaction, NuEvent::inu, NuEvent::neuEnMC, NuUtilities::OscillationWeight(), NuEvent::rw, NuEvent::shwEn, and NuEvent::trkEn.

Referenced by CPTAnalysis().

00469 {
00470   //Reset recoE histograms (removes bin contents and errors)
00471   fhFDMCRecoENuMuCC->Reset();
00472   fhFDMCRecoENuMuBarCC->Reset();
00473 
00474   Double_t shwEShift=1.0;
00475   Double_t trkEShift = 1.0;
00476 
00477   Double_t Dm2 = par[0];
00478   Double_t Sn2 = par[1];
00479   Double_t Dm2Bar = par[2];
00480   Double_t Sn2Bar = par[3];
00481 
00482   //Fill the nubar histogram, weighted with truth parameters
00483   for (vector<NuEvent>::const_iterator itBar
00484          = fvFDMCCCNuMuBarEvents.begin();
00485        itBar!=fvFDMCCCNuMuBarEvents.end();
00486        ++itBar){
00487     NuEvent barEvent = *itBar;
00488     Int_t truthpar = this->TruthIndex(barEvent);
00489     Double_t barweight = 1.0;
00490     barweight *= barEvent.rw;
00491     if (truthpar>=0){
00492       barweight *= fvNDFitPars[truthpar];
00493     }
00494     Double_t thisSn2 = 0.0;
00495     Double_t thisDm2 = 0.0;
00496     if (1==barEvent.iaction){
00497       if (-14==barEvent.inu){
00498         thisSn2 = Sn2Bar;
00499         thisDm2 = Dm2Bar;
00500       }
00501       if (14==barEvent.inu){
00502         thisSn2 = Sn2;
00503         thisDm2 = Dm2;
00504       }
00505     }
00506     Double_t oscweightbar = NuUtilities::OscillationWeight(barEvent.neuEnMC,
00507                                                            thisDm2, thisSn2);
00508     barweight *= oscweightbar;
00509     Double_t recoNuE = shwEShift*(barEvent.shwEn)
00510       + trkEShift*(barEvent.trkEn);
00511     fhFDMCRecoENuMuBarCC->Fill(recoNuE,barweight);
00512   }
00513   if (ffdMCPoT){fhFDMCRecoENuMuBarCC->Scale(ffdDataPoT/ffdMCPoT);}
00514 
00515   //Fill the numu histogram, weighted with truth parameters
00516   for (vector<NuEvent>::const_iterator itNu
00517          = fvFDMCCCNuMuEvents.begin();
00518        itNu!=fvFDMCCCNuMuEvents.end();
00519        ++itNu){
00520     NuEvent nuEvent = *itNu;
00521     Int_t truthpar = this->TruthIndex(nuEvent);
00522     Double_t nuweight = 1.0;
00523     nuweight *= nuEvent.rw;
00524     if (truthpar>=0){
00525       nuweight *= fvNDFitPars[truthpar];
00526     }
00527     Double_t thisSn2 = 0.0;
00528     Double_t thisDm2 = 0.0;
00529     if (1==nuEvent.iaction){
00530       if (-14==nuEvent.inu){
00531         thisSn2 = Sn2Bar;
00532         thisDm2 = Dm2Bar;
00533       }
00534       if (14==nuEvent.inu){
00535         thisSn2 = Sn2;
00536         thisDm2 = Dm2;
00537       }
00538     }
00539     Double_t oscweight = NuUtilities::OscillationWeight(nuEvent.neuEnMC,
00540                                                         thisDm2, thisSn2);
00541     nuweight *= oscweight;
00542     Double_t recoNuE = shwEShift*(nuEvent.shwEn)
00543       + trkEShift*(nuEvent.trkEn);
00544     fhFDMCRecoENuMuCC->Fill(recoNuE,nuweight);
00545   }
00546   if (ffdMCPoT){fhFDMCRecoENuMuCC->Scale(ffdDataPoT/ffdMCPoT);}
00547 }

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

Definition at line 1133 of file NuXFitAnalysis.cxx.

References NuEvent::energy, fhFDDataRecoENuMuBarCC, fhFDDataRecoENuMuCC, fhFDNuMuBarCCDataFromFile, fhFDNuMuCCDataFromFile, fOutputFile, ftFDDataTree, NuTreeWrapper::GetEntries(), NuTreeWrapper::GetInfoObject(), NuEvent::iaction, NuEvent::inu, MSG, NuEvent::neuEnMC, NuXSecFit::NuSelectionResult_t, NuUtilities::OscillationWeight(), NuEvent::rw, SelectedAs(), and NuTreeWrapper::Write().

Referenced by CPTAnalysis(), and TransitionAnalysis().

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

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

Definition at line 551 of file NuXFitAnalysis.cxx.

References NuEvent::iaction, NuEvent::inu, NuEvent::neuEnMC, NuUtilities::OscillationWeight(), NuEvent::Reset(), NuEvent::rw, NuEvent::shwEn, and NuEvent::trkEn.

Referenced by TransitionAnalysis().

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

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

Definition at line 64 of file NuXFitAnalysis.h.

References fvTrueEBinsNuMuBarCC.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

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.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

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.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

00061     {fvNDFitPars = xSecWeights;}

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

Definition at line 669 of file NuXFitAnalysis.cxx.

00670 {
00671   //  return fNuBarCCCrossSectionGraph->Eval(trueNuE,0,"");
00672   return fhNuBarCCCrossSections->
00673     GetBinContent(fhNuBarCCCrossSections->FindBin(trueNuE));
00674 }

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

Definition at line 678 of file NuXFitAnalysis.cxx.

00679 {
00680   return fhNuBarCCSelectionEfficiency->
00681     GetBinContent(fhNuBarCCSelectionEfficiency->FindBin(trueNuE));
00682 }

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

Definition at line 686 of file NuXFitAnalysis.cxx.

00687 {
00688   //  return fNuMuCCCrossSectionGraph->Eval(trueNuE,0,"");
00689   return fhNuMuCCCrossSections->
00690     GetBinContent(fhNuMuCCCrossSections->FindBin(trueNuE));
00691 }

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

Definition at line 695 of file NuXFitAnalysis.cxx.

00696 {
00697   return fhNuMuCCSelectionEfficiency->
00698     GetBinContent(fhNuMuCCSelectionEfficiency->FindBin(trueNuE));
00699 }

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

Definition at line 220 of file NuXFitAnalysis.cxx.

References MSG.

00221 {
00222   static Int_t fitcounter = 0;
00223   if (!(fitcounter%50)){
00224     cout << "Minuit FD XFit call " << fitcounter << endl;
00225   }
00226   ++fitcounter;
00227   if (NuXFit::kCPT == fanalysisSetting){
00228     this->FillCPTFDPrediction(pars);
00229   }
00230   else if(NuXFit::kTransition == fanalysisSetting){
00231     this->FillTransitionFDPrediction(pars);
00232   }
00233   else{
00234     MSG("NuXFitAnalysis.cxx",Msg::kFatal)
00235       << "Incorrect analysis setting" << endl;
00236     return -1.0;
00237   }
00238   return this->CalculateLikelihood();
00239 }

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

Definition at line 296 of file NuXFitAnalysis.cxx.

References fOutputFile.

00297 {
00298   if (fOutputFile){
00299     fOutputFile->Close();
00300     delete fOutputFile;
00301     fOutputFile = 0;
00302   }
00303   fOutputFile = new TFile(outFile.c_str(),"RECREATE");
00304 }

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

Definition at line 1311 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(), and SelectionScheme().

Referenced by CacheFDMCEvents(), and FillFDDataHistograms().

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

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

Definition at line 67 of file NuXFitAnalysis.h.

References fSelEffFileName.

00068     {fSelEffFileName = selEffFileName;}

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

Definition at line 106 of file NuXFitAnalysis.h.

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 1039 of file NuXFitAnalysis.cxx.

References fFitter.

Referenced by SetupPars().

01040 {
01041   fFitter->SetParameter(0,
01042                         "Dm2",
01043                         0.00238,0.2,1.0,0.0);
01044   fFitter->SetParameter(1,
01045                         "Sn2",
01046                         1.0,0.2,1.0,0.0);
01047   fFitter->SetParameter(2,
01048                         "Dm2Bar",
01049                         0.00238,0.2,1.0,0.0);
01050   fFitter->SetParameter(3,
01051                         "Sn2Bar",
01052                         1.0,0.2,1.0,0.0);
01053 }

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

Definition at line 1021 of file NuXFitAnalysis.cxx.

References MSG, SetupCPTPars(), and SetupTransitionPars().

Referenced by CPTAnalysis(), and TransitionAnalysis().

01022 {
01023   if (NuXFit::kCPT == fanalysisSetting){
01024     this->SetupCPTPars();
01025     return;
01026   }
01027   else if (NuXFit::kTransition == fanalysisSetting){
01028     this->SetupTransitionPars();
01029     return;
01030   }
01031   else{
01032     MSG("NuXFitAnalysis.cxx",Msg::kFatal)
01033       << "Incorrect analysis setting" << endl;
01034     return;
01035   }
01036 }

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

Definition at line 1056 of file NuXFitAnalysis.cxx.

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

Referenced by SetupPars().

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

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

Definition at line 951 of file NuXFitAnalysis.cxx.

References CacheFDMCEvents(), CalculateLikelihood(), fanalysisSetting, fBestTransitionProb, fdm2, fFitter, fhFDDataRecoENuMuBarCC, fhFDMCRecoENuMuBarCC, fhFDMCRecoENuMuCC, FillFDDataHistograms(), FillTransitionFDPrediction(), fOutputFile, fsn2, MSG, SetupPars(), and NuTreeWrapper::Write().

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

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

Definition at line 702 of file NuXFitAnalysis.cxx.

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

Referenced by CacheFDMCEvents().

00703 {
00704   Int_t numnubins = fvTrueEBinsNuMuCC.size();
00705   Int_t numbarbins = fvTrueEBinsNuMuBarCC.size();
00706 
00707   Int_t type = info.inu;
00708   const vector<Double_t>* truthbins;
00709   Int_t offset = 0;
00710   Int_t numbins = 0;
00711   if (14 == type){
00712     truthbins = &fvTrueEBinsNuMuCC;
00713     numbins = numnubins;
00714     offset = 0;
00715   }
00716   else if (-14 == type){
00717     truthbins = &fvTrueEBinsNuMuBarCC;
00718     numbins = numbarbins;
00719     offset = numnubins;
00720   }
00721   else{
00722     return numnubins + numbarbins;
00723   }
00724   for (Int_t i=1; i<numbins; ++i){
00725     if ((*truthbins)[i]>info.neuEnMC){
00726       return i - 1 + offset;
00727     }
00728   }
00729   if ((14 == type) || (-14 == type)){
00730     return (numbins + offset);
00731   }
00732   return numnubins + numbarbins;
00733 }

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

Definition at line 36 of file NuXFitAnalysis.h.

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.

Referenced by NuMultiRunXFitAnalysis::ConfigureExtrapolators().

00077     {fwriteOutput = writeOutput;}

Member Data Documentation

NuXFit::NuXAnalysis_t NuXFitAnalysis::fanalysisSetting [private]
 

Definition at line 115 of file NuXFitAnalysis.h.

Referenced by CPTAnalysis(), NuXFitAnalysis(), 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 CPTAnalysis().

Double_t NuXFitAnalysis::fBestDm2Bar [private]
 

Definition at line 123 of file NuXFitAnalysis.h.

Referenced by CPTAnalysis().

Double_t NuXFitAnalysis::fBestSn2 [private]
 

Definition at line 122 of file NuXFitAnalysis.h.

Referenced by CPTAnalysis().

Double_t NuXFitAnalysis::fBestSn2Bar [private]
 

Definition at line 124 of file NuXFitAnalysis.h.

Referenced by CPTAnalysis().

Double_t NuXFitAnalysis::fBestTransitionProb [private]
 

Definition at line 125 of file NuXFitAnalysis.h.

Referenced by 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 DoGridSearch().

Double_t NuXFitAnalysis::ffdDataPoT [private]
 

Definition at line 117 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), FDData(), and FDDataPoT().

Double_t NuXFitAnalysis::ffdMCPoT [private]
 

Definition at line 118 of file NuXFitAnalysis.h.

Referenced by CacheFDMCEvents(), and FDMC().

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(), 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(), OutputFileName(), 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 FDData(), FillFDDataHistograms(), and NuXFitAnalysis().

NuTreeWrapper* NuXFitAnalysis::ftFDMCTree [private]
 

Definition at line 128 of file NuXFitAnalysis.h.

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

Double_t NuXFitAnalysis::fUp [private]
 

Definition at line 116 of file NuXFitAnalysis.h.

Referenced by SetErrorDef().

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 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 Feb 15 11:09:58 2010 for loon by  doxygen 1.3.9.1