NuMMRunFCNSINubar Class Reference

#include <NuMMRunFCNSINubar.h>

Inheritance diagram for NuMMRunFCNSINubar:

NuMMRunNuBar NuMMRun List of all members.

Public Member Functions

 NuMMRunFCNSINubar (NuMMHelperCPT *helper, const NuMatrixSpectrum *ndNuData, const NuMatrixSpectrum *ndBarData, double pot)
 NuMMRunFCNSINubar (NuMMHelperCPT *helper, const NuMatrixSpectrum *ndNuData, const NuMatrixSpectrum *ndBarData, const NuMatrixSpectrum *fdNuData, const NuMatrixSpectrum *fdBarData)
 NuMMRunFCNSINubar (const NuMMRunFCNSINubar &old)
 ~NuMMRunFCNSINubar ()
virtual Double_t ComparePredWithData (const NuMMParameters &pars)
virtual std::pair< NuMatrixSpectrum,
NuMatrixSpectrum
MakeFDPred (const NuMMParameters &pars)
 Return a pair (NQ,PQ) of NuMatrixSpectra of the far detector prediction with oscillation parameters described in pars. Pure virtual.
virtual std::vector< TH1D > WriteFDPredHistos (const NuMMParameters &pars) const
virtual NuMatrixSpectrum TrueComponents (const NuMMParameters &pars, Sample_t s) const
 Return the individual true energy prediction of the far detector sub sample s with oscillation parameters described in pars. Default implementation just drops an error.
virtual NuMatrixSpectrum TrueComponents (const NuMMParameters &pars, Sample_t s)
void OscillateNuMu (NuMatrixSpectrum &numu, const NuMMParameters &pars) const
 Helper. Oscillates, decays or decoheres a true energy numu spectrum.
void InverseOscillateNuTau (NuMatrixSpectrum &nutau, const NuMMParameters &pars) const
 Helper. Inverse oscillates a true energy nutau spectrum.
void OscillateNuBar (NuMatrixSpectrum &numu, const NuMMParameters &pars) const
 Helper. Oscillates, decays or decoheres a true energy nubar spectrum.
void InverseOscillateTauBar (NuMatrixSpectrum &nutau, const NuMMParameters &pars) const
 Helper. Inverse oscillates a true energy taubar spectrum.
virtual void PredictNus (Bool_t predict)
 Will the neutrino prediction be calculated?
virtual void PredictNuBars (Bool_t predict)
 Will the antineutrino prediction be calculated?
virtual Bool_t PredictNus ()
virtual Bool_t PredictNuBars ()
void LinearInterpolation (Bool_t predict)
 Will the linear interpolation be applied?
Bool_t PreCalcWrongSign (const NuMMParameters &pars)
void ResetCache ()
virtual void ResetNDData (const NuMatrix &nddata)
 Replace the ND data used in extrapolation.
virtual void ResetFDData (const NuMatrix &fddata)
 Replace the FD data used in extrapolation.
virtual std::auto_ptr< NuMatrixGetNDData (void) const
 Returns the ND data used in extrapolation.
virtual std::auto_ptr< NuMatrixGetFDData (void) const
 Return the FD data used in extrapolation.

Private Member Functions

void Init (NuMMHelperCPT *helper, const NuMatrixSpectrum *ndNuData, const NuMatrixSpectrum *ndBarData, const NuMatrixSpectrum *fdNuData, const NuMatrixSpectrum *fdBarData)
NuMMRunFCNSINubaroperator= (const NuMMRunFCNSINubar &rhs)
 Disallow assignment: This is broken, so don't let people do it.
void CacheExtrapolation (void)

Private Attributes

NuMatrixSpectrumPreCalcnuPrediction
NuMatrixSpectrumPreCalcbarPrediction
NuMatrixSpectrumPreCalcpotentialNuTaus
NuMatrixSpectrumPreCalcpotentialTauBars
NuMatrixSpectrumPreCalcnuNCBackground
NuMatrixSpectrumPreCalcbarNCBackground
NuMatrixSpectrumPreCalcwrongSignNuMus
NuMatrixSpectrumPreCalcwrongSignNuBars
Bool_t fLinearInterpolation
 Controls oscillation weights method.
Bool_t fDoneWsNeutrinos
 Flags to remember if the wrong sign has been precalculated.
Bool_t fDoneWsAntineutrinos

Detailed Description

Definition at line 17 of file NuMMRunFCNSINubar.h.


Constructor & Destructor Documentation

NuMMRunFCNSINubar::NuMMRunFCNSINubar ( NuMMHelperCPT helper,
const NuMatrixSpectrum ndNuData,
const NuMatrixSpectrum ndBarData,
double  pot 
)

Definition at line 25 of file NuMMRunFCNSINubar.cxx.

References EVD::Init(), Msg::kError, and MSG.

00029   : NuMMRunNuBar()
00030 {
00031   // Duplicate this test here, as we try to use the helper before moving to init
00032   if (!helper) {
00033     MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for helper" << endl;
00034     assert(helper);
00035   }
00036   
00037   // We haven't been passed a FD histogram yet, but we know what the binning
00038   // will be because we know the algorithm.
00039   assert(helper->FDNuPurity());
00040   TH1D hBlank(*reinterpret_cast<const TH1D*>(helper->FDNuPurity()));
00041   hBlank.SetNameTitle("herror", "Blank default FD data: Something went wrong");
00042 
00043   NuMatrixSpectrum *tmpNu = new NuMatrixSpectrum(hBlank, pot);
00044   NuMatrixSpectrum *tmpBar = new NuMatrixSpectrum(hBlank, pot);
00045   Init(helper, ndNuData, ndBarData, tmpNu, tmpBar);
00046   // Delete these temporary histograms - they should have been copied by the function
00047   delete tmpNu;
00048   delete tmpBar;
00049 }

NuMMRunFCNSINubar::NuMMRunFCNSINubar ( NuMMHelperCPT helper,
const NuMatrixSpectrum ndNuData,
const NuMatrixSpectrum ndBarData,
const NuMatrixSpectrum fdNuData,
const NuMatrixSpectrum fdBarData 
)

Definition at line 67 of file NuMMRunFCNSINubar.cxx.

References Init().

00072                    : NuMMRunNuBar()
00073 {
00074   Init(helper, ndNuData, ndBarData, fdNuData, fdBarData);
00075 }

NuMMRunFCNSINubar::NuMMRunFCNSINubar ( const NuMMRunFCNSINubar old  ) 

Definition at line 169 of file NuMMRunFCNSINubar.cxx.

References fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMRunNuBar::ffdBarData, NuMMRunNuBar::ffdNuData, NuMMRunNuBar::fHelper, fLinearInterpolation, NuMMRunNuBar::fndBarData, NuMMRunNuBar::fndNuData, NuMMRunNuBar::fPredictAntiNeutrinos, NuMMRunNuBar::fPredictNeutrinos, PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, and PreCalcwrongSignNuMus.

00169                                                                  : NuMMRunNuBar(old)
00170 {
00171   // Copy all the old histograms
00172   fndNuData =  new NuMatrixSpectrum(*old.fndNuData);
00173   fndBarData = new NuMatrixSpectrum(*old.fndBarData);
00174   ffdNuData =  new NuMatrixSpectrum(*old.ffdNuData);
00175   ffdBarData = new NuMatrixSpectrum(*old.ffdBarData);
00176 
00177   fHelper = old.fHelper;
00178   
00179   // Blank out all the Precache variables before reassignment
00180   PreCalcnuPrediction   = PreCalcbarPrediction      = 0;
00181   PreCalcpotentialNuTaus= PreCalcpotentialTauBars   = 0;
00182   PreCalcnuNCBackground = PreCalcbarNCBackground    = 0;
00183   PreCalcwrongSignNuMus = PreCalcwrongSignNuBars    = 0;
00184     
00185   // Make copies of all the precalculations frmo the old runner
00186   if (old.PreCalcnuPrediction)
00187     PreCalcnuPrediction = new NuMatrixSpectrum(*old.PreCalcnuPrediction);
00188   if (old.PreCalcbarPrediction)
00189     PreCalcbarPrediction = new NuMatrixSpectrum(*old.PreCalcbarPrediction);
00190   if (old.PreCalcpotentialNuTaus)
00191     PreCalcpotentialNuTaus = new NuMatrixSpectrum(*old.PreCalcpotentialNuTaus);
00192   if (old.PreCalcpotentialTauBars)
00193     PreCalcpotentialTauBars = new NuMatrixSpectrum(*old.PreCalcpotentialTauBars);
00194   
00195   if (old.PreCalcnuNCBackground)
00196     PreCalcnuNCBackground = new NuMatrixSpectrum(*old.PreCalcnuNCBackground);
00197   if (old.PreCalcbarNCBackground)
00198     PreCalcbarNCBackground = new NuMatrixSpectrum(*old.PreCalcbarNCBackground);
00199 
00200   if (old.PreCalcwrongSignNuMus)
00201     PreCalcwrongSignNuMus = new NuMatrixSpectrum(*old.PreCalcwrongSignNuMus);
00202   if (old.PreCalcwrongSignNuBars)
00203     PreCalcwrongSignNuBars = new NuMatrixSpectrum(*old.PreCalcwrongSignNuBars);
00204   
00205   fPredictNeutrinos = old.fPredictNeutrinos;
00206   fPredictAntiNeutrinos = old.fPredictAntiNeutrinos;
00207   fLinearInterpolation = old.fLinearInterpolation;  
00208   
00209   // Set the wrong sign to false however - this copy may want different
00210   // oscillation parameters!
00211   fDoneWsNeutrinos = fDoneWsAntineutrinos = false;
00212 }

