loon: NuMMRunNC2010 Class Reference

enum NuMMRunNC2010::EExtrapolationMode

How to perform the extrapolation for the NC FD prediction.

kNoExtrapolation does exactly what is says on the tin:

$F_r^{\rm pred}=\sum_tF_{tr}^{\rm MC}$

kNCFarOverNear F/N method in reco energy a la NC analysis:

$F_r^{\rm pred}={N_r^{\rm dat}\over\sum_tN_{rt}^{\rm MC}}\sum_tF_{tr}^{\rm MC}$

kCCFluxMeasurement uses the ratio of the flux predictions from ND MC and data as a correction in true energy:

$F_r^{\rm pred}=\sum_t{\Phi_t^{\rm dat}\over\Phi_t^{\rm MC}}F_{tr}^{\rm MC}$

kCCFluxMeasurementPlusNCFarOverNear applies true energy corrections from the CC flux prediction in both detectors and then treats the remaining data/MC differences in the ND as a reco energy correction to apply to the FD prediction.

$F_r^{\rm pred}={N_r^{\rm dat}\over\sum_t{\varphi_t^{\rm dat}\over\varphi_t^{\rm MC}}N_{tr}^{\rm MC}}\sum_t{\Phi_t^{\rm dat}\over\Phi_t^{\rm MC}}F_{tr}^{\rm MC}$

$ F $ - Far Detector, $ N $ - Near Detector, $ t $ - True energy, $ r $ - Reconstructed energy, $\Phi$ - Far Detector flux, $\varphi$ - Near Detector flux

Enumerator:

kNoExtrapolation
kNCFarOverNear
kCCFluxMeasurement
kCCFluxMeasurementPlusNCFarOverNear

Definition at line 44 of file NuMMRunNC2010.h.

00044                          {
00045     kNoExtrapolation,
00046     kNCFarOverNear,
00047     kCCFluxMeasurement,
00048     kCCFluxMeasurementPlusNCFarOverNear
00049   };

NuMMRunNC2010::NuMMRunNC2010	(	EExtrapolationMode	extrapMode,
		NuMMHelperPRL *	helper,
		NuMatrixSpectrum *	fdNCData,
		NuMatrixSpectrum *	ndNCData = `0`,
		NuMatrixSpectrum *	ndCCData = `0`,
		NuMatrixSpectrum *	ndCCMC = `0`
	)

Depending on extrapolation mode some of these spectra may not be required.

Definition at line 16 of file NuMMRunNC2010.cxx.

References NuMatrixSpectrum::Divide(), ENCTruth::kNumTruths, NuMatrix1D::ScaleToPOT(), NuMatrixSpectrum::SetName(), and NuMatrixSpectrum::Spectrum().

