MakeSterilePred Class Reference

#include <MakeSterilePred.h>

Inheritance diagram for MakeSterilePred:
NuMMRun

List of all members.

Public Types

enum  whichPred { CC, NC }
enum  whichDet { ND, FD }
enum  ESyst {
  kShwScale, kTrkScale, kNcBack, kAbsShwNC,
  kRelShwNC, kCCBack, kFDClean, kNDClean,
  kFDCosmic, kNumSyst
}

Public Member Functions

 MakeSterilePred ()
virtual ~MakeSterilePred ()
void SetNDMC (TFile *MC_file, TFile *Nue_file, TFile *NuTau_file)
void SetNDData (TFile *Data_file)
void SetNDBaseline (double baseline)
void SetFDMC (TFile *MC_file, TFile *Nue_file, TFile *NuTau_file)
void SetFDData (TFile *Data_file)
void SetFDBaseline (double baseline)
void SetPOT (double POT_)
virtual Double_t ComparePredWithData (const NuMMParameters &pars)
virtual std::vector< TH1D > WriteFDPredHistos (const NuMMParameters &pars) const
TH1D * FDPrediction (const NuMMParameters &pars, whichPred Pred)
TH1D * FDPrediction (NuXMLConfig *xml_config, whichPred Pred)
TH1D * MCOscillated (const NuMMParameters &pars, whichPred Pred, whichDet Det)
TH1D * MCOscillated (NuXMLConfig *xml_config, whichPred Pred, whichDet Det)
TH1D * HistRebin (TH1D *histo, bool whichBin)
std::vector< double > Rebin4Chi2 ()
std::vector< double > Rebin ()
void SetNoNC ()
void SetNoCC ()
void SetSystShifts (TFile *systFile)
TH1D * RebinSystShift (TH1D *&SystHist, TH1D *binTemplate) const

Public Attributes

TH1D * oscAvgOverBinNC
TH1D * oscAvgOverBinNuMu
TGraph * oscIterOverBinNC
TGraph * oscIterOverBinNuMu
TH1D * oscTrueNC
TH1D * oscNuMu
TH1D * oscBeamNue
TH1D * oscAppNue
TH1D * oscAppNuTau
TH1D * fSystPlus [2][kNumSyst]
TH1D * fSystMinus [2][kNumSyst]
TH1D * fhOne
Bool_t fFitSysts
std::map< unsigned int,
NuMMParameters::EParam
fParMap

Private Member Functions

void cleanup ()
NuMMParameters XMLtoParameters (NuXMLConfig *xml_config)
void GetHistos ()
 ClassDef (MakeSterilePred, 1)

Private Attributes

double ND_baseline
double FD_baseline
TFile * ND_MC
TFile * ND_Nue
TFile * ND_NuTau
TFile * ND_data
TFile * FD_MC
TFile * FD_Nue
TFile * FD_NuTau
TFile * FD_data
double POT
bool got_histos
TH1F * ND_MC_POT
TH1F * ND_Nue_POT
TH1F * ND_NuTau_POT
TH1F * ND_data_POT
TH1F * FD_MC_POT
TH1F * FD_Nue_POT
TH1F * FD_NuTau_POT
TH2D * NDNC_TrueNC
TH2D * NDNC_NuMu
TH2D * NDNC_BeamNue
TH2D * NDNC_AppNue
TH2D * NDNC_AppNuTau
TH2D * NDCC_TrueNC
TH2D * NDCC_NuMu
TH2D * NDCC_BeamNue
TH2D * NDCC_AppNue
TH2D * NDCC_AppNuTau
TH2D * FDNC_TrueNC
TH2D * FDNC_NuMu
TH2D * FDNC_BeamNue
TH2D * FDNC_AppNue
TH2D * FDNC_AppNuTau
TH2D * FDCC_TrueNC
TH2D * FDCC_NuMu
TH2D * FDCC_BeamNue
TH2D * FDCC_AppNue
TH2D * FDCC_AppNuTau
TH1D * FD_dataNC
TH1D * FD_dataCC
TH1D * ND_dataNC
TH1D * ND_dataCC
bool fNoNC
bool fNoCC

Detailed Description

Definition at line 16 of file MakeSterilePred.h.


Member Enumeration Documentation

Enumerator:
kShwScale 
kTrkScale 
kNcBack 
kAbsShwNC 
kRelShwNC 
kCCBack 
kFDClean 
kNDClean 
kFDCosmic 
kNumSyst 

Definition at line 22 of file MakeSterilePred.h.

00022             {
00023     kShwScale,  // Energy dependent CC systematics
00024     kTrkScale,
00025     kNcBack,
00026     kAbsShwNC,  // Energy dependent NC systematics
00027     kRelShwNC,
00028     kCCBack,
00029     kFDClean,
00030     kNDClean,
00031     kFDCosmic,
00032     kNumSyst    // Number of energy depended systematics
00033   };

Enumerator:
ND 
FD 

Definition at line 20 of file MakeSterilePred.h.

00020 {ND, FD};

Enumerator:
CC 
NC 

Definition at line 19 of file MakeSterilePred.h.

00019 {CC, NC};


Constructor & Destructor Documentation

MakeSterilePred::MakeSterilePred (  ) 
MakeSterilePred::~MakeSterilePred (  )  [virtual]

Definition at line 65 of file MakeSterilePred.cxx.

References cleanup().

00066 {
00067   cleanup();
00068 }


Member Function Documentation

MakeSterilePred::ClassDef ( MakeSterilePred  ,
 
) [private]
void MakeSterilePred::cleanup (  )  [private]

Definition at line 50 of file MakeSterilePred.cxx.

References oscAppNue, oscAppNuTau, oscAvgOverBinNC, oscAvgOverBinNuMu, oscBeamNue, oscIterOverBinNC, oscIterOverBinNuMu, oscNuMu, and oscTrueNC.

Referenced by MCOscillated(), and ~MakeSterilePred().

00051 {
00052   if(oscAvgOverBinNC)    { delete oscAvgOverBinNC;    oscAvgOverBinNC    = 0; }
00053   if(oscAvgOverBinNuMu)  { delete oscAvgOverBinNuMu;  oscAvgOverBinNuMu  = 0; }
00054   if(oscIterOverBinNC)   { delete oscIterOverBinNC;   oscIterOverBinNC   = 0; }
00055   if(oscIterOverBinNuMu) { delete oscIterOverBinNuMu; oscIterOverBinNuMu = 0; }
00056 
00057   if(oscTrueNC)   { delete oscTrueNC;   oscTrueNC   = 0; }
00058   if(oscNuMu)     { delete oscNuMu;     oscNuMu     = 0; }
00059   if(oscBeamNue)  { delete oscBeamNue;  oscBeamNue  = 0; }
00060   if(oscAppNue)   { delete oscAppNue;   oscAppNue   = 0; }
00061   if(oscAppNuTau) { delete oscAppNuTau; oscAppNuTau = 0; }
00062 }

