NuMMRunNC2010 Class Reference

Predict the Far Detector NC spectrum from one of a selection of techniques. More...

#include <NuMMRunNC2010.h>

Inheritance diagram for NuMMRunNC2010:

NuMMRun List of all members.

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
NuMatrixSpectrumCalculateNDFlux (const NuMatrixSpectrum *nd, NuMMHelperPRL *helper) const
 Beam matrix calculation based on observed spectrum nd.
NuMatrixSpectrumCalculateFDFlux (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.
NuMatrixSpectrumfFDNCData
 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

Detailed Description

Predict the Far Detector NC spectrum from one of a selection of techniques.

Definition at line 16 of file NuMMRunNC2010.h.


Member Enumeration Documentation

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.


Constructor & Destructor Documentation

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 }


Member Function Documentation

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 }


Member Data Documentation

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().


The documentation for this class was generated from the following files:
Generated on Mon Nov 10 00:56:03 2014 for loon by  doxygen 1.4.7