00022   : NuMMRun(),
00023     fSingleNCBin(false),
00024     fFDNCData(fdNCData)
00025 {
00026   // The amount by which FD MC must be reweighted in true energy so that it
00027   // matches the flux deduced from data.
00028   NuMatrixSpectrum* fdTrueECorr = 0;
00029   // Similary in ND...
00030   NuMatrixSpectrum* ndTrueECorr = 0;
00031 
00032   if(extrapMode == kCCFluxMeasurement ||
00033      extrapMode == kCCFluxMeasurementPlusNCFarOverNear){
00034     assert(ndCCData);
00035     assert(ndCCMC);
00036     fdTrueECorr = CalculateFDFlux(ndCCData, helper);
00037     fdTrueECorr->Divide(CalculateFDFlux(ndCCMC, helper));
00038     fdTrueECorr->SetName("fdTrueECorr");
00039 
00040     ndTrueECorr = CalculateNDFlux(ndCCData, helper);
00041     ndTrueECorr->Divide(CalculateNDFlux(ndCCMC, helper));
00042     ndTrueECorr->SetName("ndTrueECorr");
00043   }
00044 
00045   // Apply this correction to the ND reco vs. true MC
00046   TH2D* nd2D = (TH2D*)helper->NDRecoVsTrueNC()->Clone();
00047   ApplyCorrectionFactors(nd2D, ndTrueECorr, 0);
00048 
00049   // All differences left in the ND NC spectrum not accounted for by the beam
00050   // flux calculation are applied in reco energy as a correction for
00051   // cross-sections and efficiencies.
00052   NuMatrixSpectrum* fdRecoECorr = 0;
00053   if(extrapMode == kNCFarOverNear ||
00054      extrapMode == kCCFluxMeasurementPlusNCFarOverNear){
00055     assert(ndNCData);
00056 
00057   // Initialize with a normalization of 1 POT
00058     NuMatrixSpectrum ndMCRecoE = NuMatrixSpectrum(*nd2D->ProjectionY(), 1);
00059   // Scale to correct exposure
00060     ndMCRecoE.ScaleToPOT(ndNCData->GetPOT());
00061 
00062     fdRecoECorr = new NuMatrixSpectrum(*ndNCData);
00063     fdRecoECorr->Divide(ndMCRecoE);
00064     fdRecoECorr->Divide(ndNCData->GetPOT());
00065     fdRecoECorr->SetName("fdRecoECorr");
00066 
00067     /*
00068     new TCanvas;
00069     ndNCData->Draw();
00070     ndMCRecoE.Spectrum()->DrawClone("hist same");
00071     */
00072   }
00073 
00074   // Grab the different FD components out of the helper, and apply the
00075   // extrapolation corrections to them.
00076   for(int truth = 0; truth < ENCTruth::kNumTruths; ++truth){
00077     fTrueToRecoFD[truth] = (TH2D*)helper->RecoVsTrueNC(truth, 1)->Clone();
00078     ApplyCorrectionFactors(fTrueToRecoFD[truth],
00079                            fdTrueECorr, fdRecoECorr);
00080     // Was normalized to 1 POT
00081     assert(fFDNCData->GetPOT() > 0);
00082     fTrueToRecoFD[truth]->Scale(fFDNCData->GetPOT());
00083 
00084     fNCFDMCTrueE[truth] = NuMatrixSpectrum(*fTrueToRecoFD[truth]->ProjectionY());
00085   }
00086 
00087   if(fdTrueECorr) fDebugThings.push_back(fdTrueECorr->Spectrum()->Clone());
00088   if(ndTrueECorr) fDebugThings.push_back(ndTrueECorr->Spectrum()->Clone());
00089   if(fdRecoECorr) fDebugThings.push_back(fdRecoECorr->Spectrum()->Clone());
00090 
00091   if(fdTrueECorr) delete fdTrueECorr;
00092   if(ndTrueECorr) delete ndTrueECorr;
00093   if(fdRecoECorr) delete fdRecoECorr;
00094 }

void NuMMRunNC2010::ApplyCorrectionFactors	(	TH2D *	t2r,
		const NuMatrixSpectrum *	trueEcorr,
		const NuMatrixSpectrum *	recoEcorr
	)			const `[protected]`

Either correction factor may be NULL.

Definition at line 248 of file NuMMRunNC2010.cxx.

References NuMatrixSpectrum::GetNbinsX(), and NuMatrixSpectrum::Spectrum().

00251 {
00252   // Include underflow and overflow
00253   const int numTrueBins = t2r->GetNbinsX()+2;
00254   const int numRecoBins = t2r->GetNbinsY()+2;
00255 
00256   assert(!trueEcorr || numTrueBins == trueEcorr->GetNbinsX()+2);
00257   assert(!recoEcorr || numRecoBins == recoEcorr->GetNbinsX()+2);
00258 
00259   for(int recoBin = 0; recoBin < numRecoBins; ++recoBin){
00260     // Access fArray directly. GetBinContent and SetBinContent are slow
00261     const double recoScale = recoEcorr ? recoEcorr->Spectrum()->fArray[recoBin] : 1;
00262 
00263     for(int trueBin = 0; trueBin < numTrueBins; ++trueBin){
00264       const double trueScale = trueEcorr ? trueEcorr->Spectrum()->fArray[trueBin] : 1;
00265 
00266       t2r->fArray[trueBin+numTrueBins*recoBin] *= recoScale*trueScale;
00267     } // end for trueBin
00268   } // end for recoBin
00269 }