Double_t MakeSterilePred::ComparePredWithData ( const NuMMParameters pars  )  [virtual]

Implements NuMMRun.

Definition at line 333 of file MakeSterilePred.cxx.

References CC, FD, FD_dataCC, FD_dataNC, fNoCC, fNoNC, GetHistos(), HistRebin(), MCOscillated(), NC, ND, ND_dataCC, ND_dataNC, and NuMMRun::StatsLikelihood().

00334 {
00335   GetHistos();
00336 
00337   TH1D *NDOsc_NC = MCOscillated(pars, NC, ND);
00338   TH1D *FDOsc_NC = MCOscillated(pars, NC, FD);
00339   TH1D *NDOsc_CC = MCOscillated(pars, CC, ND);
00340   TH1D *FDOsc_CC = MCOscillated(pars, CC, FD);
00341 
00342   FDOsc_NC->Multiply(ND_dataNC);
00343   FDOsc_NC->Divide(NDOsc_NC);
00344   FDOsc_CC->Multiply(ND_dataCC);
00345   FDOsc_CC->Divide(NDOsc_CC);
00346 
00347   FDOsc_NC = HistRebin(FDOsc_NC, 0);
00348   FDOsc_CC = HistRebin(FDOsc_CC, 0);
00349 
00350   Double_t likelihood = 0.0;
00351 
00352   if (!fNoNC) likelihood += StatsLikelihood(FDOsc_NC, FD_dataNC);
00353   if (!fNoCC) likelihood += StatsLikelihood(FDOsc_CC, FD_dataCC);
00354 
00355   delete FDOsc_NC;
00356   delete FDOsc_CC;
00357 
00358   Double_t ndMCRate = 0;
00359   if(!fNoNC) ndMCRate += NDOsc_NC->Integral();
00360   if(!fNoCC) ndMCRate += NDOsc_CC->Integral();
00361   Double_t ndDataRate = 0;
00362   if(!fNoNC) ndDataRate += ND_dataNC->Integral();
00363   if(!fNoCC) ndDataRate += ND_dataCC->Integral();
00364 
00365   if (!fNoNC||!fNoCC) likelihood += 2*(ndMCRate - ndDataRate*(1 - log(ndDataRate/ndMCRate)));
00366 
00367   delete NDOsc_NC;
00368   delete NDOsc_CC;
00369 
00370   return likelihood;
00371 }

TH1D * MakeSterilePred::FDPrediction ( NuXMLConfig xml_config,
whichPred  Pred 
)

Definition at line 421 of file MakeSterilePred.cxx.

References FDPrediction(), and XMLtoParameters().

00422 {
00423   NuMMParameters pars = XMLtoParameters(xml_config);
00424   return FDPrediction(pars, Pred);
00425 }

TH1D * MakeSterilePred::FDPrediction ( const NuMMParameters pars,
whichPred  Pred 
)

Definition at line 380 of file MakeSterilePred.cxx.

References CC, FD, GetHistos(), MCOscillated(), NC, ND, ND_dataCC, ND_dataNC, oscAppNue, oscAppNuTau, oscBeamNue, oscNuMu, and oscTrueNC.

Referenced by FDPrediction().

00381 {
00382   GetHistos();
00383   TH1D *ND_dataE = 0;
00384   switch(Pred)
00385     {
00386     case NC:
00387       ND_dataE = ND_dataNC;
00388       break;
00389     case CC:
00390       ND_dataE = ND_dataCC;
00391       break;
00392     default:
00393       cout << "wrong pred type" << endl;
00394       break;
00395     }
00396   TH1D *cloneNDdata = (TH1D*)ND_dataE->Clone("cloneNDdata");
00397         
00398   TH1D *NDOsc_MC = MCOscillated(pars, Pred, ND);
00399   TH1D *FDOsc_MC = MCOscillated(pars, Pred, FD);
00400 
00401   //FDOsc_MC->Divide(NDOsc_MC);
00402   //FDOsc_MC->Multiply(ND_dataE);
00403 
00404   cloneNDdata->Divide(NDOsc_MC);
00405   FDOsc_MC->Multiply(cloneNDdata);
00406 
00407   oscTrueNC->Multiply(cloneNDdata);
00408   oscNuMu->Multiply(cloneNDdata);
00409   oscBeamNue->Multiply(cloneNDdata);
00410   oscAppNue->Multiply(cloneNDdata);
00411   oscAppNuTau->Multiply(cloneNDdata);
00412 
00413   delete NDOsc_MC;
00414   delete cloneNDdata;
00415 
00416   //    cout << "made pred" << endl;
00417   return FDOsc_MC;
00418 }

void MakeSterilePred::GetHistos (  )  [private]

Definition at line 117 of file MakeSterilePred.cxx.

References FD_data, FD_dataCC, FD_dataNC, FD_MC, FD_MC_POT, FD_Nue, FD_Nue_POT, FD_NuTau, FD_NuTau_POT, FDCC_AppNue, FDCC_AppNuTau, FDCC_BeamNue, FDCC_NuMu, FDCC_TrueNC, FDNC_AppNue, FDNC_AppNuTau, FDNC_BeamNue, FDNC_NuMu, FDNC_TrueNC, got_histos, HistRebin(), ND_data, ND_data_POT, ND_dataCC, ND_dataNC, ND_MC, ND_MC_POT, ND_Nue, ND_Nue_POT, ND_NuTau, ND_NuTau_POT, NDCC_AppNue, NDCC_AppNuTau, NDCC_BeamNue, NDCC_NuMu, NDCC_TrueNC, NDNC_AppNue, NDNC_AppNuTau, NDNC_BeamNue, NDNC_NuMu, and NDNC_TrueNC.

Referenced by ComparePredWithData(), FDPrediction(), and MCOscillated().