NuMMRunFCNSINubar::~NuMMRunFCNSINubar (  ) 

Definition at line 216 of file NuMMRunFCNSINubar.cxx.

References NuMMRunNuBar::ffdBarData, NuMMRunNuBar::ffdNuData, NuMMRunNuBar::fndBarData, NuMMRunNuBar::fndNuData, and ResetCache().

00217 {
00218   ResetCache();
00219   
00220   // We now take copies of the data histograms - clean them up
00221   if (fndNuData)  delete fndNuData;   fndNuData   = 0;
00222   if (fndBarData) delete fndBarData;  fndBarData  = 0;
00223   if (ffdNuData)  delete ffdNuData;   ffdNuData   = 0;
00224   if (ffdBarData) delete ffdBarData;  ffdBarData  = 0;
00225 }


Member Function Documentation

void NuMMRunFCNSINubar::CacheExtrapolation ( void   )  [private]

Pre-calculate much of the extrapolation. Most of the matrix method extrapolation does not depend on the oscillation parameters. This includes lots of complicated matrix multiplications and histogram divisions. This function seperates out this code, and is called from the constructor (as everything it needs should exist with a validly called constructor)

Definition at line 455 of file NuMMRunFCNSINubar.cxx.

References NuMMHelperCPT::BarBeamMatrix(), NuMMHelperCPT::BarBeamMatrixNuMuCCXSec(), NuMMHelperCPT::BarBeamMatrixTauCCXSec(), NuMMHelperCPT::BarXSecGraph(), NuMatrixSpectrum::Divide(), NuMMHelperCPT::DoTaus(), NuMatrixSpectrum::ExtrapolateNDToFD(), NuMMRunNuBar::fCached, NuMMHelperCPT::FDBarEfficiency(), NuMMHelperCPT::FDBarNCContamination(), NuMMHelperCPT::FDBarPurity(), NuMMHelperCPT::FDBarRecoVsTrue(), NuMMHelperCPT::FDNuEfficiency(), NuMMHelperCPT::FDNuNCContamination(), NuMMHelperCPT::FDNuPurity(), NuMMHelperCPT::FDNuRecoVsTrue(), NuMMHelperCPT::FDNuTauEfficiency(), fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMHelperCPT::FDTauBarEfficiency(), NuMMHelperCPT::FDWrongSignBarEfficiency(), NuMMHelperCPT::FDWrongSignNuEfficiency(), NuMMRunNuBar::ffdBarData, NuMMRun::fFDFidMass, NuMMRunNuBar::ffdNuData, NuMMRunNuBar::fHelper, NuMMRunNuBar::fndBarData, NuMMRun::fNDFidMass, NuMMRunNuBar::fndNuData, NuMatrix::GetPOT(), Msg::kWarning, MAXMSG, NuMatrixSpectrum::Multiply(), NuMMHelperCPT::NDBarEfficiency(), NuMMHelperCPT::NDBarPurity(), NuMMHelperCPT::NDBarRecoVsTrue(), NuMMHelperCPT::NDNuEfficiency(), NuMMHelperCPT::NDNuPurity(), NuMMHelperCPT::NDNuRecoVsTrue(), NuMMHelperCPT::NuBeamMatrix(), NuMMHelperCPT::NuBeamMatrixNuMuCCXSec(), NuMMHelperCPT::NuBeamMatrixTauCCXSec(), NuMMHelperCPT::NuXSecGraph(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMatrixSpectrum::RecoToTrue(), ResetCache(), NuMatrix::ResetPOT(), NuMatrixSpectrum::SetName(), NuMatrixSpectrum::TrueToReco(), NuMMHelperCPT::XSecGraphNuTaus(), and NuMMHelperCPT::XSecGraphTauBars().

Referenced by Init(), MakeFDPred(), PredictNuBars(), PredictNus(), ResetFDData(), ResetNDData(), and TrueComponents().

00456 {
00457     // Only cache once.
00458     if (fCached) return;
00459   
00460     ResetCache();
00461   
00462     // Disable this output for now - this process should be fast anyway!
00463     // if (!fQuietMode)
00464     //     cout << "Pre-calculating static extrapolation variables..." << endl;
00465     
00466     // Caching variables, to reduce the workload of each step of the fitter
00467     // Initialise these the way they would be before
00468     PreCalcnuPrediction = new NuMatrixSpectrum(*fndNuData);
00469     PreCalcbarPrediction = new NuMatrixSpectrum(*fndBarData);
00470     
00471     // Be lazy and just alias the pointers to references so can keep
00472     // the code the same
00473     NuMatrixSpectrum &nuPrediction = *PreCalcnuPrediction;
00474     NuMatrixSpectrum &barPrediction = *PreCalcbarPrediction;
00475     
00476     // Now we have prepared the extrapolation variables, calculate them
00477     // Get the neutrinos to ND Flux x Xsec
00478     nuPrediction.Multiply(fHelper->NDNuPurity());
00479     nuPrediction.RecoToTrue(fHelper->NDNuRecoVsTrue());
00480     nuPrediction.Divide(fHelper->NDNuEfficiency());
00481     nuPrediction.Divide(fndNuData->GetPOT());
00482     nuPrediction.Divide(fNDFidMass);
00483 
00484     // Get the antineutrinos to ND Flux x Xsec
00485     barPrediction.Multiply(fHelper->NDBarPurity());
00486     barPrediction.RecoToTrue(fHelper->NDBarRecoVsTrue());
00487     barPrediction.Divide(fHelper->NDBarEfficiency());
00488     barPrediction.Divide(fndBarData->GetPOT());
00489     barPrediction.Divide(fNDFidMass);
00490     
00491 
00492     // Create and link to the Tau components, before we include the
00493     // cross section in the predictions (tau Xsec is different)
00494     PreCalcpotentialNuTaus = new NuMatrixSpectrum(nuPrediction);
00495     PreCalcpotentialTauBars = new NuMatrixSpectrum(barPrediction);
00496     NuMatrixSpectrum &potentialNuTaus = *PreCalcpotentialNuTaus;
00497     NuMatrixSpectrum &potentialTauBars = *PreCalcpotentialTauBars;
00498 
00499     
00500     // Get the Neutrinos to the FD
00501     nuPrediction.ExtrapolateNDToFD(fHelper->NuBeamMatrixNuMuCCXSec());
00502     nuPrediction.Multiply(fFDFidMass);
00503     nuPrediction.Multiply(ffdNuData->GetPOT());
00504     // Reset the spectrum to the new POT
00505     nuPrediction.ResetPOT(ffdNuData->GetPOT());
00506 
00507     // Get the Antineutrinos to the FD
00508     barPrediction.ExtrapolateNDToFD(fHelper->BarBeamMatrixNuMuCCXSec());
00509     barPrediction.Multiply(fFDFidMass);
00510     barPrediction.Multiply(ffdBarData->GetPOT());
00511     // Reset the spectrum to the new PoT
00512     barPrediction.ResetPOT(ffdBarData->GetPOT());
00513 
00514 
00515     if (fHelper->DoTaus()) {
00516         // Get the Neutrinos to the FD
00517         if (fHelper->NuBeamMatrixTauCCXSec()) {
00518             potentialNuTaus.ExtrapolateNDToFD(fHelper->NuBeamMatrixTauCCXSec());
00519             potentialTauBars.ExtrapolateNDToFD(fHelper->BarBeamMatrixTauCCXSec());
00520         }
00521         else {
00522             MAXMSG("NuMMRunFCNSINubar",Msg::kWarning,10) << "Doing tau extrapolation the old way." << endl;
00523             potentialNuTaus.Divide(fHelper->NuXSecGraph());
00524             potentialNuTaus.ExtrapolateNDToFD(fHelper->NuBeamMatrix());
00525             potentialNuTaus.Multiply(fHelper->XSecGraphNuTaus());
00526             potentialTauBars.Divide(fHelper->BarXSecGraph());
00527             potentialTauBars.ExtrapolateNDToFD(fHelper->BarBeamMatrix());
00528             potentialTauBars.Multiply(fHelper->XSecGraphTauBars());
00529         }
00530             
00531         potentialNuTaus.Multiply(fFDFidMass);
00532         potentialNuTaus.Multiply(ffdNuData->GetPOT());
00533         // Reset the spectrum to the new PoT
00534         potentialNuTaus.ResetPOT(ffdNuData->GetPOT());
00535         potentialNuTaus.Multiply(fHelper->FDNuTauEfficiency());
00536         
00537         // Get the Antineutrinos to the FD
00538         potentialTauBars.Multiply(fFDFidMass);
00539         potentialTauBars.Multiply(ffdBarData->GetPOT());
00540         // Reset the spectrum to the new PoT
00541         potentialTauBars.ResetPOT(ffdBarData->GetPOT());
00542         potentialTauBars.Multiply(fHelper->FDTauBarEfficiency());
00543     }
00544     else {
00545         PreCalcpotentialNuTaus->Multiply(0.0);
00546         PreCalcpotentialTauBars->Multiply(0.0);
00547     }
00548   
00549     // Now build the NC Spectrum, after the cross section calculation!
00550     PreCalcnuNCBackground = new NuMatrixSpectrum(*PreCalcnuPrediction);;
00551     PreCalcbarNCBackground = new NuMatrixSpectrum(*PreCalcbarPrediction);
00552     NuMatrixSpectrum &nuNCBackground = *PreCalcnuNCBackground;
00553     NuMatrixSpectrum &barNCBackground = *PreCalcbarNCBackground;  
00554 
00555     //Get the neutrino NC background
00556     nuNCBackground.Multiply(fHelper->FDNuEfficiency());
00557     nuNCBackground.TrueToReco(fHelper->FDNuRecoVsTrue());
00558     nuNCBackground.Divide(fHelper->FDNuPurity());
00559     nuNCBackground.Multiply(fHelper->FDNuNCContamination());
00560 
00561     //Get the antineutrino NC background
00562     barNCBackground.Multiply(fHelper->FDBarEfficiency());
00563     barNCBackground.TrueToReco(fHelper->FDBarRecoVsTrue());
00564     barNCBackground.Divide(fHelper->FDBarPurity());
00565     barNCBackground.Multiply(fHelper->FDBarNCContamination());
00566     
00567     // Now build the wrong sign spectrum
00568     PreCalcwrongSignNuMus = new NuMatrixSpectrum(*PreCalcnuPrediction);
00569     PreCalcwrongSignNuBars = new NuMatrixSpectrum(*PreCalcbarPrediction);
00570     NuMatrixSpectrum &wrongSignNuMus = *PreCalcwrongSignNuMus;
00571     NuMatrixSpectrum &wrongSignNuBars = *PreCalcwrongSignNuBars;
00572     
00573     // Do the Neutrino background for the antineutrino spectrum
00574     wrongSignNuMus.Multiply(fHelper->FDWrongSignNuEfficiency());
00575     
00576     // Do the Antineutrino background for the neutrino spectrum
00577     wrongSignNuBars.Multiply(fHelper->FDWrongSignBarEfficiency());
00578     
00579     // Apply the efficiency to the predictions
00580     barPrediction.Multiply(fHelper->FDBarEfficiency());
00581     nuPrediction.Multiply(fHelper->FDNuEfficiency());
00582     
00583   
00584     nuPrediction.SetName("NuMus");
00585     barPrediction.SetName("NuMuBars");
00586     
00587     if (fHelper->DoTaus()) {
00588       potentialNuTaus.SetName("NuTaus");
00589       potentialTauBars.SetName("NuTauBars");
00590     }
00591     
00592     wrongSignNuMus.SetName("WrongSign_NuMus");
00593     wrongSignNuBars.SetName("WrongSign_NuMuBars");
00594     
00595     nuNCBackground.SetName("NC_NuMus");
00596     barNCBackground.SetName("NC_NuMuBars");
00597   
00598     fCached = true;
00599   
00600     // If we have precalculated the wrong sign oscillations,
00601     // then we need to recalculate them next time we are given
00602     // the oscilaltion parameters. Reset the flags used to
00603     // control this  
00604     fDoneWsNeutrinos = fDoneWsAntineutrinos = false;
00605 }

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

Implements NuMMRun.

Definition at line 854 of file NuMMRunFCNSINubar.cxx.

00855 {
00856   // Generate a prediction
00857   const pair<NuMatrixSpectrum,NuMatrixSpectrum> predictions =
00858     this->MakeFDPred(pars);
00859   Double_t like = 0;
00860   // Now, only count a likelihood for components we want - this is just
00861   // a constant offset, but should help speed things up a little.
00862   if (fPredictNeutrinos)
00863   {
00864     like += this->StatsLikelihood(predictions.first.Spectrum(),
00865         ffdNuData->Spectrum());
00866   }
00867   if (fPredictAntiNeutrinos) {
00868     like += this->StatsLikelihood(predictions.second.Spectrum(),
00869         ffdBarData->Spectrum());
00870   }
00871   return like;
00872 }

auto_ptr< NuMatrix > NuMMRunFCNSINubar::GetFDData ( void   )  const [virtual]

Return the FD data used in extrapolation.

Reimplemented from NuMMRun.

Definition at line 1076 of file NuMMRunFCNSINubar.cxx.

References NuMMRunNuBar::ffdBarData, NuMMRunNuBar::ffdNuData, and Munits::nm.

01077 {
01078   // NOTE: The data objects are stored as protected data members in the
01079   // NuMMRunNuBar class. However, the way the data is dealt with is very
01080   // specific to each extrapolation, so it turns out to be easier to 
01081   // do this here, in this leaf class than centrally.
01082   
01083   // Convert to a NuMatrixCPT, as charge-signs are separated internally
01084   NuMatrixCPT *nm = new NuMatrixCPT(ffdNuData, ffdBarData);
01085   return auto_ptr<NuMatrix>(nm);
01086 }

auto_ptr< NuMatrix > NuMMRunFCNSINubar::GetNDData ( void   )  const [virtual]

Returns the ND data used in extrapolation.

Reimplemented from NuMMRun.

Definition at line 1062 of file NuMMRunFCNSINubar.cxx.

References NuMMRunNuBar::fndBarData, NuMMRunNuBar::fndNuData, and Munits::nm.

01063 {
01064   // NOTE: The data objects are stored as protected data members in the
01065   // NuMMRunNuBar class. However, the way the data is dealt with is very
01066   // specific to each extrapolation, so it turns out to be easier to 
01067   // do this here, in this leaf class than centrally.
01068   
01069   // Convert to a NuMatrixCPT, as charge-signs are separated internally
01070   NuMatrixCPT *nm = new NuMatrixCPT(fndNuData, fndBarData);
01071   return auto_ptr<NuMatrix>(nm);
01072 }

void NuMMRunFCNSINubar::Init ( NuMMHelperCPT helper,
const NuMatrixSpectrum ndNuData,
const NuMatrixSpectrum ndBarData,
const NuMatrixSpectrum fdNuData,
const NuMatrixSpectrum fdBarData 
) [private]

Definition at line 95 of file NuMMRunFCNSINubar.cxx.

References CacheExtrapolation(), NuMMHelperCPT::FDBarEfficiency(), NuMMHelperCPT::FDNuEfficiency(), fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMRunNuBar::ffdBarData, NuMMRunNuBar::ffdNuData, NuMMRunNuBar::fHelper, fLinearInterpolation, NuMMRunNuBar::fndBarData, NuMMRunNuBar::fndNuData, NuMMRunNuBar::fPredictAntiNeutrinos, NuMMRunNuBar::fPredictNeutrinos, Msg::kError, MSG, PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, and NuMatrixSpectrum::Spectrum().

Referenced by NuMMRunFCNSINubar().

00100 {
00101   fLinearInterpolation = true;
00102   fDoneWsNeutrinos = false;
00103   fDoneWsAntineutrinos = false;  
00104   fPredictNeutrinos = true;
00105   fPredictAntiNeutrinos = true;
00106   
00107   if (!helper) {
00108     MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for helper" << endl;
00109     assert(helper);
00110   }
00111   if (!ndNuData) {
00112     MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for ndNuData" << endl;
00113     assert(ndNuData);
00114   }
00115   if (!ndBarData) {
00116     MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for ndBarData" << endl;
00117     assert(ndBarData);
00118   }
00119   if (!fdNuData) {
00120     MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for fdNuData" << endl;
00121     assert(fdNuData);
00122   }
00123   if (!fdBarData) {
00124     MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for fdBarData" << endl;
00125     assert(fdBarData);
00126   }  
00127   
00128   
00129   fndNuData   = new NuMatrixSpectrum(*ndNuData);
00130   fndBarData  = new NuMatrixSpectrum(*ndBarData);
00131   ffdNuData   = new NuMatrixSpectrum(*fdNuData);
00132   ffdBarData  = new NuMatrixSpectrum(*fdBarData);
00133 
00134   fHelper = helper;
00135   
00136   // Protect against cases where the FD data is not the same
00137   // binning as the prediction would be. Use the helper file
00138   // as a guide to what this should be...
00139   // Only perform this check if the passed in data has a spectrum
00140   if (fdNuData->Spectrum()) {
00141     if (fdNuData->Spectrum()->GetNbinsX() != fHelper->FDNuEfficiency()->GetNbinsX()) {
00142       MSG("NuMMRunFCNSINubar",Msg::kError) << "Nu Binning Mismatch: fdNuData # bins: " << fdNuData->Spectrum()->GetNbinsX() 
00143       << " and fHelper # bins: " << fHelper->FDNuEfficiency()->GetNbinsX() << endl;
00144       assert(fdNuData->Spectrum()->GetNbinsX() == fHelper->FDNuEfficiency()->GetNbinsX());
00145     }
00146   }
00147   if (fdBarData->Spectrum()) {
00148     if (fdBarData->Spectrum()->GetNbinsX() != fHelper->FDBarEfficiency()->GetNbinsX()) {
00149       MSG("NuMMRunFCNSINubar",Msg::kError) << "Bar Binning Mismatch: fdNuData # bins: " << fdBarData->Spectrum()->GetNbinsX() 
00150       << " and fHelper # bins: " << fHelper->FDBarEfficiency()->GetNbinsX() << endl;
00151       assert(fdBarData->Spectrum()->GetNbinsX() == fHelper->FDBarEfficiency()->GetNbinsX());
00152     }
00153   }
00154   
00155   // Blank out all the Precache variables
00156   PreCalcnuPrediction   = PreCalcbarPrediction      = 0;
00157   PreCalcpotentialNuTaus= PreCalcpotentialTauBars   = 0;
00158   PreCalcnuNCBackground = PreCalcbarNCBackground    = 0;
00159   PreCalcwrongSignNuMus = PreCalcwrongSignNuBars    = 0;
00160   
00161   // We should now be completely capable of calculating the
00162   // halfway point of the prediction. Do so now.
00163   CacheExtrapolation();
00164 }

void NuMMRunFCNSINubar::InverseOscillateNuTau ( NuMatrixSpectrum nutau,
const NuMMParameters pars 
) const

Helper. Inverse oscillates a true energy nutau spectrum.

Does nothing if the model is decay or decoherence

Definition at line 901 of file NuMMRunFCNSINubar.cxx.

References NuMMParameters::Alpha(), NuMMParameters::Dm2(), NuMMParameters::Epsilon(), NuMMRun::fDisappearanceModel, fLinearInterpolation, NuMMParameters::Mu2(), NueConvention::nutau, and NuMMParameters::Sn2().

Referenced by MakeFDPred(), TrueComponents(), and WriteFDPredHistos().

00903 {
00904   if(fDisappearanceModel == 0) {
00905     if(fLinearInterpolation)
00906       nutau.InverseOscillateLinearInterp(pars.Dm2(), pars.Sn2());
00907     else
00908       nutau.InverseOscillatePreAveraged(pars.Dm2(), pars.Sn2());
00909   }
00910   if(fDisappearanceModel == 1)
00911     nutau.DecayMuToTau(pars.Dm2(), pars.Sn2(), pars.Alpha());
00912   if(fDisappearanceModel == 2)
00913     nutau.InverseDecohere(pars.Dm2(), pars.Sn2(), pars.Mu2());
00914   if(fDisappearanceModel == 3)
00915     nutau.InverseOscillateNSI(pars.Dm2(), pars.Sn2(), pars.Epsilon(), 1.0);
00916 }

void NuMMRunFCNSINubar::InverseOscillateTauBar ( NuMatrixSpectrum nutau,
const NuMMParameters pars 
) const

Helper. Inverse oscillates a true energy taubar spectrum.

Does nothing if the model is decay or decoherence

Definition at line 946 of file NuMMRunFCNSINubar.cxx.

References NuMMParameters::Alpha(), NuMMParameters::Dm2Bar(), NuMMParameters::Epsilon(), NuMMRun::fDisappearanceModel, fLinearInterpolation, NuMMParameters::Mu2(), NueConvention::nutau, and NuMMParameters::Sn2Bar().

Referenced by MakeFDPred(), TrueComponents(), and WriteFDPredHistos().

00948 {
00949   if(fDisappearanceModel == 0) {
00950     if(fLinearInterpolation)
00951       nutau.InverseOscillateLinearInterp(pars.Dm2Bar(), pars.Sn2Bar());
00952     else
00953       nutau.InverseOscillatePreAveraged(pars.Dm2Bar(), pars.Sn2Bar());
00954   }
00955   if(fDisappearanceModel == 1)
00956     nutau.DecayMuToTau(pars.Dm2Bar(), pars.Sn2Bar(), pars.Alpha());
00957   if(fDisappearanceModel == 2)
00958     nutau.InverseDecohere(pars.Dm2Bar(), pars.Sn2Bar(), pars.Mu2());
00959   if(fDisappearanceModel == 3)
00960     nutau.InverseOscillateNSI(pars.Dm2Bar(), pars.Sn2Bar(), pars.Epsilon(), -1.0);
00961 }

void NuMMRunFCNSINubar::LinearInterpolation ( Bool_t  predict  )  [inline]

Will the linear interpolation be applied?

Definition at line 75 of file NuMMRunFCNSINubar.h.

References fLinearInterpolation.

Referenced by NuFCFitterNSINubar::NuFCFitterNSINubar().

00075                                            {  
00076       fLinearInterpolation = predict; 
00077   }

pair< NuMatrixSpectrum, NuMatrixSpectrum > NuMMRunFCNSINubar::MakeFDPred ( const NuMMParameters pars  )  [virtual]

Return a pair (NQ,PQ) of NuMatrixSpectra of the far detector prediction with oscillation parameters described in pars. Pure virtual.

Implements NuMMRunNuBar.

Definition at line 646 of file NuMMRunFCNSINubar.cxx.

References NuMatrix1D::Add(), CacheExtrapolation(), NuMMParameters::Dm2(), NuMMParameters::Dm2Bar(), NuMMHelperCPT::DoTaus(), NuMMParameters::Epsilon(), NuMMHelperCPT::FDBarRecoVsTrue(), NuMMHelperCPT::FDNuRecoVsTrue(), NuMMHelperCPT::FDNuTauRecoVsTrue(), fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMHelperCPT::FDTauBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignNuRecoVsTrue(), NuMMRunNuBar::fHelper, NuMMRunNuBar::fPredictAntiNeutrinos, NuMMRunNuBar::fPredictNeutrinos, NuMMRun::fQuietMode, InverseOscillateNuTau(), InverseOscillateTauBar(), OscillateNuBar(), OscillateNuMu(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMMParameters::Sn2(), NuMMParameters::Sn2Bar(), NuMatrixSpectrum::Spectrum(), and NuMatrixSpectrum::TrueToReco().

Referenced by NuFCGridPointNSINubar::PredictSpectrum().

00647 {
00648   // Precache extrap, but only if needed
00649   CacheExtrapolation(); 
00650   
00651   // Output the oscillation settings!
00652   if (!fQuietMode) {
00653       //pars.PrintStatus();
00654     cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
00655          << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
00656          << "; epsilon: "<< pars.Epsilon() << endl;
00657   }
00658   
00660   // For all neutrinos
00661 
00662   // Make copies of the prepared extrapolation variables, so that
00663   // we can alter them locally with the oscillation parameters
00664   NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);
00665   NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
00666   
00667   NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
00668   NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);
00669 
00670   NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
00671   NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
00672   
00673   NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
00674   NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
00675 
00677   // Processes for neutrinos
00678   
00679   if (fPredictNeutrinos)
00680   {  
00681     if (fHelper->DoTaus()) {
00682       // Oscillate the taus
00683       InverseOscillateNuTau(potentialNuTaus,pars);
00684       potentialNuTaus.TrueToReco(fHelper->FDNuTauRecoVsTrue());
00685     }
00686 
00687     // If we have pre-oscillated the wrong sign, do not do so again
00688     if (!fDoneWsAntineutrinos) {
00689         // Antineutrinos in the neutrino spectrum
00690         OscillateNuBar(wrongSignNuBars,pars);
00691         wrongSignNuBars.TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
00692     }
00693 
00694     // Oscillate the Neutrino spectrum!
00695     OscillateNuMu(nuPrediction,pars);
00696 
00697     // True to Reco
00698     nuPrediction.TrueToReco(fHelper->FDNuRecoVsTrue());
00699 
00700     //Add in backgrounds
00701     nuPrediction.Add(wrongSignNuBars);
00702     nuPrediction.Add(nuNCBackground);
00703     if (fHelper->DoTaus()) nuPrediction.Add(potentialNuTaus);
00704   } else {
00705       // Scale the histogram to zero, so as not to confuse people
00706       // if they look at the spectrum with neutrinos turned off
00707       nuPrediction.Spectrum()->Scale(0);
00708   }
00709   
00711   // Processes for Antineutrinos
00712   
00713   if (fPredictAntiNeutrinos)
00714   {
00715       if (fHelper->DoTaus()) {
00716         // Oscillate the taubars
00717         InverseOscillateTauBar(potentialTauBars,pars);
00718         potentialTauBars.TrueToReco(fHelper->FDTauBarRecoVsTrue());
00719       }
00720 
00721       // Only oscillate the wrong sign if it hasn't been done already
00722       if (!fDoneWsNeutrinos) {
00723           // Oscillate the wrong sign component
00724           // Neutrinos for the antineutrino spectrum
00725           OscillateNuMu(wrongSignNuMus,pars);
00726           wrongSignNuMus.TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
00727       }
00728       // Oscillate the antineutrino spectrum!
00729       OscillateNuBar(barPrediction,pars);
00730 
00731       // True to reco
00732      barPrediction.TrueToReco(fHelper->FDBarRecoVsTrue());
00733       
00734       // Add in backgrounds
00735       barPrediction.Add(wrongSignNuMus);
00736       barPrediction.Add(barNCBackground);
00737       if (fHelper->DoTaus()) barPrediction.Add(potentialTauBars);
00738   } else {
00739       // Scale the histogram to zero, so as not to confuse people
00740       barPrediction.Spectrum()->Scale(0);
00741   }
00742   
00743   // Return the two predictions, as a pair
00744   pair<NuMatrixSpectrum,NuMatrixSpectrum>
00745     predictions(nuPrediction,barPrediction);
00746   return predictions;
00747 }