NuMatrixSpectrum * NuMMRunNC2010::CalculateFDFlux	(	const NuMatrixSpectrum *	nd,
		NuMMHelperPRL *	helper
	)			const `[protected]`

Beam matrix calculation based on observed spectrum nd.

Definition at line 361 of file NuMMRunNC2010.cxx.

References NuMMHelperPRL::BeamMatrix(), CalculateNDFlux(), and NuMatrixSpectrum::ExtrapolateNDToFD().

00362 {
00363   NuMatrixSpectrum* pred = CalculateNDFlux(nd, helper);
00364   pred->ExtrapolateNDToFD(helper->BeamMatrix());
00365   return pred;
00366 }

NuMatrixSpectrum * NuMMRunNC2010::CalculateNDFlux	(	const NuMatrixSpectrum *	nd,
		NuMMHelperPRL *	helper
	)			const `[protected]`

Beam matrix calculation based on observed spectrum nd.

Definition at line 345 of file NuMMRunNC2010.cxx.

References NuMatrixSpectrum::Divide(), NuMMRun::fNDFidMass, NuMatrix::GetPOT(), NuMatrixSpectrum::Multiply(), NuMMHelperPRL::NDEfficiency(), NuMMHelperPRL::NDPurity(), NuMMHelperPRL::NDRecoVsTrue(), NuMatrixSpectrum::RecoToTrue(), and NuMMHelperPRL::XSecGraph().

Referenced by CalculateFDFlux().

00346 {
00347   NuMatrixSpectrum* pred = new NuMatrixSpectrum(*nd);
00348 
00349   pred->Multiply(helper->NDPurity());
00350   pred->RecoToTrue(helper->NDRecoVsTrue());
00351   pred->Divide(helper->NDEfficiency());
00352   pred->Divide(helper->XSecGraph());
00353   pred->Divide(nd->GetPOT());
00354   pred->Divide(fNDFidMass);
00355 
00356   return pred;
00357 }

Double_t NuMMRunNC2010::ComparePredWithData ( const NuMMParameters & pars ) [virtual]

Implements NuMMRun.

Definition at line 324 of file NuMMRunNC2010.cxx.

References NuMatrixSpectrum::Integral(), and NuMatrixSpectrum::Spectrum().

00325 {
00326   NuMatrixSpectrum ncPrediction = MakeFDPred(pars);
00327 
00328   double ncChisq = 0;
00329   if(fSingleNCBin){
00330     const double pred = ncPrediction.Integral();
00331     const double data = fFDNCData->Integral();
00332     ncChisq = 2*(pred - data + data*log(data/pred));
00333   }
00334   else{
00335     ncChisq = StatsLikelihood(ncPrediction.Spectrum(),
00336                               fFDNCData->Spectrum());
00337   }
00338 
00339   return ncChisq;
00340 }

NuMatrixSpectrum NuMMRunNC2010::MakeFDPred ( const NuMMParameters & pars ) const [virtual]

Definition at line 129 of file NuMMRunNC2010.cxx.

References NuMatrix1D::Add(), count, NuMMParameters::Dm2(), fFDNCData, NuMMRun::fJessFile, NuMMRun::fQuietMode, ENCTruth::kCCmu, ENCTruth::kCCmubar, ENCTruth::kCCtau, ENCTruth::kCCtaubar, OscFit::kNC, ENCTruth::kNumTruths, MakeFDPredForSample(), MakeFDTrueVsRecoPredForSample(), NuMMParameters::NCBackgroundScale(), NuMMParameters::Normalisation(), NuMMParameters::ShwEnScale(), NuMMParameters::Sn2(), and NuMatrixSpectrum::Spectrum().