00118 {
00119   if(got_histos) return;
00120 
00121   // GetObjects
00122   assert(FD_data);
00123   assert(ND_data);
00124   assert(ND_MC);
00125   assert(ND_Nue);
00126   assert(ND_NuTau);
00127   assert(FD_MC);
00128   assert(FD_Nue);
00129   assert(FD_NuTau);
00130 
00131   FD_data->GetObject("hRecoEnergyNC",    FD_dataNC); assert(FD_dataNC);
00132   FD_dataNC->SetName("hRecoEnergyNC_FD");
00133   FD_data->GetObject("hRecoEnergyCCAll", FD_dataCC); assert(FD_dataCC);
00134   FD_dataCC->SetName("hRecoEnergyCCAll_FD");
00135 
00136   ND_data->GetObject("hRecoEnergyNC",    ND_dataNC); assert(ND_dataNC);
00137   ND_dataNC->SetName("hRecoEnergyNC_ND");
00138   ND_data->GetObject("hRecoEnergyCCAll", ND_dataCC); assert(ND_dataCC);
00139   ND_dataCC->SetName("hRecoEnergyCCAll_ND");
00140 
00141   ND_MC->GetObject("hRecoToTrueNCSelectedTrueNC",      NDNC_TrueNC);   assert(NDNC_TrueNC);
00142   ND_MC->GetObject("hRecoToTrueNCSelectedTrueCCNuMu",  NDNC_NuMu);     assert(NDNC_NuMu);
00143   ND_MC->GetObject("hRecoToTrueNCSelectedBeamNue",     NDNC_BeamNue);  assert(NDNC_BeamNue);
00144   ND_Nue->GetObject("hRecoToTrueNCSelectedAppearNue",   NDNC_AppNue);   assert(NDNC_AppNue);
00145   ND_NuTau->GetObject("hRecoToTrueNCSelectedAppearNuTau", NDNC_AppNuTau); assert(NDNC_AppNuTau);
00146 
00147   ND_MC->GetObject("hRecoToTrueCCSelectedTrueNC",      NDCC_TrueNC);   assert(NDCC_TrueNC);
00148   ND_MC->GetObject("hRecoToTrueCCSelectedTrueCCNuMu",  NDCC_NuMu);     assert(NDCC_NuMu);
00149   ND_MC->GetObject("hRecoToTrueCCSelectedBeamNue",     NDCC_BeamNue);  assert(NDCC_BeamNue);
00150   ND_Nue->GetObject("hRecoToTrueCCSelectedAppearNue",   NDCC_AppNue);   assert(NDCC_AppNue);
00151   ND_NuTau->GetObject("hRecoToTrueCCSelectedAppearNuTau", NDCC_AppNuTau); assert(NDCC_AppNuTau);
00152 
00153   FD_MC->GetObject("hRecoToTrueNCSelectedTrueNC",      FDNC_TrueNC);   assert(FDNC_TrueNC);
00154   FD_MC->GetObject("hRecoToTrueNCSelectedTrueCCNuMu",  FDNC_NuMu);     assert(FDNC_NuMu);
00155   FD_MC->GetObject("hRecoToTrueNCSelectedBeamNue",     FDNC_BeamNue);  assert(FDNC_BeamNue);
00156   FD_Nue->GetObject("hRecoToTrueNCSelectedAppearNue",   FDNC_AppNue);   assert(FDNC_AppNue);
00157   FD_NuTau->GetObject("hRecoToTrueNCSelectedAppearNuTau", FDNC_AppNuTau); assert(FDNC_AppNuTau);
00158 
00159   FD_MC->GetObject("hRecoToTrueCCSelectedTrueNC",      FDCC_TrueNC);   assert(FDCC_TrueNC);
00160   FD_MC->GetObject("hRecoToTrueCCSelectedTrueCCNuMu",  FDCC_NuMu);     assert(FDCC_NuMu);
00161   FD_MC->GetObject("hRecoToTrueCCSelectedBeamNue",     FDCC_BeamNue);  assert(FDCC_BeamNue);
00162   FD_Nue->GetObject("hRecoToTrueCCSelectedAppearNue",   FDCC_AppNue);   assert(FDCC_AppNue);
00163   FD_NuTau->GetObject("hRecoToTrueCCSelectedAppearNuTau", FDCC_AppNuTau); assert(FDCC_AppNuTau);
00164 
00165   ND_data->GetObject("hTotalPot", ND_data_POT);  assert(ND_data_POT);
00166   ND_MC->GetObject("hTotalPot", ND_MC_POT);    assert(ND_MC_POT);
00167   ND_Nue->GetObject("hTotalPot", ND_Nue_POT);   assert(ND_Nue_POT);
00168   ND_NuTau->GetObject("hTotalPot", ND_NuTau_POT); assert(ND_NuTau_POT);
00169   FD_MC->GetObject("hTotalPot", FD_MC_POT);    assert(FD_MC_POT);
00170   FD_Nue->GetObject("hTotalPot", FD_Nue_POT);   assert(FD_Nue_POT);
00171   FD_NuTau->GetObject("hTotalPot", FD_NuTau_POT); assert(FD_NuTau_POT);
00172 
00173   // POT normalize
00174   double dataPOT = ND_data_POT->Integral();
00175   ND_dataNC->Scale(POT/dataPOT);
00176   ND_dataCC->Scale(POT/dataPOT);
00177         
00178   double ndmcPOT = ND_MC_POT->Integral();
00179   NDNC_TrueNC->Scale(POT/ndmcPOT);
00180   NDNC_NuMu->Scale(POT/ndmcPOT);
00181   NDNC_BeamNue->Scale(POT/ndmcPOT);
00182   NDCC_TrueNC->Scale(POT/ndmcPOT);
00183   NDCC_NuMu->Scale(POT/ndmcPOT);
00184   NDCC_BeamNue->Scale(POT/ndmcPOT);
00185 
00186   double ndnuePOT = ND_Nue_POT->Integral();
00187   NDNC_AppNue->Scale(POT/ndnuePOT);
00188   NDCC_AppNue->Scale(POT/ndnuePOT);
00189 
00190   double ndnutauPOT = ND_NuTau_POT->Integral();
00191   NDNC_AppNuTau->Scale(POT/ndnutauPOT);
00192   NDCC_AppNuTau->Scale(POT/ndnutauPOT);
00193 
00194   double fdmcPOT = FD_MC_POT->Integral();
00195   FDNC_TrueNC->Scale(POT/fdmcPOT);
00196   FDNC_NuMu->Scale(POT/fdmcPOT);
00197   FDNC_BeamNue->Scale(POT/fdmcPOT);
00198   FDCC_TrueNC->Scale(POT/fdmcPOT);
00199   FDCC_NuMu->Scale(POT/fdmcPOT);
00200   FDCC_BeamNue->Scale(POT/fdmcPOT);
00201 
00202   double fdnuePOT = FD_Nue_POT->Integral();
00203   FDNC_AppNue->Scale(POT/fdnuePOT);
00204   FDCC_AppNue->Scale(POT/fdnuePOT);
00205 
00206   double fdnutauPOT = FD_NuTau_POT->Integral();
00207   FDNC_AppNuTau->Scale(POT/fdnutauPOT);
00208   FDCC_AppNuTau->Scale(POT/fdnutauPOT);
00209 
00210   FD_dataNC = HistRebin(FD_dataNC, 0);
00211   FD_dataCC = HistRebin(FD_dataCC, 0);
00212   ND_dataNC = HistRebin(ND_dataNC, 1);
00213   ND_dataCC = HistRebin(ND_dataCC, 1);
00214 
00215   got_histos = true;
00216 
00217   //    cout << "got all histos" << endl;
00218 }