NuMMRunFCNSINubar& NuMMRunFCNSINubar::operator= ( const NuMMRunFCNSINubar rhs  )  [private]

Disallow assignment: This is broken, so don't let people do it.

void NuMMRunFCNSINubar::OscillateNuBar ( NuMatrixSpectrum numu,
const NuMMParameters pars 
) const

Helper. Oscillates, decays or decoheres a true energy nubar spectrum.

Definition at line 919 of file NuMMRunFCNSINubar.cxx.

References NuMMParameters::Alpha(), NuMMParameters::Dm2Bar(), NuMMParameters::Epsilon(), NuMMRun::fDisappearanceModel, fLinearInterpolation, NuMMParameters::Mu2(), NueConvention::numu, and NuMMParameters::Sn2Bar().

Referenced by MakeFDPred(), PreCalcWrongSign(), TrueComponents(), and WriteFDPredHistos().

00921 {
00922   switch(fDisappearanceModel){
00923   case 0:
00924     if(fLinearInterpolation)
00925       numu.OscillateLinearInterp(pars.Dm2Bar(), pars.Sn2Bar());
00926     else
00927       numu.OscillatePreAveraged(pars.Dm2Bar(), pars.Sn2Bar());
00928     return;
00929   case 1:
00930     numu.DecayCC(pars.Dm2Bar(), pars.Sn2Bar(), pars.Alpha());
00931     return;
00932   case 2:
00933     numu.Decohere(pars.Dm2Bar(), pars.Sn2Bar(), pars.Mu2());
00934     return;
00935   case 3: 
00936     numu.OscillateNSI(pars.Dm2Bar(), pars.Sn2Bar(), pars.Epsilon(), -1.0);
00937     return;
00938 
00939   default:
00940     assert(0 && "Badly configured disappearance model");
00941   }
00942 }   