00130 {
00131   static Int_t count = 0;
00132   if ((!(count%3)) && (!fQuietMode)){
00133     cout << "8sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2()
00134          << "; norm: " << pars.Normalisation()
00135          << "; NCBack: " << pars.NCBackgroundScale()
00136          << "; ShwEn: " << pars.ShwEnScale() << endl;
00137   }
00138   ++count;
00139 
00140   using namespace ENCTruth;
00141 
00142   NuMatrixSpectrum ret;
00143   for(int truth = 0; truth < kNumTruths; ++truth)
00144     ret.Add(MakeFDPredForSample(pars, ENCTruth_t(truth)));
00145 
00146   if(fJessFile){
00147     fJessFile->cd();
00148 
00149     TH2D ccPred = MakeFDTrueVsRecoPredForSample(pars, kCCmu);
00150     TH2D ccbarPred = MakeFDTrueVsRecoPredForSample(pars, kCCmubar);
00151     ccPred.Add(&ccbarPred);
00152     ccPred.Write("nuPrediction");
00153 
00154     TH2D tauPred = MakeFDTrueVsRecoPredForSample(pars, kCCtau);
00155     TH2D taubarPred = MakeFDTrueVsRecoPredForSample(pars, kCCtaubar);
00156     tauPred.Add(&taubarPred);
00157     tauPred.Write("potentialTaus");
00158 
00159     NuMatrixSpectrum ncPred = MakeFDPredForSample(pars, kNC);
00160     ncPred.Spectrum()->Write("ncBackground");
00161 
00162     // Don't have any wrong-sign background. Provide it to be nice
00163     TH2D wsPred(ccPred);
00164     wsPred.Reset("ICE");
00165     wsPred.Write("wsBackground");
00166 
00167     fFDNCData->Spectrum()->Write("data");
00168 
00169     // TODO CJB : nues - probably need changes to GhostFitter
00170   } // end if fJessFile
00171 
00172   return ret;
00173 }

NuMatrixSpectrum NuMMRunNC2010::MakeFDPredForSample	(	const NuMMParameters &	pars,
		ENCTruth::ENCTruth_t	truth
	)			const `[protected]`

Helper for MakeFDPred.

Definition at line 218 of file NuMMRunNC2010.cxx.

References fFDNCData, MakeFDTrueVsRecoPredForSample(), and NuMatrixSpectrum::Spectrum().

Referenced by MakeFDPred().

00220 {
00221   TH2D t2r = MakeFDTrueVsRecoPredForSample(pars, truth);
00222 
00223   // Now project back to reco energy
00224   // Do this to get the right binning
00225   NuMatrixSpectrum ncPrediction = *fFDNCData;
00226   ncPrediction.Spectrum()->Reset();
00227 
00228   // Include underflow and overflow
00229   const int numTrueBins = t2r.GetNbinsX()+2;
00230   const int numRecoBins = t2r.GetNbinsY()+2;
00231 
00232   // The next two loops are equivalent to this, but faster.
00233   //    ncPrediction.Add(t2r[truth]->ProjectionY());
00234 
00235   double* ncPredSpecArr = ncPrediction.Spectrum()->fArray;
00236   const double* t2rTruthArr = t2r.fArray;
00237   for(int trueBin = 0; trueBin < numTrueBins; ++trueBin){
00238     for(int recoBin = 0; recoBin < numRecoBins; ++recoBin){
00239       ncPredSpecArr[recoBin] += t2rTruthArr[trueBin+numTrueBins*recoBin];
00240     }
00241   }
00242 
00243   return ncPrediction;
00244 }

TH2D NuMMRunNC2010::MakeFDTrueVsRecoPredForSample	(	const NuMMParameters &	pars,
		ENCTruth::ENCTruth_t	truth
	)			const `[protected]`