TH1D * MakeSterilePred::HistRebin ( TH1D *  histo,
bool  whichBin 
)

Definition at line 313 of file MakeSterilePred.cxx.

References Rebin(), and Rebin4Chi2().

Referenced by ComparePredWithData(), GetHistos(), and MCOscillated().

00314 {
00315   vector<double> binning;
00316   if(whichRebin)
00317     binning = Rebin();
00318   else
00319     binning = Rebin4Chi2();
00320 
00321 //  TH1D *oscMC = new TH1D(Form("%s_rebin",histo->GetName()), "; E_{reco} GeV; Events", binning.size()-1, binning.data());
00322   TH1D *oscMC = new TH1D("", "; E_{reco} GeV; Events", binning.size()-1, binning.data());
00323   for(int i = 1; i <= histo->GetXaxis()->GetNbins(); i++)
00324     {
00325       oscMC->Fill(histo->GetXaxis()->GetBinCenter(i), histo->GetBinContent(i));
00326     }
00327   delete histo;
00328   //    cout << "rebinned" << endl;
00329   return oscMC;
00330 }

TH1D * MakeSterilePred::MCOscillated ( NuXMLConfig xml_config,
whichPred  Pred,
whichDet  Det 
)

Definition at line 691 of file MakeSterilePred.cxx.

References MCOscillated(), and XMLtoParameters().

00692 {
00693   NuMMParameters pars = XMLtoParameters(xml_config);
00694   return MCOscillated(pars, Pred, Det);
00695 }

TH1D * MakeSterilePred::MCOscillated ( const NuMMParameters pars,
whichPred  Pred,
whichDet  Det 
)

Definition at line 428 of file MakeSterilePred.cxx.

References CC, cleanup(), NuMMParameters::Delta1(), NuMMParameters::Delta2(), NuMMParameters::Delta3(), NuMMParameters::Dm2(), NuMMParameters::Dm221(), NuMMParameters::Dm243(), FD, FD_baseline, FDCC_AppNue, FDCC_AppNuTau, FDCC_BeamNue, FDCC_NuMu, FDCC_TrueNC, FDNC_AppNue, FDNC_AppNuTau, FDNC_BeamNue, FDNC_NuMu, FDNC_TrueNC, fFitSysts, NuOscProb::FourFlavourDisappearanceWeight(), NuOscProb::FourFlavourNuESurvivalProbability(), NuOscProb::FourFlavourNuMuToNuEProbability(), NuOscProb::FourFlavourNuMuToNuSProbability(), NuOscProb::FourFlavourNuMuToNuTauProbability(), fParMap, fSystMinus, fSystPlus, GetHistos(), NuMMParameters::GetParameterByIndex(), HistRebin(), k1267, NuMMParameters::kAbsNorm, kAbsShwNC, kCCBack, Munits::km, kNcBack, kNDClean, NuMMParameters::kNorm, NuMMParameters::kNormNC, kNumSyst, kShwScale, kTrkScale, NC, ND, ND_baseline, NDCC_AppNue, NDCC_AppNuTau, NDCC_BeamNue, NDCC_NuMu, NDCC_TrueNC, NDNC_AppNue, NDNC_AppNuTau, NDNC_BeamNue, NDNC_NuMu, NDNC_TrueNC, oscAppNue, oscAppNuTau, oscAvgOverBinNC, oscAvgOverBinNuMu, oscBeamNue, oscIterOverBinNC, oscIterOverBinNuMu, oscNuMu, oscTrueNC, NuMMParameters::Theta12(), NuMMParameters::Theta13(), NuMMParameters::Theta14(), NuMMParameters::Theta23(), NuMMParameters::Theta24(), and NuMMParameters::Theta34().

Referenced by ComparePredWithData(), FDPrediction(), and MCOscillated().