void NuMMRunFCNSINubar::OscillateNuMu ( NuMatrixSpectrum numu,
const NuMMParameters pars 
) const

Helper. Oscillates, decays or decoheres a true energy numu spectrum.

Definition at line 875 of file NuMMRunFCNSINubar.cxx.

References NuMMParameters::Alpha(), NuMMParameters::Dm2(), NuMMParameters::Epsilon(), NuMMRun::fDisappearanceModel, fLinearInterpolation, NuMMParameters::Mu2(), NueConvention::numu, and NuMMParameters::Sn2().

Referenced by MakeFDPred(), PreCalcWrongSign(), TrueComponents(), and WriteFDPredHistos().

00877 {
00878   switch(fDisappearanceModel){
00879   case 0:
00880     if(fLinearInterpolation)
00881       numu.OscillateLinearInterp(pars.Dm2(), pars.Sn2());
00882     else
00883       numu.OscillatePreAveraged(pars.Dm2(), pars.Sn2());
00884     return;
00885   case 1:
00886     numu.DecayCC(pars.Dm2(), pars.Sn2(), pars.Alpha());
00887     return;
00888   case 2:
00889     numu.Decohere(pars.Dm2(), pars.Sn2(), pars.Mu2());
00890     return;
00891   case 3: 
00892     numu.OscillateNSI(pars.Dm2(), pars.Sn2(), pars.Epsilon(), 1.0);
00893     return;
00894   default:
00895     assert(0 && "Badly configured disappearance model");
00896   }
00897 }