Helper for MakeFDPredForSample.

Definition at line 177 of file NuMMRunNC2010.cxx.

References fNCFDMCTrueE, fTrueToRecoFD, NuMatrixSpectrum::GetNbinsX(), Oscillate(), and NuMatrixSpectrum::Spectrum().

Referenced by MakeFDPred(), and MakeFDPredForSample().

00179 {
00180   using namespace ENCTruth;
00181 
00182   NuMatrixSpectrum ncPred = fNCFDMCTrueE[truth];
00183 
00184   Oscillate(ncPred, pars, truth);
00185 
00186   // We need to scale the reco vs true histogram so that every bin in
00187   // true energy matches the normalized, oscillated true energy prediction
00188 
00189   // So get the true energy prediction this matrix has now
00190 
00191   TH2D t2r(*fTrueToRecoFD[truth]);
00192   NuMatrixSpectrum predOld = fNCFDMCTrueE[truth];
00193   // Need to scale to 1 POT to match... something. TODO CJB, can we avoid this bit?
00194   //  predOld.ScaleToPot(1);
00195 
00196   // Include underflow and overflow
00197   const int numTrueBins = t2r.GetNbinsX()+2;
00198   const int numRecoBins = t2r.GetNbinsY()+2;
00199   for(int trueBin = 0; trueBin < numTrueBins; ++trueBin){
00200     // Access fArray directly. GetBinContent and SetBinContent are slow
00201     const double oldTot = predOld.Spectrum()->fArray[trueBin];
00202     const double oscTot = ncPred.Spectrum()->fArray[trueBin];
00203 
00204     // The scale between the true energy spectrum the matrix
00205     // currently predicts and the one that it should
00206     const double scale = oldTot ? oscTot/oldTot : 1;
00207     // Apply this correction factor
00208     for(int recoBin = 0; recoBin < numRecoBins; ++recoBin){
00209       t2r.fArray[trueBin+numTrueBins*recoBin] *= scale;
00210     } // end for recoBin
00211   } // end for trueBin
00212 
00213   return t2r;
00214 }

void NuMMRunNC2010::Oscillate	(	NuMatrixSpectrum &	ncPred,
		const NuMMParameters &	pars,
		ENCTruth::ENCTruth_t	truth
	)			const `[protected]`

or decay, or decohere. ncPred is a trueE energy spectrum

Definition at line 272 of file NuMMRunNC2010.cxx.

References NuMMParameters::Alpha(), NuMatrix1D::DecayCC(), NuMatrix1D::DecayNC(), NuMatrix1D::Decohere(), NuMMParameters::Dm2(), NuMMRun::fDisappearanceModel, NuMatrixSpectrum::InverseOscillate(), ENCTruth::kCCmu, ENCTruth::kCCmubar, ENCTruth::kCCtau, ENCTruth::kCCtaubar, OscFit::kNC, ENCTruth::kNCbar, NuMMParameters::Mu2(), NuMatrixSpectrum::Oscillate(), and NuMMParameters::Sn2().

Referenced by MakeFDTrueVsRecoPredForSample().