00429 {
00430 
00431   GetHistos();
00432   cleanup();
00433 
00434   double baseline = 0;
00435   TString detName;
00436   switch (Det)
00437     {
00438     case ND:
00439       detName = "ND";
00440       break;
00441     case FD:
00442       detName = "FD";
00443       break;
00444     default:
00445       cout << "what detector???" << endl;
00446       break;
00447     }
00448 
00449   TString predName;
00450   switch (Pred)
00451     {
00452     case NC:
00453       predName = "NC";
00454       break;
00455     case CC:
00456       predName = "CC";
00457       break;
00458     default:
00459       cout << "what prediction???" << endl;
00460       break;
00461     }
00462 
00463   TH2D *TrueNC = 0;
00464   TH2D *NuMu = 0;
00465   TH2D *BeamNue = 0;
00466   TH2D *AppNue = 0;
00467   TH2D *AppNuTau = 0;
00468   switch(Det*1000+Pred)
00469     {
00470     case ND*1000+NC:
00471       TrueNC   = NDNC_TrueNC;
00472       NuMu     = NDNC_NuMu;
00473       BeamNue  = NDNC_BeamNue;
00474       AppNue   = NDNC_AppNue;
00475       AppNuTau = NDNC_AppNuTau;
00476       baseline = ND_baseline;
00477       break;
00478     case ND*1000+CC:
00479       TrueNC   = NDCC_TrueNC;
00480       NuMu     = NDCC_NuMu;
00481       BeamNue  = NDCC_BeamNue;
00482       AppNue   = NDCC_AppNue;
00483       AppNuTau = NDCC_AppNuTau;
00484       baseline = ND_baseline;
00485       break;
00486     case FD*1000+NC:
00487       TrueNC   = FDNC_TrueNC;
00488       NuMu     = FDNC_NuMu;
00489       BeamNue  = FDNC_BeamNue;
00490       AppNue   = FDNC_AppNue;
00491       AppNuTau = FDNC_AppNuTau;
00492       baseline = FD_baseline;
00493       break;
00494     case FD*1000+CC:
00495       TrueNC   = FDCC_TrueNC;
00496       NuMu     = FDCC_NuMu;
00497       BeamNue  = FDCC_BeamNue;
00498       AppNue   = FDCC_AppNue;
00499       AppNuTau = FDCC_AppNuTau;
00500       baseline = FD_baseline;
00501       break;
00502     default:
00503       cout << "what detector and what pred type???" << endl;
00504       break;
00505     }           
00506 
00507   // clone the TrueNC projection plot so the new oscillated spectra have the same binning
00508   TH1D *binTemplate = TrueNC->ProjectionY();
00509   binTemplate->Reset();
00510   oscTrueNC   = (TH1D*) binTemplate->Clone("oscTrueNC");
00511   oscNuMu     = (TH1D*) binTemplate->Clone("oscNuMu");
00512   oscBeamNue  = (TH1D*) binTemplate->Clone("oscBeamNue");
00513   oscAppNue   = (TH1D*) binTemplate->Clone("oscAppNue");
00514   oscAppNuTau = (TH1D*) binTemplate->Clone("oscAppNuTau");
00515 
00516   oscAvgOverBinNC    = (TH1D*) binTemplate->Clone("oscAvgOverBinNC");
00517   oscAvgOverBinNuMu  = (TH1D*) binTemplate->Clone("oscAvgOverBinNuMu");
00518   oscIterOverBinNC   = new TGraph();
00519   oscIterOverBinNuMu = new TGraph();
00520 
00521   const double k1267 = 1.26693276;
00522 
00523   // loop over every true energy bin in the reco vs. true matrices, then loop over every reco energy in that bin
00524   // to calculate an oscillation weight for that reco energy based on the true energy. Get the 4 flavor oscillations
00525   // from OscProb/NuOscProbCalc. Fill a new histogram for each of the 5 types of events with the now oscillated 
00526   // reco energy. 
00527   TAxis *Yaxis = TrueNC->GetYaxis();
00528   TAxis *Xaxis = TrueNC->GetXaxis();
00529 for(int x = 1; x <= Xaxis->GetNbins(); x++)
00530         {
00531                 double oscWeightNC       = 0.0;
00532                 double oscWeightNuMu     = 0.0;
00533                 double oscWeightBeamNue  = 0.0;
00534                 double oscWeightAppNue   = 0.0;
00535                 double oscWeightAppNuTau = 0.0;
00536                 if(baseline > 0)
00537                 {               
00538                         // default iterations (1 at bin center)
00539                         int n_LoverE = 1;
00540                         double LoverE[5];
00541                         LoverE[0] = Xaxis->GetBinCenter(x);
00542 
00543                         // should we average?
00544 //                      const double T = TMath::Pi()/k1267/pars.Dm243(); // half-period of oscillation
00545                         const double W = Xaxis->GetBinWidth(x);
00546                         const double arg = k1267*pars.Dm243()*W; // half-period of oscillation
00547                         double sample = W/2/sqrt(3);
00548                         if(arg!=0) sample = TMath::ACos(TMath::Sin(arg)/arg)/arg*W/2;
00549 //                      if(T <= W)
00550 //                      {
00551                                 n_LoverE = 2;
00552                                 double bc = LoverE[0]; // bin center
00553 //                              LoverE[0] = bc - T/4.0;
00554 //                              LoverE[1] = bc + T/4.0;
00555                                 LoverE[0] = bc - sample;
00556                                 LoverE[1] = bc + sample;
00557 //                      }
00558 
00559                         const double E = 1.0; 
00560 
00561                         for(int i = 0; i < n_LoverE; i++)
00562                         {
00563                                 oscWeightNC       += NuOscProbCalc::FourFlavourNuMuToNuSProbability(E,              pars.Dm2(),     pars.Theta23(), pars.Dm221(),   
00564                                                                                                                                                                 pars.Dm243(),   pars.Theta12(), pars.Theta13(), pars.Theta14(), 
00565                                                                                                                                                                 pars.Theta24(), pars.Theta34(), pars.Delta1(),  pars.Delta2(),
00566                                                                                                                                                                 pars.Delta3(),  LoverE[i]*Munits::km);
00567 
00568                                 oscWeightNuMu      += NuOscProbCalc::FourFlavourDisappearanceWeight(E,              pars.Dm2(),     pars.Theta23(), pars.Dm221(),   
00569                                                                                                                                                            pars.Dm243(),   pars.Theta12(), pars.Theta13(), pars.Theta14(), 
00570                                                                                                                                                            pars.Theta24(), pars.Theta34(), pars.Delta1(),  pars.Delta2(),
00571                                                                                                                                                            pars.Delta3(),  LoverE[i]*Munits::km);
00572 
00573                                 oscWeightBeamNue  += NuOscProbCalc::FourFlavourNuESurvivalProbability(E,              pars.Dm2(),     pars.Theta23(), pars.Dm221(),   
00574                                                                                                                                                                   pars.Dm243(),   pars.Theta12(), pars.Theta13(), pars.Theta14(), 
00575                                                                                                                                                                   pars.Theta24(), pars.Theta34(), pars.Delta1(),  pars.Delta2(),
00576                                                                                                                                                                   pars.Delta3(),  LoverE[i]*Munits::km);
00577                                 
00578                                 oscWeightAppNue   += NuOscProbCalc::FourFlavourNuMuToNuEProbability(E,              pars.Dm2(),     pars.Theta23(), pars.Dm221(),   
00579                                                                                                                                                                 pars.Dm243(),   pars.Theta12(), pars.Theta13(), pars.Theta14(), 
00580                                                                                                                                                                 pars.Theta24(), pars.Theta34(), pars.Delta1(),  pars.Delta2(),
00581                                                                                                                                                                 pars.Delta3(),  LoverE[i]*Munits::km);
00582 
00583                                 oscWeightAppNuTau += NuOscProbCalc::FourFlavourNuMuToNuTauProbability(E,              pars.Dm2(),     pars.Theta23(), pars.Dm221(),   
00584                                                                                                                                                                   pars.Dm243(),   pars.Theta12(), pars.Theta13(), pars.Theta14(), 
00585                                                                                                                                                                   pars.Theta24(), pars.Theta34(), pars.Delta1(),  pars.Delta2(),
00586                                                                                                                                                                   pars.Delta3(),  LoverE[i]*Munits::km);
00587                         }
00588 
00589                         oscWeightNC       /= n_LoverE;
00590                         oscWeightNuMu     /= n_LoverE;
00591                         oscWeightBeamNue  /= n_LoverE;
00592                         oscWeightAppNue   /= n_LoverE;
00593                         oscWeightAppNuTau /= n_LoverE;
00594         
00595 //                      oscIterOverBinNC->SetPoint(x-1, LoverE[0], oscWeightNC);
00596 //                      oscIterOverBinNuMu->SetPoint(x-1, LoverE[0], oscWeightNuMu);
00597                 }
00598                 else
00599                 {
00600                         oscWeightNC       = 0.0;
00601                         oscWeightNuMu     = 1.0;
00602                         oscWeightBeamNue  = 1.0;
00603                         oscWeightAppNue   = 0.0;
00604                         oscWeightAppNuTau = 0.0;
00605                 }
00606 
00607                 oscAvgOverBinNC->SetBinContent(x, oscWeightNC);
00608                 oscAvgOverBinNuMu->SetBinContent(x, oscWeightNuMu);
00609                                                 
00610                 // using the oscillation weight, fill a 1d histogram for each type of event with the oscillated reco energy
00611                 for(int y = 1; y <= Yaxis->GetNbins(); y++)
00612                 {
00613                         oscTrueNC->AddBinContent(  y,   TrueNC->GetBinContent(x,y)*(1.0-oscWeightNC));
00614                         oscNuMu->AddBinContent(    y,     NuMu->GetBinContent(x,y)*oscWeightNuMu);
00615                         oscBeamNue->AddBinContent( y,  BeamNue->GetBinContent(x,y)*oscWeightBeamNue);
00616                         oscAppNue->AddBinContent(  y,   AppNue->GetBinContent(x,y)*oscWeightAppNue);
00617                         oscAppNuTau->AddBinContent(y, AppNuTau->GetBinContent(x,y)*oscWeightAppNuTau);
00618                 }
00619         } 
00620 
00621   TString oscSumName = "oscSum_";
00622   oscSumName += detName;
00623   oscSumName += predName;
00624 
00625   TH1D *oscSum = (TH1D*)oscTrueNC->Clone(oscSumName);
00626   oscSum->Add(oscNuMu);
00627   oscSum->Add(oscBeamNue);
00628   oscSum->Add(oscAppNue);
00629   oscSum->Add(oscAppNuTau);
00630 
00631   oscSum = HistRebin(oscSum, 1);
00632   oscTrueNC = HistRebin(oscTrueNC, 1);
00633   oscNuMu = HistRebin(oscNuMu, 1);
00634   oscBeamNue = HistRebin(oscBeamNue, 1);
00635   oscAppNue = HistRebin(oscAppNue, 1);
00636   oscAppNuTau = HistRebin(oscAppNuTau, 1);
00637 
00638   if( fFitSysts ){
00639     // Apply normalization systematics
00640     if(Det==FD){
00641       if(Pred==NC) oscSum->Scale(pars.GetParameterByIndex(NuMMParameters::kNormNC));
00642       else if(Pred==CC) oscSum->Scale(pars.GetParameterByIndex(NuMMParameters::kNorm));
00643     }
00644     oscSum->Scale(1+0.2*pars.GetParameterByIndex(NuMMParameters::kAbsNorm));
00645 
00646     // Apply energy dependent systematics
00647     for(int kPar=0; kPar<kNumSyst; kPar++){
00648       // Only apply shifts to spectra that do change
00649       if(kPar==kShwScale || kPar==kTrkScale || kPar==kNcBack){ if(Pred==NC) continue; }
00650       else{
00651         if(Pred==CC) continue;
00652         else{
00653           if(kPar!=kAbsShwNC && kPar!=kCCBack && kPar!=kNDClean && Det==ND) continue;
00654           if(kPar==kNDClean && Det==FD) continue;
00655         }
00656       }
00657       // Get the shift value in sigmas
00658       double parvalue = pars.GetParameterByIndex(fParMap.at(kPar));
00659       if(kPar==kNcBack) parvalue = (parvalue-1.0)/0.2;
00660 
00661       // Skip parameters that do nothing
00662       if(parvalue==0) continue;
00663 
00664       // Get the shift histogram by sign
00665       TH1D *ScaledSyst;
00666       if(parvalue<0)
00667         ScaledSyst = (TH1D*)fSystMinus[Det][kPar]->Clone();
00668       else
00669         ScaledSyst = (TH1D*)fSystPlus[Det][kPar]->Clone();
00670                 
00671       ScaledSyst->Scale(TMath::Abs(parvalue)); // Scale to shift value
00672       //            ScaledSyst->Add(fhOne);                  // Subtract one
00673 
00674       // Add one to systematic shifts
00675       for(int i=0; i<=ScaledSyst->GetNbinsX()+1; i++){
00676         ScaledSyst->SetBinContent(i,1+ScaledSyst->GetBinContent(i));
00677       }
00678       ScaledSyst = HistRebin(ScaledSyst, 1);
00679       oscSum->Multiply(ScaledSyst);         // Apply systematic
00680 
00681       delete ScaledSyst;
00682 
00683     }// Loop over systematics
00684 
00685   }// Apply systematics if present
00686 
00687   return oscSum;
00688 }