Bool_t NuMMRunFCNSINubar::PreCalcWrongSign ( const NuMMParameters pars  ) 

Pre-calculate the wrong sign oscillation. This is a valid action in cases where, for instance, the neutrino prediction has been turned off. It is assumed that if you are not predicting neutrinos, then the neutrino mixing parameters remain constant throughout the fit. Returns false if everything has already been precalculated.

Definition at line 609 of file NuMMRunFCNSINubar.cxx.

References fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMHelperCPT::FDWrongSignBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignNuRecoVsTrue(), NuMMRunNuBar::fHelper, NuMMRunNuBar::fPredictAntiNeutrinos, NuMMRunNuBar::fPredictNeutrinos, NuMMRun::fQuietMode, OscillateNuBar(), OscillateNuMu(), PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, and NuMatrixSpectrum::TrueToReco().

00610 {
00611     // Did we change anything in this run?
00612     Bool_t change = false;
00613     
00614     // Precalculate the wrong sign, if we have disabled predictions
00615     // for that class, and it hasn't been done already. This should only
00616     // be done once, unless of course the user does something strange like
00617     // turning on neutrino prediction in the middle of an extrapolation.
00618     if(!fDoneWsNeutrinos) {
00619         if (!fPredictNeutrinos)
00620         {
00621             change = true;
00622             if (!fQuietMode) cout << "Neutrino prediction off: Precalculating wrong sign oscillation." << endl;
00623             OscillateNuMu(*PreCalcwrongSignNuMus,pars);
00624             PreCalcwrongSignNuMus->TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
00625             fDoneWsNeutrinos = true;
00626         }
00627     }
00628     if(!fPredictAntiNeutrinos) {
00629         if (!fDoneWsAntineutrinos)
00630         {
00631             change = true;
00632             if (!fQuietMode) cout << "Antineutrino prediction off: Precalculating wrong sign oscillation." << endl;
00633             OscillateNuBar(*PreCalcwrongSignNuBars,pars);
00634             PreCalcwrongSignNuBars->TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
00635             fDoneWsAntineutrinos = true;
00636         }
00637     }
00638     
00639     // Return the flag saying if we have changed anything
00640     return change;
00641 }

virtual Bool_t NuMMRunFCNSINubar::PredictNuBars (  )  [inline, virtual]

Reimplemented from NuMMRunNuBar.

Definition at line 71 of file NuMMRunFCNSINubar.h.

References NuMMRunNuBar::fPredictAntiNeutrinos.

00071 { return fPredictAntiNeutrinos;}

virtual void NuMMRunFCNSINubar::PredictNuBars ( Bool_t  predict  )  [inline, virtual]

Will the antineutrino prediction be calculated?

Reimplemented from NuMMRunNuBar.

Definition at line 66 of file NuMMRunFCNSINubar.h.