00275 {
00276   using namespace ENCTruth;
00277 
00278   // Save typing
00279   const double dm2 = pars.Dm2();
00280   const double sn2 = pars.Sn2();
00281   const double mu2 = pars.Mu2();
00282   const double alpha = pars.Alpha();
00283 
00284   switch(fDisappearanceModel){
00285   case 0:
00286     // NC oscillations are not observable
00287 
00288     // TODO CJB Hardoded CPT conserving oscillations, since the fitter
00289     // TODO CJB doesn't seem to conserve CPT for us.
00290     // TODO CJB Suspect taus are wrong everywhere
00291     if(truth == kCCmu)     ncPred.Oscillate(dm2, sn2);
00292     if(truth == kCCmubar)  ncPred.Oscillate(dm2, sn2);
00293     if(truth == kCCtau)    ncPred.InverseOscillate(dm2, sn2);
00294     if(truth == kCCtaubar) ncPred.InverseOscillate(dm2, sn2);
00295 
00296     break;
00297   case 1:
00298     // TODO CJB - this makes true taus decay the same as true mus. Is that OK?
00299     // TODO CJB - for nubar analysis we should assume -ve neutrinos don't decay
00300     // TODO CJB - if the fitter is taught about CPT this will be easier
00301     // TODO CJB - This doesn't handle CC electron and tau events right - ought
00302     // TODO CJB - to be a small effect.
00303     if(truth == kNC || truth == kNCbar)
00304       ncPred.DecayNC(alpha, sn2);
00305     else
00306       ncPred.DecayCC(dm2, sn2, alpha);
00307 
00308     break;
00309   case 2:
00310     // NC decoherence is not observable
00311 
00312     // TODO CJB is this enough?
00313     if(truth == kCCmu)    ncPred.Decohere(dm2, sn2, mu2);
00314     if(truth == kCCmubar) ncPred.Decohere(dm2, sn2, mu2);
00315 
00316     break;
00317   default:
00318     assert(0 && "Badly configured disappearance model.");
00319   }
00320 }

void NuMMRunNC2010::UseSingleNCBin ( bool val ) [inline]

Integrate up the spectra before calculating the log-likelihood.

Definition at line 67 of file NuMMRunNC2010.h.

References fSingleNCBin.

00067 {fSingleNCBin = val;}

void NuMMRunNC2010::WriteDebugThings ( TString fname ) [protected]

Definition at line 369 of file NuMMRunNC2010.cxx.

References fDebugThings.

00370 {
00371   TFile* fout = new TFile(fname, "RECREATE");
00372   for(unsigned int n = 0; n < fDebugThings.size(); ++n)
00373     fDebugThings[n]->Write();
00374   fout->Close();
00375 }

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

Implements NuMMRun.

Definition at line 98 of file NuMMRunNC2010.cxx.

References NuMatrix1D::Add(), ENCTruth::kCCmu, ENCTruth::kCCmubar, ENCTruth::kNC, ENCTruth::kNCbar, and NuMatrixSpectrum::Spectrum().

00099 {
00100   // The order of these histograms is chosen to match those in RunCC2010
00101   vector<TH1D> vHistos;
00102 
00103   TH1D blank;
00104 
00105   vHistos.push_back(blank);//*fNDNCData->Spectrum()); // ND data
00106 
00107   vHistos.push_back(blank);//*FDPredictionMCTrueE(pars).Spectrum()); // True E FD Pred
00108 
00109   NuMatrixSpectrum nc_only = MakeFDPredForSample(pars, ENCTruth::kNC);
00110   nc_only.Add(MakeFDPredForSample(pars, ENCTruth::kNCbar));
00111   vHistos.push_back(*nc_only.Spectrum()); // NC-only prediction
00112 
00113   vHistos.push_back(*MakeFDPred(pars).Spectrum()); // Full prediction
00114 
00115   vHistos.push_back(blank); // FD taus
00116 
00117   NuMatrixSpectrum cc_bkg = MakeFDPredForSample(pars, ENCTruth::kCCmu);
00118   cc_bkg.Add(MakeFDPredForSample(pars, ENCTruth::kCCmubar));
00119   vHistos.push_back(*cc_bkg.Spectrum()); // FD CC bkg
00120 
00121   vHistos.push_back(blank); // FD WS bkg
00122 
00123   vHistos.push_back(*fFDNCData->Spectrum()); // FD data
00124 
00125   return vHistos;
00126 }

std::vector<TObject*> NuMMRunNC2010::fDebugThings [protected]

Definition at line 107 of file NuMMRunNC2010.h.

Referenced by WriteDebugThings().