vector< double > MakeSterilePred::Rebin (  ) 

Definition at line 221 of file MakeSterilePred.cxx.

Referenced by HistRebin().

00222 {
00223   vector<double> bins;
00224   //    bins.push_back(0.0);
00225   double low = 0.0;
00226   double high = 1.0;
00227   double width = 1.0;
00228   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00229     {
00230       bins.push_back(binedge);
00231     }
00232   low = 1.0;
00233   high = 5.0;
00234   width = 0.05;
00235   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00236     {
00237       bins.push_back(binedge);
00238     }
00239   low = 5.0;
00240   high = 20.0;
00241   width = 0.25;
00242   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00243     {
00244       bins.push_back(binedge);
00245     }
00246   low = 20.0;
00247   high = 30.0;
00248   width = 1.0;
00249   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00250     {
00251       bins.push_back(binedge);
00252     }
00253   low = 30.0;
00254   high = 50.0;
00255   width = 2.0;
00256   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00257     {
00258       bins.push_back(binedge);
00259     }
00260   bins.push_back(50.0);
00261   bins.push_back(200.0);
00262 
00263   //    cout << "binning" << endl;
00264   return bins;
00265 }

vector< double > MakeSterilePred::Rebin4Chi2 (  ) 

Definition at line 267 of file MakeSterilePred.cxx.

Referenced by HistRebin().

00268 {
00269   vector<double> bins;
00270   //    bins.push_back(0.0);
00271   double low = 0.0;
00272   double high = 1.0;
00273   double width = 1.0;
00274   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00275     {
00276       bins.push_back(binedge);
00277     }
00278   low = 1.0;
00279   high = 5.0;
00280   width = 0.1;
00281   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00282     {
00283       bins.push_back(binedge);
00284     }
00285   low = 5.0;
00286   high = 20.0;
00287   width = 0.25;
00288   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00289     {
00290       bins.push_back(binedge);
00291     }
00292   low = 20.0;
00293   high = 30.0;
00294   width = 1.0;
00295   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00296     {
00297       bins.push_back(binedge);
00298     }
00299   low = 30.0;
00300   high = 50.0;
00301   width = 2.0;
00302   for(double binedge = low; binedge < high - (width/2.0); binedge += width)
00303     {
00304       bins.push_back(binedge);
00305     }
00306   bins.push_back(50.0);
00307   bins.push_back(200.0);
00308 
00309   //    cout << "binning" << endl;
00310   return bins;
00311 }