References CacheExtrapolation(), fDoneWsAntineutrinos, and NuMMRunNuBar::fPredictAntiNeutrinos.

00066                                              {
00067       fPredictAntiNeutrinos = predict;
00068       if(fDoneWsAntineutrinos) CacheExtrapolation();
00069   }

virtual Bool_t NuMMRunFCNSINubar::PredictNus (  )  [inline, virtual]

Reimplemented from NuMMRunNuBar.

Definition at line 70 of file NuMMRunFCNSINubar.h.

References NuMMRunNuBar::fPredictNeutrinos.

00070 { return fPredictNeutrinos;}

virtual void NuMMRunFCNSINubar::PredictNus ( Bool_t  predict  )  [inline, virtual]

Will the neutrino prediction be calculated?

Reimplemented from NuMMRunNuBar.

Definition at line 61 of file NuMMRunFCNSINubar.h.

References CacheExtrapolation(), fDoneWsNeutrinos, and NuMMRunNuBar::fPredictNeutrinos.

Referenced by NuFCFitterNSINubar::NuFCFitterNSINubar().

00061                                           {
00062       fPredictNeutrinos = predict;
00063       if(fDoneWsNeutrinos) CacheExtrapolation();
00064   }

void NuMMRunFCNSINubar::ResetCache (  ) 

Resets the internal cache. This means that the next time you ask for a prediction, it will take longer as everything will need to be calculated from scratch.

Definition at line 230 of file NuMMRunFCNSINubar.cxx.

References NuMMRunNuBar::fCached, PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, and PreCalcwrongSignNuMus.

Referenced by CacheExtrapolation(), ResetFDData(), ResetNDData(), TrueComponents(), and ~NuMMRunFCNSINubar().

00231 {
00232   // delete the precalculated MM spectra we previously created
00233   if (PreCalcnuPrediction)    delete PreCalcnuPrediction;
00234   if (PreCalcbarPrediction)   delete PreCalcbarPrediction;
00235   
00236   if (PreCalcpotentialNuTaus) delete PreCalcpotentialNuTaus; 
00237   if (PreCalcpotentialTauBars)delete PreCalcpotentialTauBars; 
00238   
00239   if (PreCalcnuNCBackground)  delete PreCalcnuNCBackground; 
00240   if (PreCalcbarNCBackground) delete PreCalcbarNCBackground; 
00241   
00242   if (PreCalcwrongSignNuMus)  delete PreCalcwrongSignNuMus; 
00243   if (PreCalcwrongSignNuBars) delete PreCalcwrongSignNuBars; 
00244   
00245   PreCalcnuPrediction    = PreCalcbarPrediction    = 0;
00246   PreCalcpotentialNuTaus = PreCalcpotentialTauBars = 0;
00247   PreCalcnuNCBackground  = PreCalcbarNCBackground  = 0;
00248   PreCalcwrongSignNuMus  = PreCalcwrongSignNuBars  = 0;
00249   
00250   fCached = false;
00251 }

void NuMMRunFCNSINubar::ResetFDData ( const NuMatrix fddata  )  [virtual]

Replace the FD data used in extrapolation.

Reimplemented from NuMMRun.

Definition at line 1001 of file NuMMRunFCNSINubar.cxx.

References CacheExtrapolation(), NuMatrixSpectrum::Copy(), NuMMRunNuBar::ffdBarData, NuMMRunNuBar::ffdNuData, NuMatrix1D::GetNuMatrixSpectrum(), NuMatrix::GetPOT(), Msg::kFatal, MSG, NuMatrixCPT::NQ(), NuMatrixCPT::PQ(), and ResetCache().

01002 {
01003   // Attempt downcast to a CPT object
01004   const NuMatrixCPT *cpt = dynamic_cast<const NuMatrixCPT*>(&fddata);
01005   if (!cpt) {
01006     MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: Have not been passed a CPT matrix object to reset ND Data" << endl;
01007   }
01008 
01009   // Pointers to temporary storage if we need to convert NuMatrix1D->NuMatrixspectrum
01010   // This is because we use borrowed pointers normally, but by creating a new NuMatrixSpectrum
01011   // we become responsible for destroying the objects, and leaking them is not an option.
01012   auto_ptr<NuMatrixSpectrum> tmpPQ, tmpNQ;
01013   
01014   // Extract the NQ and PQ spectra
01015   const NuMatrixSpectrum *pq = dynamic_cast<const NuMatrixSpectrum*>(cpt->PQ());
01016   if (!pq) {
01017     // Try a NuMatrix1D, then convert it to a NuMatrixSpecturm if it is
01018     const NuMatrix1D *nm1d = dynamic_cast<const NuMatrix1D*>(cpt->PQ());
01019     if (!nm1d) {
01020       // Fail if we cannot handle this histogram
01021       MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: PQ spectrum appears not to be a NuMatrixSpectrum or NuMatrix1D" << endl;
01022     }
01023     tmpPQ.reset(nm1d->GetNuMatrixSpectrum().Copy());
01024     pq = tmpPQ.get();
01025   }
01026   
01027   const NuMatrixSpectrum *nq = dynamic_cast<NuMatrixSpectrum*>(cpt->NQ());
01028   if (!nq) {
01029     // Try a NuMatrix1D, then convert it to a NuMatrixSpecturm if it is
01030     const NuMatrix1D *nm1d = dynamic_cast<const NuMatrix1D*>(cpt->NQ());
01031     if (!nm1d) {
01032       // Fail if we cannot handle this histogram
01033       MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: NQ spectrum appears not to be a NuMatrixSpectrum" << endl;
01034     }
01035     tmpNQ.reset(nm1d->GetNuMatrixSpectrum().Copy());
01036     nq = tmpNQ.get();
01037   }
01038   
01039   // Store the old FD data POT
01040   Double_t oldPOT = ffdNuData->GetPOT();
01041   
01042   // Delete the old spectra, if they exist
01043   if (ffdNuData) delete ffdNuData; ffdNuData = 0;
01044   if (ffdBarData) delete ffdBarData; ffdBarData = 0;
01045   
01046   // Copy the spectra to this object
01047   ffdNuData = nq->Copy();
01048   ffdBarData = pq->Copy();
01049   
01050   // If the POT has changed, we need to recache the extrapolation
01051   if (ffdNuData->GetPOT() != oldPOT)
01052   {
01053     // cout << "POT CHANGE: " << oldPOT << " -> " << ffdNuData->GetPOT()
01054     //   << " = change of " << ffdNuData->GetPOT() - oldPOT << " POT" << endl;
01055     ResetCache();
01056     CacheExtrapolation();
01057   }
01058 }

void NuMMRunFCNSINubar::ResetNDData ( const NuMatrix nddata  )  [virtual]

Replace the ND data used in extrapolation.

Reimplemented from NuMMRun.

Definition at line 966 of file NuMMRunFCNSINubar.cxx.

References CacheExtrapolation(), NuMatrixSpectrum::Copy(), NuMMRunNuBar::fndBarData, NuMMRunNuBar::fndNuData, Msg::kFatal, MSG, NuMatrixCPT::NQ(), NuMatrixCPT::PQ(), and ResetCache().

00967 {
00968   // Attempt downcast to a CPT object
00969   const NuMatrixCPT *cpt = dynamic_cast<const NuMatrixCPT*>(&nddata);
00970   if (!cpt) {
00971     MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: Have not been passed a CPT matrix object to reset ND Data" << endl;
00972   }
00973   
00974   // Extract the NQ and PQ spectra
00975   const NuMatrixSpectrum *pq = dynamic_cast<NuMatrixSpectrum*>(cpt->PQ());
00976   if (!pq) {
00977     MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: PQ spectrum appears not to be a NuMatrixSpectrum" << endl;
00978   }
00979   
00980   const NuMatrixSpectrum *nq = dynamic_cast<NuMatrixSpectrum*>(cpt->NQ());
00981   if (!nq) {
00982     MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: NQ spectrum appears not to be a NuMatrixSpectrum" << endl;
00983   }
00984   
00985   // Delete the old spectra, if they exist
00986   if (fndNuData) delete fndNuData; fndNuData = 0;
00987   if (fndBarData) delete fndBarData; fndBarData = 0;
00988   
00989   // Now we have the spectra!
00990   fndNuData = nq->Copy();
00991   fndBarData = pq->Copy();
00992   
00993   // Recalculate the extrapolation caches
00994   ResetCache();
00995   CacheExtrapolation();
00996 }

NuMatrixSpectrum NuMMRunFCNSINubar::TrueComponents ( const NuMMParameters pars,
Sample_t  s 
) [virtual]

Definition at line 753 of file NuMMRunFCNSINubar.cxx.