NuMatrixSpectrum* NuMMRunNC2010::fFDNCData [protected]

The FD data we're fitting to.

Definition at line 99 of file NuMMRunNC2010.h.

Referenced by MakeFDPred(), and MakeFDPredForSample().

NuMatrixSpectrum NuMMRunNC2010::fNCFDMCTrueE[ENCTruth::kNumTruths] [protected]

Just the projections of fTrueToRecoFD, for efficiency.

Definition at line 105 of file NuMMRunNC2010.h.

Referenced by MakeFDTrueVsRecoPredForSample().

bool NuMMRunNC2010::fSingleNCBin [protected]

Integrate up the spectra before calculating the log-likelihood.

Definition at line 96 of file NuMMRunNC2010.h.

Referenced by UseSingleNCBin().

TH2D* NuMMRunNC2010::fTrueToRecoFD[ENCTruth::kNumTruths] [protected]

The different components of the FD prediction.

Definition at line 102 of file NuMMRunNC2010.h.

Referenced by MakeFDTrueVsRecoPredForSample().

NuMMRunNC2010 Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Types
	kNoExtrapolation
	kNCFarOverNear
	kCCFluxMeasurement
	kCCFluxMeasurementPlusNCFarOverNear
enum	EExtrapolationMode { kNoExtrapolation, kNCFarOverNear, kCCFluxMeasurement, kCCFluxMeasurementPlusNCFarOverNear }
	How to perform the extrapolation for the NC FD prediction. More...
Public Member Functions
	NuMMRunNC2010 (EExtrapolationMode extrapMode, NuMMHelperPRL helper, NuMatrixSpectrum fdNCData, NuMatrixSpectrum ndNCData=0, NuMatrixSpectrum ndCCData=0, NuMatrixSpectrum *ndCCMC=0)
	Depending on extrapolation mode some of these spectra may not be required.
virtual Double_t	ComparePredWithData (const NuMMParameters &pars)
virtual NuMatrixSpectrum	MakeFDPred (const NuMMParameters &pars) const
virtual std::vector< TH1D >	WriteFDPredHistos (const NuMMParameters &pars) const
void	UseSingleNCBin (bool val)
	Integrate up the spectra before calculating the log-likelihood.
Protected Member Functions
TH2D	MakeFDTrueVsRecoPredForSample (const NuMMParameters &pars, ENCTruth::ENCTruth_t truth) const
	Helper for MakeFDPredForSample.
NuMatrixSpectrum	MakeFDPredForSample (const NuMMParameters &pars, ENCTruth::ENCTruth_t truth) const
	Helper for MakeFDPred.
void	ApplyCorrectionFactors (TH2D t2r, const NuMatrixSpectrum trueEcorr, const NuMatrixSpectrum *recoEcorr) const
	Either correction factor may be NULL.
void	Oscillate (NuMatrixSpectrum &ncPred, const NuMMParameters &pars, ENCTruth::ENCTruth_t truth) const
	or decay, or decohere. ncPred is a trueE energy spectrum
NuMatrixSpectrum *	CalculateNDFlux (const NuMatrixSpectrum nd, NuMMHelperPRL helper) const
	Beam matrix calculation based on observed spectrum nd.
NuMatrixSpectrum *	CalculateFDFlux (const NuMatrixSpectrum nd, NuMMHelperPRL helper) const
	Beam matrix calculation based on observed spectrum nd.
void	WriteDebugThings (TString fname)
Protected Attributes
bool	fSingleNCBin
	Integrate up the spectra before calculating the log-likelihood.
NuMatrixSpectrum *	fFDNCData
	The FD data we're fitting to.
TH2D *	fTrueToRecoFD [ENCTruth::kNumTruths]
	The different components of the FD prediction.
NuMatrixSpectrum	fNCFDMCTrueE [ENCTruth::kNumTruths]
	Just the projections of fTrueToRecoFD, for efficiency.
std::vector< TObject * >	fDebugThings