TH1D * MakeSterilePred::RebinSystShift ( TH1D *&  SystHist,
TH1D *  binTemplate 
) const

Definition at line 764 of file MakeSterilePred.cxx.

00765 {
00766 
00767   TH1D *outhist = (TH1D*)binTemplate->Clone();
00768 
00769   for(int i=0;i<=outhist->GetNbinsX()+1;i++){
00770     double xval = outhist->GetBinCenter(i);
00771     double yval = SystHist->Interpolate(xval);
00772     outhist->SetBinContent(i,yval);
00773     outhist->SetBinError(i,0);
00774   }
00775 
00776   //  cout << "integral outhist: " << outhist->Integral() << "; integral systhist: " << SystHist->Integral() << endl;
00777   return outhist;
00778 
00779 }  

void MakeSterilePred::SetFDBaseline ( double  baseline  ) 

Definition at line 105 of file MakeSterilePred.cxx.

References FD_baseline.

00106 {
00107   FD_baseline = baseline;
00108 }

void MakeSterilePred::SetFDData ( TFile *  Data_file  ) 

Definition at line 99 of file MakeSterilePred.cxx.

References FD_data.

00100 {
00101   FD_data = Data_file;
00102 }

void MakeSterilePred::SetFDMC ( TFile *  MC_file,
TFile *  Nue_file,
TFile *  NuTau_file 
)

Definition at line 91 of file MakeSterilePred.cxx.

References FD_MC, FD_Nue, and FD_NuTau.

00092 {
00093   FD_MC    = MC_file;
00094   FD_Nue   = Nue_file;
00095   FD_NuTau = NuTau_file;
00096 }

void MakeSterilePred::SetNDBaseline ( double  baseline  ) 

Definition at line 85 of file MakeSterilePred.cxx.

References ND_baseline.

00086 {
00087   ND_baseline = baseline;
00088 }

void MakeSterilePred::SetNDData ( TFile *  Data_file  ) 

Definition at line 79 of file MakeSterilePred.cxx.

References ND_data.

00080 {
00081   ND_data = Data_file;
00082 }

void MakeSterilePred::SetNDMC ( TFile *  MC_file,
TFile *  Nue_file,
TFile *  NuTau_file 
)

Definition at line 71 of file MakeSterilePred.cxx.

References ND_MC, ND_Nue, and ND_NuTau.

00072 {
00073   ND_MC    = MC_file;
00074   ND_Nue   = Nue_file;
00075   ND_NuTau = NuTau_file;
00076 }

void MakeSterilePred::SetNoCC (  )  [inline]

Definition at line 65 of file MakeSterilePred.h.

References fNoCC.

00065 {fNoCC = true;}

void MakeSterilePred::SetNoNC (  )  [inline]

Definition at line 64 of file MakeSterilePred.h.

References fNoNC.

00064 {fNoNC = true;}

void MakeSterilePred::SetPOT ( double  POT_  ) 

Definition at line 111 of file MakeSterilePred.cxx.

00112 {
00113   POT = POT_;
00114 }

void MakeSterilePred::SetSystShifts ( TFile *  systFile  ) 

Definition at line 717 of file MakeSterilePred.cxx.

References fFitSysts, fSystMinus, fSystPlus, kAbsShwNC, kCCBack, kFDClean, kFDCosmic, kNcBack, kNDClean, kNumSyst, kRelShwNC, kShwScale, and kTrkScale.

00718 {
00719 
00720   string Pred[2] = {"CC","NC"};
00721   string Det[2] = {"ND","FD"};
00722   string SystName[kNumSyst];
00723   SystName[kShwScale] = "absHadCC";
00724   SystName[kTrkScale] = "absLep";
00725   SystName[kNcBack] = "ncBkg";
00726   SystName[kAbsShwNC] = "absHad";
00727   SystName[kRelShwNC] = "relativeHadronic";
00728   SystName[kCCBack] = "ccBkg";
00729   SystName[kFDClean] = "fdCleaning";
00730   SystName[kNDClean] = "ndCleaning";
00731   SystName[kFDCosmic] = "fdCosmics";
00732 
00733   /*    assert(FD_data);
00734         TH1D *binTemplate;
00735         FD_data->GetObject("hRecoEnergyNC",binTemplate);
00736   */
00737   assert(systFile);
00738 
00739   for(int kDet=0; kDet<2; kDet++){
00740     for(int kPar=0; kPar<kNumSyst; kPar++){
00741 
00742       int kPred = 1;
00743       if(kPar==kShwScale || kPar==kTrkScale || kPar==kNcBack) kPred=0;
00744 
00745       systFile->GetObject((Det[kDet]+Pred[kPred]+SystName[kPar]+"Plus").c_str(),fSystPlus[kDet][kPar]);
00746       systFile->GetObject((Det[kDet]+Pred[kPred]+SystName[kPar]+"Minus").c_str(),fSystMinus[kDet][kPar]);
00747 
00748       //      fSystPlus[kDet][kPar] = RebinSystShift(fSystPlus[kDet][kPar],binTemplate);
00749       //      fSystMinus[kDet][kPar] = RebinSystShift(fSystMinus[kDet][kPar],binTemplate);
00750 
00751     }}
00752 
00753   /*    fhOne = (TH1D*)binTemplate->Clone();
00754         for(int i=0; i<=fhOne->GetNbinsX()+1; i++){
00755         fhOne->SetBinContent(i,1);
00756         fhOne->SetBinError(i,0);
00757         }
00758   */
00759   fFitSysts = true;
00760 
00761 }

std::vector< TH1D > MakeSterilePred::WriteFDPredHistos ( const NuMMParameters pars  )  const [virtual]

Implements NuMMRun.

Definition at line 374 of file MakeSterilePred.cxx.

00375 {
00376   return vector<TH1D>();
00377 }

NuMMParameters MakeSterilePred::XMLtoParameters ( NuXMLConfig xml_config  )  [private]

Definition at line 698 of file MakeSterilePred.cxx.