References CacheExtrapolation(), fDoneWsAntineutrinos, fDoneWsNeutrinos, Msg::kWarning, MAXMSG, ResetCache(), and TrueComponents().

00754 {
00755   if (fDoneWsNeutrinos || fDoneWsAntineutrinos) {
00756     MAXMSG("NuMMRunFCNSINubar",Msg::kWarning,10) << "Already True-To-Recoed the wrong signs.  Re-caching -- this may be slow event-by-event." << endl;
00757     ResetCache();
00758   }
00759 
00760   CacheExtrapolation(); 
00761   
00762   return static_cast<const NuMMRunFCNSINubar *>(this)->TrueComponents(pars, s);
00763 }

NuMatrixSpectrum NuMMRunFCNSINubar::TrueComponents ( const NuMMParameters pars,
Sample_t  s 
) const [virtual]

Return the individual true energy prediction of the far detector sub sample s with oscillation parameters described in pars. Default implementation just drops an error.

Reimplemented from NuMMRun.

Definition at line 765 of file NuMMRunFCNSINubar.cxx.

References NuMMParameters::Dm2(), NuMMParameters::Dm2Bar(), NuMMRunNuBar::fCached, fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMRunNuBar::fPredictAntiNeutrinos, NuMMRunNuBar::fPredictNeutrinos, NuMMRun::fQuietMode, InverseOscillateNuTau(), InverseOscillateTauBar(), Sample::kAppearedNQ, Sample::kAppearedPQ, Msg::kError, Msg::kFatal, Sample::kNCNQ, Sample::kNCPQ, Sample::kSignalNQ, Sample::kSignalPQ, Sample::kTauNQ, Sample::kTauPQ, Msg::kWarning, Sample::kWrongSignNQ, Sample::kWrongSignPQ, MAXMSG, MSG, OscillateNuBar(), OscillateNuMu(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMatrixSpectrum::SetName(), NuMMParameters::Sn2(), NuMMParameters::Sn2Bar(), and NuMatrixSpectrum::Spectrum().

Referenced by TrueComponents().

00766 {
00767   if (fDoneWsNeutrinos || fDoneWsAntineutrinos) {
00768     MAXMSG("NuMMRunFCNSINubar",Msg::kWarning,10) << "Already True-To-Recoed the wrong signs.  Re-caching -- this may be slow event-by-event." << endl;
00769     MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Cannot recache as TrueComponents is now constant" << endl;    
00770     // ResetCache();
00771   } 
00772   
00773   // Check that we are cached and throw an error otherwise
00774   if (!fCached) {
00775     MSG("NuMMRunFCNSINubar",Msg::kError) << "Have not cached extrapolation prior to asking for true components!" << endl;
00776     assert(fCached);
00777   }
00778   
00779   // Output the oscillation settings!
00780   if (!fQuietMode) {
00781     cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
00782     << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
00783     << endl;
00784   }
00785   
00786   // No appeared spectrum for oscillations
00787   if (s == kAppearedPQ || s == kAppearedNQ) {
00788     NuMatrixSpectrum blank(*PreCalcnuPrediction);
00789     blank.SetName("Blank");
00790     blank.Spectrum()->Scale(0);
00791     return blank;    
00792   }
00793   
00794   // Request NQ spectrum, but no NuBar Predictions OR
00795   // Request PQ spectrum, but no NuMu Predictions
00796   if ( (s < 0 && !fPredictNeutrinos) || 
00797       (s > 0 && !fPredictAntiNeutrinos) ) {
00798     NuMatrixSpectrum blank(*PreCalcnuPrediction);
00799     blank.SetName("Blank");
00800     blank.Spectrum()->Scale(0);
00801     return blank;
00802   }
00803   
00804   if (s == kSignalPQ) {
00805     NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
00806     OscillateNuBar(barPrediction,pars);
00807     return barPrediction;
00808   }
00809   else if (s == kSignalNQ) {
00810     NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);  
00811     OscillateNuMu(nuPrediction,pars);
00812     return nuPrediction;
00813   }
00814   else if (s == kWrongSignPQ) {
00815     NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
00816     OscillateNuMu(wrongSignNuMus,pars);
00817     return wrongSignNuMus;
00818   }
00819   else if (s == kWrongSignNQ) {
00820     NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
00821     OscillateNuBar(wrongSignNuBars,pars);
00822     return wrongSignNuBars;
00823   }  
00824   else if (s == kNCPQ) {
00825     NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
00826     return barNCBackground;
00827   }
00828   else if (s == kNCNQ) {
00829     NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
00830     return nuNCBackground;
00831   }
00832   else if (s == kTauPQ) {
00833     NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);
00834     InverseOscillateTauBar(potentialTauBars,pars);
00835     return potentialTauBars;
00836   }
00837   else if (s == kTauNQ) {
00838     NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
00839     InverseOscillateNuTau(potentialNuTaus,pars);
00840     return potentialNuTaus;
00841   }
00842   else {
00843     MSG("NuMMRunTransitions",Msg::kWarning) << "Requested unknown prediction #" << s << ", returning blank." << endl;
00844     NuMatrixSpectrum blank(*PreCalcnuPrediction);
00845     blank.SetName("Blank");
00846     blank.Spectrum()->Scale(0);
00847     return blank;
00848   }
00849 }

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

Implements NuMMRun.

Definition at line 256 of file NuMMRunFCNSINubar.cxx.