References NuMMParameters::Delta1(), NuXMLConfig::Delta1(), NuMMParameters::Delta2(), NuXMLConfig::Delta2(), NuMMParameters::Dm2(), NuMMParameters::Dm221(), NuXMLConfig::DM221(), NuMMParameters::Dm243(), NuXMLConfig::DM243(), NuXMLConfig::DM2Nu(), NuXMLConfig::Theta12(), NuMMParameters::Theta12(), NuXMLConfig::Theta13(), NuMMParameters::Theta13(), NuXMLConfig::Theta14(), NuMMParameters::Theta14(), NuMMParameters::Theta23(), NuXMLConfig::Theta23(), NuMMParameters::Theta24(), NuXMLConfig::Theta24(), NuXMLConfig::Theta34(), and NuMMParameters::Theta34().

Referenced by FDPrediction(), and MCOscillated().

00699 {
00700   NuMMParameters pars;
00701   // set pars to xml_config
00702   pars.Dm2(     xml_config->DM2Nu());
00703   pars.Theta23( xml_config->Theta23());
00704   pars.Dm221(   xml_config->DM221());
00705   pars.Dm243(   xml_config->DM243());
00706   pars.Delta1(  xml_config->Delta1());
00707   pars.Delta2(  xml_config->Delta2());
00708   pars.Theta12( xml_config->Theta12());
00709   pars.Theta13( xml_config->Theta13());
00710   pars.Theta14( xml_config->Theta14());
00711   pars.Theta24( xml_config->Theta24());
00712   pars.Theta34( xml_config->Theta34());
00713   return pars;
00714 }


Member Data Documentation

double MakeSterilePred::FD_baseline [private]

Definition at line 100 of file MakeSterilePred.h.

Referenced by MCOscillated(), and SetFDBaseline().

TFile * MakeSterilePred::FD_data [private]

Definition at line 103 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetFDData().

TH1D * MakeSterilePred::FD_dataCC [private]

Definition at line 119 of file MakeSterilePred.h.

Referenced by ComparePredWithData(), and GetHistos().

TH1D* MakeSterilePred::FD_dataNC [private]

Definition at line 119 of file MakeSterilePred.h.

Referenced by ComparePredWithData(), and GetHistos().

TFile* MakeSterilePred::FD_MC [private]

Definition at line 103 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetFDMC().

TH1F* MakeSterilePred::FD_MC_POT [private]

Definition at line 111 of file MakeSterilePred.h.

Referenced by GetHistos().

TFile * MakeSterilePred::FD_Nue [private]

Definition at line 103 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetFDMC().

TH1F * MakeSterilePred::FD_Nue_POT [private]

Definition at line 111 of file MakeSterilePred.h.

Referenced by GetHistos().

TFile * MakeSterilePred::FD_NuTau [private]

Definition at line 103 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetFDMC().

Definition at line 111 of file MakeSterilePred.h.

Referenced by GetHistos().

TH2D * MakeSterilePred::FDCC_AppNue [private]

Definition at line 117 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 117 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 117 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

TH2D * MakeSterilePred::FDCC_NuMu [private]

Definition at line 117 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 117 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

TH2D * MakeSterilePred::FDNC_AppNue [private]

Definition at line 116 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 116 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 116 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

TH2D * MakeSterilePred::FDNC_NuMu [private]

Definition at line 116 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 116 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 90 of file MakeSterilePred.h.

Referenced by MCOscillated(), and SetSystShifts().

Definition at line 87 of file MakeSterilePred.h.

bool MakeSterilePred::fNoCC [private]

Definition at line 121 of file MakeSterilePred.h.

Referenced by ComparePredWithData(), and SetNoCC().

bool MakeSterilePred::fNoNC [private]

Definition at line 121 of file MakeSterilePred.h.

Referenced by ComparePredWithData(), and SetNoNC().

Definition at line 93 of file MakeSterilePred.h.

Referenced by MCOscillated().

TH1D* MakeSterilePred::fSystMinus[2][kNumSyst]

Definition at line 86 of file MakeSterilePred.h.

Referenced by MCOscillated(), and SetSystShifts().

TH1D* MakeSterilePred::fSystPlus[2][kNumSyst]

Definition at line 85 of file MakeSterilePred.h.

Referenced by MCOscillated(), and SetSystShifts().

Definition at line 108 of file MakeSterilePred.h.

Referenced by GetHistos().

double MakeSterilePred::ND_baseline [private]

Definition at line 99 of file MakeSterilePred.h.

Referenced by MCOscillated(), and SetNDBaseline().

TFile * MakeSterilePred::ND_data [private]

Definition at line 102 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetNDData().

TH1F * MakeSterilePred::ND_data_POT [private]

Definition at line 110 of file MakeSterilePred.h.

Referenced by GetHistos().

TH1D * MakeSterilePred::ND_dataCC [private]

Definition at line 119 of file MakeSterilePred.h.

Referenced by ComparePredWithData(), FDPrediction(), and GetHistos().

TH1D * MakeSterilePred::ND_dataNC [private]

Definition at line 119 of file MakeSterilePred.h.

Referenced by ComparePredWithData(), FDPrediction(), and GetHistos().

TFile* MakeSterilePred::ND_MC [private]

Definition at line 102 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetNDMC().

TH1F* MakeSterilePred::ND_MC_POT [private]

Definition at line 110 of file MakeSterilePred.h.

Referenced by GetHistos().

TFile * MakeSterilePred::ND_Nue [private]

Definition at line 102 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetNDMC().

TH1F * MakeSterilePred::ND_Nue_POT [private]

Definition at line 110 of file MakeSterilePred.h.

Referenced by GetHistos().

TFile * MakeSterilePred::ND_NuTau [private]

Definition at line 102 of file MakeSterilePred.h.

Referenced by GetHistos(), and SetNDMC().

Definition at line 110 of file MakeSterilePred.h.

Referenced by GetHistos().

TH2D * MakeSterilePred::NDCC_AppNue [private]

Definition at line 114 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 114 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 114 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

TH2D * MakeSterilePred::NDCC_NuMu [private]

Definition at line 114 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 114 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

TH2D * MakeSterilePred::NDNC_AppNue [private]

Definition at line 113 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 113 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 113 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

TH2D * MakeSterilePred::NDNC_NuMu [private]

Definition at line 113 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 113 of file MakeSterilePred.h.

Referenced by GetHistos(), and MCOscillated().

Definition at line 75 of file MakeSterilePred.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 76 of file MakeSterilePred.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 67 of file MakeSterilePred.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 68 of file MakeSterilePred.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 74 of file MakeSterilePred.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 69 of file MakeSterilePred.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 70 of file MakeSterilePred.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 73 of file MakeSterilePred.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 72 of file MakeSterilePred.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

double MakeSterilePred::POT [private]

Definition at line 105 of file MakeSterilePred.h.


The documentation for this class was generated from the following files:

Generated on 22 Nov 2017 for loon by  doxygen 1.6.1