References NuMatrix1D::Add(), NuMMParameters::Dm2(), NuMMParameters::Dm2Bar(), NuMMHelperCPT::DoTaus(), NuMMHelperCPT::FDBarRecoVsTrue(), NuMMHelperCPT::FDNuRecoVsTrue(), NuMMHelperCPT::FDNuTauRecoVsTrue(), fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMHelperCPT::FDTauBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignNuRecoVsTrue(), NuMMRunNuBar::ffdBarData, NuMMRunNuBar::ffdNuData, NuMMRunNuBar::fHelper, NuMMRunNuBar::fndBarData, NuMMRunNuBar::fndNuData, NuMMRunNuBar::fPredictAntiNeutrinos, NuMMRunNuBar::fPredictNeutrinos, NuMMRun::fQuietMode, InverseOscillateNuTau(), InverseOscillateTauBar(), OscillateNuBar(), OscillateNuMu(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMMParameters::Sn2(), NuMMParameters::Sn2Bar(), NuMatrixSpectrum::Spectrum(), and NuMatrixSpectrum::TrueToReco().

00257 {    
00258   //Set up a vector to push the histograms into.
00259   vector<TH1D> vHistos;
00260 
00261   //Put the ND data in the vector:
00262   TH1D hNDNuData(*(fndNuData->Spectrum()));
00263   hNDNuData.SetName("ndDataNQ");
00264   hNDNuData.SetTitle("ndDataNQ");
00265   vHistos.push_back(*(new TH1D(hNDNuData)));
00266   TH1D hNDBarData(*(fndBarData->Spectrum()));
00267   hNDBarData.SetName("ndDataPQ");
00268   hNDBarData.SetTitle("ndDataPQ");
00269   vHistos.push_back(*(new TH1D(hNDBarData)));
00270 
00271   if (!fQuietMode) {
00272   cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
00273      << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
00274      << endl;
00275   }
00276 
00277   // Make copies of the prepared extrapolation variables
00278   NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);
00279   NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
00280   
00281   NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
00282   NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);
00283 
00284   NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
00285   NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
00286   
00287   NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
00288   NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
00289   
00290   cout << "NC Integral: " << barNCBackground.Spectrum()->Integral() << endl;
00291 
00292 
00293 
00294 // 
00295 //   //Add in backgrounds
00296 //   nuPrediction.Add(wrongSignNuBars);
00297 //   barPrediction.Add(wrongSignNuMus);
00298 //   nuPrediction.Add(nuNCBackground);
00299 //   nuPrediction.Add(potentialNuTaus);
00300 //   barPrediction.Add(barNCBackground);
00301 //   barPrediction.Add(potentialTauBars);
00302   
00304   // Processes for neutrinos
00305   
00306   if (fPredictNeutrinos)
00307   {  
00308     // Oscillate the taus
00309     if (fHelper->DoTaus()) {
00310       InverseOscillateNuTau(potentialNuTaus,pars);
00311     
00312       // Write out the true tau spectra
00313       TH1D hFDTausNuMu(*(potentialNuTaus.Spectrum()));
00314       hFDTausNuMu.SetName("fdTausNuMu");
00315       vHistos.push_back(hFDTausNuMu);
00316       
00317       potentialNuTaus.TrueToReco(fHelper->FDNuTauRecoVsTrue());
00318     }
00319 
00320     // Antineutrinos in the neutrino spectrum
00321     if (!fDoneWsAntineutrinos) OscillateNuBar(wrongSignNuBars,pars);
00322 
00323     // Now convert wrong sign to reco
00324     if (!fDoneWsAntineutrinos) wrongSignNuBars.TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
00325     
00326     // Write out the true wrong sign components
00327     TH1D hFDWrongSignNQ(*(wrongSignNuBars.Spectrum()));
00328     hFDWrongSignNQ.SetName("fdWrongSignNQ");
00329     vHistos.push_back(hFDWrongSignNQ);
00330     
00331     // Oscillation and efficiency for the Neutrino spectrum
00332     OscillateNuMu(nuPrediction,pars);
00333 //    nuPrediction.Multiply(fHelper->FDNuEfficiency());
00334 
00335     // Write out the true spectra for the prediction components
00336     // before we add in backgrounds
00337     TH1D hFDNoBackTrueNQ(*(nuPrediction.Spectrum()));
00338     hFDNoBackTrueNQ.SetName("fdBasePredictionNuMus");
00339     vHistos.push_back(hFDNoBackTrueNQ);
00340 
00341     // True to Reco
00342     nuPrediction.TrueToReco(fHelper->FDNuRecoVsTrue());
00343 
00344     // Dump out the reco spectrum before adding in the backgrounds
00345     TH1D hFDNoBackNQ(*(nuPrediction.Spectrum()));
00346     hFDNoBackNQ.SetName("fdBasePredictionNQ");
00347     vHistos.push_back(hFDNoBackNQ);
00348 
00349     //Add in backgrounds
00350     nuPrediction.Add(wrongSignNuBars);
00351     nuPrediction.Add(nuNCBackground);
00352     if (fHelper->DoTaus()) nuPrediction.Add(potentialNuTaus);
00353     
00354     //Put the other componants of the predictions in the vector
00355     TH1D hFDPredictionNQ(*(nuPrediction.Spectrum()));
00356     hFDPredictionNQ.SetName("fdPredictionNQ");
00357     vHistos.push_back(hFDPredictionNQ);
00358 
00359     TH1D hFDNCNQ(*(nuNCBackground.Spectrum()));
00360     hFDNCNQ.SetName("fdNCNQ");
00361     vHistos.push_back(hFDNCNQ);
00362 
00363     if (fHelper->DoTaus()) {
00364       TH1D hFDTausNQ(*(potentialNuTaus.Spectrum()));
00365       hFDTausNQ.SetName("fdTausNQ");
00366       vHistos.push_back(hFDTausNQ);
00367     }
00368     
00369     TH1D hFDDataNQ(*(ffdNuData->Spectrum()));
00370     hFDDataNQ.SetName("fdDataNQ");
00371     vHistos.push_back(hFDDataNQ);
00372     
00373   } else {
00374       // Scale the histogram to zero, so as not to confuse people
00375       nuPrediction.Spectrum()->Scale(0);
00376   }
00377   
00379   // Processes for Antineutrinos
00380   
00381   if (fPredictAntiNeutrinos)
00382   {
00383     if (fHelper->DoTaus()) {
00384       // Oscillate the taubars
00385       InverseOscillateTauBar(potentialTauBars,pars);
00386       // Write out the True Tau Spectrum
00387       TH1D hFDTausNuBar(*(potentialTauBars.Spectrum()));
00388       hFDTausNuBar.SetName("fdTausNuBar");
00389       vHistos.push_back(hFDTausNuBar);
00390       // Convert taus to reco energy
00391       potentialTauBars.TrueToReco(fHelper->FDTauBarRecoVsTrue());
00392     }
00393     // Oscillate the wrong sign component
00394     // Neutrinos for the antineutrino spectrum
00395     if (!fDoneWsNeutrinos) OscillateNuMu(wrongSignNuMus,pars);
00396 
00397     // Now, convert wrong sign to reco energy
00398     if (!fDoneWsNeutrinos) wrongSignNuMus.TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
00399     
00400     // write out the true wrong sign spectra
00401     TH1D hFDWrongSignPQ(*(wrongSignNuMus.Spectrum()));
00402     hFDWrongSignPQ.SetName("fdWrongSignPQ");
00403     vHistos.push_back(hFDWrongSignPQ);
00404     
00405     //Oscillation and efficiency for the antineutrino spectrum
00406     OscillateNuBar(barPrediction,pars);
00407 
00408     // Write out the true antineutrino spectrum, without backgrounds
00409     TH1D hFDNoBackTruePQ(*(barPrediction.Spectrum()));
00410     hFDNoBackTruePQ.SetName("fdBasePredictionNuBars");
00411     vHistos.push_back(hFDNoBackTruePQ);
00412 
00413     //True to reco
00414     barPrediction.TrueToReco(fHelper->FDBarRecoVsTrue());
00415 
00416     // Antineutrino reco spectrum, before backgrounds
00417     TH1D hFDNoBackPQ(*(barPrediction.Spectrum()));
00418     hFDNoBackPQ.SetName("fdBasePredictionPQ");
00419     vHistos.push_back(hFDNoBackPQ);
00420 
00421     //Add in backgrounds
00422     barPrediction.Add(wrongSignNuMus);
00423     barPrediction.Add(barNCBackground);
00424     if (fHelper->DoTaus()) barPrediction.Add(potentialTauBars);
00425     
00426     TH1D hFDPredictionPQ(*(barPrediction.Spectrum()));
00427     hFDPredictionPQ.SetName("fdPredictionPQ");
00428     vHistos.push_back(hFDPredictionPQ);
00429 
00430     TH1D hFDNCPQ(*(barNCBackground.Spectrum()));
00431     hFDNCPQ.SetName("fdNCPQ");
00432     vHistos.push_back(hFDNCPQ);
00433 
00434     if (fHelper->DoTaus()) {
00435       TH1D hFDTausPQ(*(potentialTauBars.Spectrum()));
00436       hFDTausPQ.SetName("fdTausPQ");
00437       vHistos.push_back(hFDTausPQ);
00438     }
00439 
00440     TH1D hFDDataPQ(*(ffdBarData->Spectrum()));
00441     hFDDataPQ.SetName("fdDataPQ");
00442     vHistos.push_back(hFDDataPQ);
00443     
00444   } else {
00445       // Scale the histogram to zero, so as not to confuse people
00446       barPrediction.Spectrum()->Scale(0);
00447   }
00448 
00449   return vHistos;
00450 }


Member Data Documentation

Bool_t NuMMRunFCNSINubar::fDoneWsAntineutrinos [private]

Definition at line 148 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), PreCalcWrongSign(), PredictNuBars(), TrueComponents(), and WriteFDPredHistos().

Bool_t NuMMRunFCNSINubar::fDoneWsNeutrinos [private]

Flags to remember if the wrong sign has been precalculated.

Definition at line 148 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), PreCalcWrongSign(), PredictNus(), TrueComponents(), and WriteFDPredHistos().

Bool_t NuMMRunFCNSINubar::fLinearInterpolation [private]

Controls oscillation weights method.

Definition at line 145 of file NuMMRunFCNSINubar.h.

Referenced by Init(), InverseOscillateNuTau(), InverseOscillateTauBar(), LinearInterpolation(), NuMMRunFCNSINubar(), OscillateNuBar(), and OscillateNuMu().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcbarNCBackground [private]

Definition at line 136 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), ResetCache(), TrueComponents(), and WriteFDPredHistos().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcbarPrediction [private]

Definition at line 127 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), ResetCache(), TrueComponents(), and WriteFDPredHistos().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcnuNCBackground [private]

Definition at line 135 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), ResetCache(), TrueComponents(), and WriteFDPredHistos().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcnuPrediction [private]

Definition at line 126 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), ResetCache(), TrueComponents(), and WriteFDPredHistos().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcpotentialNuTaus [private]

Definition at line 131 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), ResetCache(), TrueComponents(), and WriteFDPredHistos().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcpotentialTauBars [private]

Definition at line 132 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), ResetCache(), TrueComponents(), and WriteFDPredHistos().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcwrongSignNuBars [private]

Definition at line 142 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), PreCalcWrongSign(), ResetCache(), TrueComponents(), and WriteFDPredHistos().

NuMatrixSpectrum* NuMMRunFCNSINubar::PreCalcwrongSignNuMus [private]

Definition at line 141 of file NuMMRunFCNSINubar.h.

Referenced by CacheExtrapolation(), Init(), MakeFDPred(), NuMMRunFCNSINubar(), PreCalcWrongSign(), ResetCache(), TrueComponents(), and WriteFDPredHistos().


The documentation for this class was generated from the following files:
Generated on Thu Apr 10 23:03:16 2014 for loon by  doxygen 1.4.7