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

NuMMRunFC Class Reference

#include <NuMMRunFC.h>

Inheritance diagram for NuMMRunFC:

NuMMRunNuBar NuMMRun List of all members.

Public Member Functions

 NuMMRunFC (NuMMHelperCPT *helper, NuMatrixSpectrum *ndNuData, NuMatrixSpectrum *ndBarData, double pot)
 NuMMRunFC (NuMMHelperCPT *helper, NuMatrixSpectrum *ndNuData, NuMatrixSpectrum *ndBarData, NuMatrixSpectrum *fdNuData, NuMatrixSpectrum *fdBarData)
 NuMMRunFC (const NuMMRunFC &old)
 ~NuMMRunFC ()
virtual const Double_t ComparePredWithData (const NuMMParameters &pars)
virtual const 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 const std::vector<
TH1D > 		WriteFDPredHistos (const NuMMParameters &pars) const
virtual const NuMatrixSpectrum TrueComponents (const NuMMParameters &pars, Sample_t s)
void PredictNus (Bool_t predict)
 Will the neutrino prediction be calculated?
void PredictNuBars (Bool_t predict)
 Will the antineutrino prediction be calculated?

Private Member Functions

void CacheExtrapolation (void)
void ResetCache ()
void PreCalcWrongSign (const NuMMParameters &pars)

Private Attributes

NuMatrixSpectrum * PreCalcnuPrediction
NuMatrixSpectrum * PreCalcbarPrediction
NuMatrixSpectrum * PreCalcpotentialNuTaus
NuMatrixSpectrum * PreCalcpotentialTauBars
NuMatrixSpectrum * PreCalcnuNCBackground
NuMatrixSpectrum * PreCalcbarNCBackground
NuMatrixSpectrum * PreCalcwrongSignNuMus
NuMatrixSpectrum * PreCalcwrongSignNuBars
Bool_t fPredictNeutrinos
 Controls neutrino component of prediction.
Bool_t fPredictAntiNeutrinos
 Controls antineutrino component of prediction.
Bool_t fDoneWsNeutrinos
 Flags to remember if the wrong sign has been precalculated.
Bool_t fDoneWsAntineutrinos
 Flags to remember if the wrong sign has been precalculated.

Constructor & Destructor Documentation

NuMMRunFC::NuMMRunFC (  NuMMHelperCPT *  helper,
NuMatrixSpectrum *  ndNuData,
NuMatrixSpectrum *  ndBarData,
double  pot
) 
 

Definition at line 19 of file NuMMRunFC.cxx.

00023                : NuMMRunNuBar(),
00024                  fPredictNeutrinos(true),
00025                  fPredictAntiNeutrinos(true),
00026                  fDoneWsNeutrinos(false),
00027                  fDoneWsAntineutrinos(false)
00028 {
00029   TString name = "hError";
00030   name += (counter++);
00031   TH1D hBlank(name, "Something Went Wrong", 10, 0, 30);
00032   
00033   fndNuData = ndNuData;
00034   fndBarData = ndBarData;
00035   fHelper = helper;
00036   
00037   ffdNuData = new NuMatrixSpectrum(hBlank, pot);
00038   ffdBarData = new NuMatrixSpectrum(hBlank, pot);
00039 
00040   
00041   // Blank out all the Precache variables
00042   PreCalcnuPrediction   = PreCalcbarPrediction      = 0;
00043   PreCalcpotentialNuTaus= PreCalcpotentialTauBars   = 0;
00044   PreCalcnuNCBackground = PreCalcbarNCBackground    = 0;
00045   PreCalcwrongSignNuMus = PreCalcwrongSignNuBars    = 0;
00046   
00047   // We should now be completely capable of calculating the
00048   // halfway point of the prediction. Do so now.
00049   CacheExtrapolation();
00050   
00051 }

NuMMRunFC::NuMMRunFC (  NuMMHelperCPT *  helper,
NuMatrixSpectrum *  ndNuData,
NuMatrixSpectrum *  ndBarData,
NuMatrixSpectrum *  fdNuData,
NuMatrixSpectrum *  fdBarData
) 
 

Definition at line 54 of file NuMMRunFC.cxx.

References CacheExtrapolation(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, and PreCalcwrongSignNuMus.

00059                : NuMMRunNuBar(),
00060                  fPredictNeutrinos(true),
00061                  fPredictAntiNeutrinos(true),
00062                  fDoneWsNeutrinos(false),
00063                  fDoneWsAntineutrinos(false)
00064 {
00065   fndNuData = ndNuData;
00066   fndBarData = ndBarData;
00067   ffdNuData = fdNuData;
00068   ffdBarData = fdBarData;
00069   fHelper = helper;
00070   
00071   // Blank out all the Precache variables
00072   PreCalcnuPrediction   = PreCalcbarPrediction      = 0;
00073   PreCalcpotentialNuTaus= PreCalcpotentialTauBars   = 0;
00074   PreCalcnuNCBackground = PreCalcbarNCBackground    = 0;
00075   PreCalcwrongSignNuMus = PreCalcwrongSignNuBars    = 0;
00076   
00077   // We should now be completely capable of calculating the
00078   // halfway point of the prediction. Do so now.
00079   CacheExtrapolation();
00080   
00081 }

NuMMRunFC::NuMMRunFC (  const NuMMRunFC &  old  ) 
 

Definition at line 86 of file NuMMRunFC.cxx.

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

00086                                          : NuMMRunNuBar()
00087 {
00088   fndNuData = old.fndNuData;
00089   fndBarData = old.fndBarData;
00090   ffdNuData = old.ffdNuData;
00091   ffdBarData = old.ffdBarData;
00092   
00093   // Blank out all the Precache variables before reassignment
00094   PreCalcnuPrediction   = PreCalcbarPrediction      = 0;
00095   PreCalcpotentialNuTaus= PreCalcpotentialTauBars   = 0;
00096   PreCalcnuNCBackground = PreCalcbarNCBackground    = 0;
00097   PreCalcwrongSignNuMus = PreCalcwrongSignNuBars    = 0;
00098     
00099   // Make copies of all the precalculations frmo the old runner
00100   if (old.PreCalcnuPrediction)
00101     PreCalcnuPrediction = new NuMatrixSpectrum(*old.PreCalcnuPrediction);
00102   if (old.PreCalcbarPrediction)
00103     PreCalcbarPrediction = new NuMatrixSpectrum(*old.PreCalcbarPrediction);
00104   if (old.PreCalcpotentialNuTaus)
00105     PreCalcpotentialNuTaus = new NuMatrixSpectrum(*old.PreCalcpotentialNuTaus);
00106   if (old.PreCalcpotentialTauBars)
00107     PreCalcpotentialTauBars = new NuMatrixSpectrum(*old.PreCalcpotentialTauBars);
00108   
00109   if (old.PreCalcnuNCBackground)
00110     PreCalcnuNCBackground = new NuMatrixSpectrum(*old.PreCalcnuNCBackground);
00111   if (old.PreCalcbarNCBackground)
00112     PreCalcbarNCBackground = new NuMatrixSpectrum(*old.PreCalcbarNCBackground);
00113 
00114   if (old.PreCalcwrongSignNuMus)
00115     PreCalcwrongSignNuMus = new NuMatrixSpectrum(*old.PreCalcwrongSignNuMus);
00116   if (old.PreCalcwrongSignNuBars)
00117     PreCalcwrongSignNuBars = new NuMatrixSpectrum(*old.PreCalcwrongSignNuBars);
00118   
00119   fPredictNeutrinos = old.fPredictNeutrinos;
00120   fPredictAntiNeutrinos = old.fPredictAntiNeutrinos;
00121   
00122   // Set the wrong sign to false however - this copy may want different
00123   // oscillation parameters!
00124   fDoneWsNeutrinos = fDoneWsAntineutrinos = false;
00125 }

NuMMRunFC::~NuMMRunFC (   ) 
 

Definition at line 129 of file NuMMRunFC.cxx.

References ResetCache().

00130 {
00131   ResetCache();
00132 }

Member Function Documentation

void NuMMRunFC::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 362 of file NuMMRunFC.cxx.

References NuMMHelperCPT::BarBeamMatrix(), NuMMHelperCPT::BarXSecGraph(), NuMatrixSpectrum::Divide(), NuMMHelperCPT::DoTaus(), NuMatrixSpectrum::ExtrapolateNDToFD(), 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(), NuMatrixSpectrum::Multiply(), NuMMHelperCPT::NDBarEfficiency(), NuMMHelperCPT::NDBarPurity(), NuMMHelperCPT::NDBarRecoVsTrue(), NuMMHelperCPT::NDNuEfficiency(), NuMMHelperCPT::NDNuPurity(), NuMMHelperCPT::NDNuRecoVsTrue(), NuMMHelperCPT::NuBeamMatrix(), NuMMHelperCPT::NuXSecGraph(), NuMatrixSpectrum::PoT(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMatrixSpectrum::RecoToTrue(), ResetCache(), NuMatrixSpectrum::ResetPoT(), NuMatrixSpectrum::SetName(), NuMatrixSpectrum::TrueToReco(), NuMMHelperCPT::XSecGraphNuTaus(), and NuMMHelperCPT::XSecGraphTauBars().

Referenced by MakeFDPred(), NuMMRunFC(), PredictNuBars(), PredictNus(), and TrueComponents().

00363 {
00364     // Only cache once.
00365     if (fCached) return;
00366   
00367     ResetCache();
00368   
00369     // Disable this output for now - this process should be fast anyway!
00370     // if (!fQuietMode)
00371     //     cout << "Pre-calculating static extrapolation variables..." << endl;
00372     
00373     // Caching variables, to reduce the workload of each step of the fitter
00374     // Initialise these the way they would be before
00375     PreCalcnuPrediction = new NuMatrixSpectrum(*fndNuData);
00376     PreCalcbarPrediction = new NuMatrixSpectrum(*fndBarData);
00377     
00378     // Be lazy and just alias the pointers to references so can keep
00379     // the code the same
00380     NuMatrixSpectrum &nuPrediction = *PreCalcnuPrediction;
00381     NuMatrixSpectrum &barPrediction = *PreCalcbarPrediction;
00382     
00383     // Now we have prepared the extrapolation variables, calculate them
00384     // Get the neutrinos to the FD
00385     nuPrediction.Multiply(fHelper->NDNuPurity());
00386     nuPrediction.RecoToTrue(fHelper->NDNuRecoVsTrue());
00387     nuPrediction.Divide(fHelper->NDNuEfficiency());
00388     nuPrediction.Divide(fHelper->NuXSecGraph());
00389     nuPrediction.Divide(fndNuData->PoT());
00390     nuPrediction.Divide(fNDFidMass);
00391     nuPrediction.ExtrapolateNDToFD(fHelper->NuBeamMatrix());
00392     nuPrediction.Multiply(fFDFidMass);
00393     nuPrediction.Multiply(ffdNuData->PoT());
00394     // Reset the spectrum to the new PoT
00395     nuPrediction.ResetPoT(ffdNuData->PoT());
00396 
00397     //Get the antineutrinos to the FD
00398     barPrediction.Multiply(fHelper->NDBarPurity());
00399     barPrediction.RecoToTrue(fHelper->NDBarRecoVsTrue());
00400     barPrediction.Divide(fHelper->NDBarEfficiency());
00401     barPrediction.Divide(fHelper->BarXSecGraph());
00402     barPrediction.Divide(fndBarData->PoT());
00403     barPrediction.Divide(fNDFidMass);
00404     barPrediction.ExtrapolateNDToFD(fHelper->BarBeamMatrix());
00405     barPrediction.Multiply(fFDFidMass);
00406     barPrediction.Multiply(ffdBarData->PoT());
00407     // Reset the spectrum to the new PoT
00408     barPrediction.ResetPoT(ffdBarData->PoT());
00409 
00410     // Create and link to the Tau components, before we include the
00411     // cross section in the predictions (tau Xsec is different)
00412     PreCalcpotentialNuTaus = new NuMatrixSpectrum(nuPrediction);
00413     PreCalcpotentialTauBars = new NuMatrixSpectrum(barPrediction);
00414     NuMatrixSpectrum &potentialNuTaus = *PreCalcpotentialNuTaus;
00415     NuMatrixSpectrum &potentialTauBars = *PreCalcpotentialTauBars;
00416 
00417     if (fHelper->DoTaus()) {
00418       //Get the taus (ignoring any wrong-sign taubars)
00419       potentialNuTaus.Multiply(fHelper->XSecGraphNuTaus());
00420       potentialNuTaus.Multiply(fHelper->FDNuTauEfficiency());
00421       //Get the taubars (ignoring any wrong-sign taus)
00422       potentialTauBars.Multiply(fHelper->XSecGraphTauBars());
00423       potentialTauBars.Multiply(fHelper->FDTauBarEfficiency());
00424     }
00425     else {
00426       PreCalcpotentialNuTaus->Multiply(0.0);
00427       PreCalcpotentialTauBars->Multiply(0.0);
00428     }
00429   
00430     //Cross sections
00431     nuPrediction.Multiply(fHelper->NuXSecGraph());
00432     barPrediction.Multiply(fHelper->BarXSecGraph());
00433 
00434     // Now build the NC Spectrum, after the cross section calculation!
00435     PreCalcnuNCBackground = new NuMatrixSpectrum(*PreCalcnuPrediction);;
00436     PreCalcbarNCBackground = new NuMatrixSpectrum(*PreCalcbarPrediction);
00437     NuMatrixSpectrum &nuNCBackground = *PreCalcnuNCBackground;
00438     NuMatrixSpectrum &barNCBackground = *PreCalcbarNCBackground;  
00439 
00440     //Get the neutrino NC background
00441     nuNCBackground.Multiply(fHelper->FDNuEfficiency());
00442     nuNCBackground.TrueToReco(fHelper->FDNuRecoVsTrue());
00443     nuNCBackground.Divide(fHelper->FDNuPurity());
00444     nuNCBackground.Multiply(fHelper->FDNuNCContamination());
00445 
00446     //Get the antineutrino NC background
00447     barNCBackground.Multiply(fHelper->FDBarEfficiency());
00448     barNCBackground.TrueToReco(fHelper->FDBarRecoVsTrue());
00449     barNCBackground.Divide(fHelper->FDBarPurity());
00450     barNCBackground.Multiply(fHelper->FDBarNCContamination());
00451     
00452     // Now build the wrong sign spectrum
00453     PreCalcwrongSignNuMus = new NuMatrixSpectrum(*PreCalcnuPrediction);
00454     PreCalcwrongSignNuBars = new NuMatrixSpectrum(*PreCalcbarPrediction);
00455     NuMatrixSpectrum &wrongSignNuMus = *PreCalcwrongSignNuMus;
00456     NuMatrixSpectrum &wrongSignNuBars = *PreCalcwrongSignNuBars;
00457     
00458     // Do the Neutrino background for the antineutrino spectrum
00459     wrongSignNuMus.Multiply(fHelper->FDWrongSignNuEfficiency());
00460     
00461     // Do the Antineutrino background for the neutrino spectrum
00462     wrongSignNuBars.Multiply(fHelper->FDWrongSignBarEfficiency());
00463     
00464     // Apply the efficiency to the predictions
00465     barPrediction.Multiply(fHelper->FDBarEfficiency());
00466     nuPrediction.Multiply(fHelper->FDNuEfficiency());
00467     
00468   
00469     nuPrediction.SetName("NuMus");
00470     barPrediction.SetName("NuMuBars");
00471     
00472     if (fHelper->DoTaus()) {
00473       potentialNuTaus.SetName("NuTaus");
00474       potentialTauBars.SetName("NuTauBars");
00475     }
00476     
00477     wrongSignNuMus.SetName("WrongSign_NuMus");
00478     wrongSignNuBars.SetName("WrongSign_NuMuBars");
00479     
00480     nuNCBackground.SetName("NC_NuMus");
00481     barNCBackground.SetName("NC_NuMuBars");
00482   
00483     fCached = true;
00484   
00485     // If we have precalculated the wrong sign oscillations,
00486     // then we need to recalculate them next time we are given
00487     // the oscilaltion parameters. Reset the flags used to
00488     // control this  
00489     fDoneWsNeutrinos = fDoneWsAntineutrinos = false;
00490 }

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

Implements NuMMRun.

Definition at line 717 of file NuMMRunFC.cxx.

00718 {
00719   // Generate a prediction
00720   const pair<NuMatrixSpectrum,NuMatrixSpectrum> predictions =
00721     this->MakeFDPred(pars);
00722   Double_t like = 0;
00723   // Now, only count a likelihood for components we want - this is just
00724   // a constant offset, but should help speed things up a little.
00725   if (fPredictNeutrinos)
00726   {
00727     like += this->StatsLikelihood(predictions.first.Spectrum(),
00728         ffdNuData->Spectrum());
00729   }
00730   if (fPredictAntiNeutrinos) {
00731     like += this->StatsLikelihood(predictions.second.Spectrum(),
00732         ffdBarData->Spectrum());
00733   }
00734   return like;
00735 }

const pair< NuMatrixSpectrum, NuMatrixSpectrum > NuMMRunFC::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 523 of file NuMMRunFC.cxx.

References NuMatrixSpectrum::Add(), CacheExtrapolation(), NuMMParameters::Dm2(), NuMMParameters::Dm2Bar(), NuMMHelperCPT::DoTaus(), NuMMHelperCPT::FDBarRecoVsTrue(), NuMMHelperCPT::FDNuRecoVsTrue(), NuMMHelperCPT::FDNuTauRecoVsTrue(), NuMMHelperCPT::FDTauBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignNuRecoVsTrue(), NuMatrixSpectrum::InverseOscillate(), NuMatrixSpectrum::Oscillate(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcWrongSign(), PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMMParameters::Sn2(), NuMMParameters::Sn2Bar(), NuMatrixSpectrum::Spectrum(), and NuMatrixSpectrum::TrueToReco().

Referenced by NuFCGridPoint::PredictSpectrum().

00524 {
00525   // Precache extrap, but only if needed
00526   CacheExtrapolation(); 
00527   // Do the wrong sign precalcuation, if it hasn't been done
00528   PreCalcWrongSign(pars);
00529   
00530   // Output the oscillation settings!
00531   if (!fQuietMode) {
00532       //pars.PrintStatus();
00533     cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
00534     << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
00535     << endl;
00536   }
00537   
00539   // For all neutrinos
00540 
00541   // Make copies of the prepared extrapolation variables, so that
00542   // we can alter them locally with the oscillation parameters
00543   NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);
00544   NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
00545   
00546   NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
00547   NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);
00548 
00549   NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
00550   NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
00551   
00552   NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
00553   NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
00554 
00556   // Processes for neutrinos
00557   
00558   if (fPredictNeutrinos)
00559   {  
00560     if (fHelper->DoTaus()) {
00561       // Oscillate the taus
00562       potentialNuTaus.InverseOscillate(pars.Dm2(),pars.Sn2());
00563       potentialNuTaus.TrueToReco(fHelper->FDNuTauRecoVsTrue());
00564     }
00565 
00566     // If we have pre-oscillated the wrong sign, do not do so again
00567     if (!fDoneWsAntineutrinos) {
00568         // Antineutrinos in the neutrino spectrum
00569         wrongSignNuBars.Oscillate(pars.Dm2Bar(),pars.Sn2Bar());
00570         wrongSignNuBars.TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
00571     }
00572 
00573     // Oscillate the Neutrino spectrum!
00574     nuPrediction.Oscillate(pars.Dm2(),pars.Sn2());
00575 
00576     // True to Reco
00577     nuPrediction.TrueToReco(fHelper->FDNuRecoVsTrue());
00578 
00579     //Add in backgrounds
00580     nuPrediction.Add(wrongSignNuBars);
00581     nuPrediction.Add(nuNCBackground);
00582     if (fHelper->DoTaus()) nuPrediction.Add(potentialNuTaus);
00583   } else {
00584       // Scale the histogram to zero, so as not to confuse people
00585       // if they look at the spectrum with neutrinos turned off
00586       nuPrediction.Spectrum()->Scale(0);
00587   }
00588   
00590   // Processes for Antineutrinos
00591   
00592   if (fPredictAntiNeutrinos)
00593   {
00594       if (fHelper->DoTaus()) {
00595         // Oscillate the taubars
00596         potentialTauBars.InverseOscillate(pars.Dm2Bar(),pars.Sn2Bar());
00597         potentialTauBars.TrueToReco(fHelper->FDTauBarRecoVsTrue());
00598       }
00599 
00600       // Only oscillate the wrong sign if it hasn't been done already
00601       if (!fDoneWsNeutrinos) {
00602           // Oscillate the wrong sign component
00603           // Neutrinos for the antineutrino spectrum
00604           wrongSignNuMus.Oscillate(pars.Dm2(),pars.Sn2());
00605           wrongSignNuMus.TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
00606       }
00607       // Oscillate the antineutrino spectrum!
00608       barPrediction.Oscillate(pars.Dm2Bar(),pars.Sn2Bar());
00609 
00610       // True to reco
00611      barPrediction.TrueToReco(fHelper->FDBarRecoVsTrue());
00612       
00613       // Add in backgrounds
00614       barPrediction.Add(wrongSignNuMus);
00615       barPrediction.Add(barNCBackground);
00616       if (fHelper->DoTaus()) barPrediction.Add(potentialTauBars);
00617   } else {
00618       // Scale the histogram to zero, so as not to confuse people
00619       barPrediction.Spectrum()->Scale(0);
00620   }
00621   
00622   // Return the two predictions, as a pair
00623   pair<NuMatrixSpectrum,NuMatrixSpectrum>
00624     predictions(nuPrediction,barPrediction);
00625   return predictions;
00626 }

void NuMMRunFC::PreCalcWrongSign (  const NuMMParameters &  pars  )  [private]
 

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.

Definition at line 494 of file NuMMRunFC.cxx.

References NuMMParameters::Dm2(), NuMMParameters::Dm2Bar(), fDoneWsAntineutrinos, fDoneWsNeutrinos, NuMMHelperCPT::FDWrongSignBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignNuRecoVsTrue(), NuMatrixSpectrum::Oscillate(), PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMMParameters::Sn2(), NuMMParameters::Sn2Bar(), and NuMatrixSpectrum::TrueToReco().

Referenced by MakeFDPred().

00495 {
00496     // Precalculate the wrong sign, if we have disabled predictions
00497     // for that class, and it hasn't been done already. This should only
00498     // be done once, unless of course the user does something strange like
00499     // turning on neutrino prediction in the middle of an extrapolation.
00500     if(!fDoneWsNeutrinos) {
00501         if (!fPredictNeutrinos)
00502         {
00503             if (!fQuietMode) cout << "Neutrino prediction off: Precalculating wrong sign oscillation." << endl;
00504             PreCalcwrongSignNuMus->Oscillate(pars.Dm2(),pars.Sn2());
00505             PreCalcwrongSignNuMus->TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
00506             fDoneWsNeutrinos = true;
00507         }
00508     }
00509     if(!fPredictAntiNeutrinos) {
00510         if (!fDoneWsAntineutrinos)
00511         {
00512             if (!fQuietMode) cout << "Antineutrino prediction off: Precalculating wrong sign oscillation." << endl;
00513             PreCalcwrongSignNuBars->Oscillate(pars.Dm2Bar(),pars.Sn2Bar());
00514             PreCalcwrongSignNuBars->TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
00515             fDoneWsAntineutrinos = true;
00516         }
00517     }
00518 }

void NuMMRunFC::PredictNuBars (  Bool_t  predict  )  [inline]
 

Will the antineutrino prediction be calculated?

Definition at line 44 of file NuMMRunFC.h.

References CacheExtrapolation(), and fPredictAntiNeutrinos.

00044                                      {
00045       fPredictAntiNeutrinos = predict;
00046       if(fDoneWsAntineutrinos) CacheExtrapolation();
00047   }

void NuMMRunFC::PredictNus (  Bool_t  predict  )  [inline]
 

Will the neutrino prediction be calculated?

Definition at line 39 of file NuMMRunFC.h.

References CacheExtrapolation(), and fPredictNeutrinos.

Referenced by NuFCFitter::NuFCFitter().

00039                                   {
00040       fPredictNeutrinos = predict;
00041       if(fDoneWsNeutrinos) CacheExtrapolation();
00042   }

void NuMMRunFC::ResetCache (   )  [private]
 

Definition at line 137 of file NuMMRunFC.cxx.

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

Referenced by CacheExtrapolation(), and ~NuMMRunFC().

00138 {
00139   // delete the precalculated MM spectra we previously created
00140   if (PreCalcnuPrediction)    delete PreCalcnuPrediction;
00141   if (PreCalcbarPrediction)   delete PreCalcbarPrediction;
00142   
00143   if (PreCalcpotentialNuTaus) delete PreCalcpotentialNuTaus; 
00144   if (PreCalcpotentialTauBars)delete PreCalcpotentialTauBars; 
00145   
00146   if (PreCalcnuNCBackground)  delete PreCalcnuNCBackground; 
00147   if (PreCalcbarNCBackground) delete PreCalcbarNCBackground; 
00148   
00149   if (PreCalcwrongSignNuMus)  delete PreCalcwrongSignNuMus; 
00150   if (PreCalcwrongSignNuBars) delete PreCalcwrongSignNuBars; 
00151   
00152   PreCalcnuPrediction    = PreCalcbarPrediction    = 0;
00153   PreCalcpotentialNuTaus = PreCalcpotentialTauBars = 0;
00154   PreCalcnuNCBackground  = PreCalcbarNCBackground  = 0;
00155   PreCalcwrongSignNuMus  = PreCalcwrongSignNuBars  = 0;
00156   
00157   fCached = false;
00158 }

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

Definition at line 632 of file NuMMRunFC.cxx.

References CacheExtrapolation(), NuMMParameters::Dm2(), NuMMParameters::Dm2Bar(), fDoneWsNeutrinos, NuMatrixSpectrum::InverseOscillate(), Sample::kAppearedPQ, MSG, NuMatrixSpectrum::Oscillate(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, s(), NuMatrixSpectrum::SetName(), NuMMParameters::Sn2(), NuMMParameters::Sn2Bar(), and NuMatrixSpectrum::Spectrum().

00633 {
00634   // Precache extrap, but only if needed
00635   CacheExtrapolation(); 
00636 
00637   // Output the oscillation settings!
00638   if (!fQuietMode) {
00639     cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
00640     << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
00641     << endl;
00642   }
00643   
00644   if (fDoneWsNeutrinos || fDoneWsAntineutrinos) {
00645     MSG("NuMMRunFC",Msg::kError) << "Already True-To-Recoed the wrong signs.  Cannot precalculate the wrong-signs for event-by-event.  Bailing." << endl;
00646     MSG("NuMMRunFC",Msg::kFatal) << "Already True-To-Recoed the wrong signs.  Cannot precalculate the wrong-signs for event-by-event.  Bailing." << endl;
00647   } 
00648   
00649   // No appeared spectrum for oscillations
00650   if (s == kAppearedPQ || s == kAppearedNQ) {
00651     NuMatrixSpectrum blank(*PreCalcnuPrediction);
00652     blank.SetName("Blank");
00653     blank.Spectrum()->Scale(0);
00654     return blank;    
00655   }
00656   
00657   // Request NQ spectrum, but no NuBar Predictions OR
00658   // Request PQ spectrum, but no NuMu Predictions
00659   if ( (s < 0 && !fPredictNeutrinos) || 
00660       (s > 0 && !fPredictAntiNeutrinos) ) {
00661     NuMatrixSpectrum blank(*PreCalcnuPrediction);
00662     blank.SetName("Blank");
00663     blank.Spectrum()->Scale(0);
00664     return blank;
00665   }
00666   
00667   if (s == kSignalPQ) {
00668     NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
00669     barPrediction.Oscillate(pars.Dm2Bar(),pars.Sn2Bar());
00670     return barPrediction;
00671   }
00672   else if (s == kSignalNQ) {
00673     NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);  
00674     nuPrediction.Oscillate(pars.Dm2(),pars.Sn2());
00675     return nuPrediction;
00676   }
00677   else if (s == kWrongSignPQ) {
00678     NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
00679     wrongSignNuMus.Oscillate(pars.Dm2(),pars.Sn2());
00680     return wrongSignNuMus;
00681   }
00682   else if (s == kWrongSignNQ) {
00683     NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
00684     wrongSignNuBars.Oscillate(pars.Dm2Bar(),pars.Sn2Bar());
00685     return wrongSignNuBars;
00686   }  
00687   else if (s == kNCPQ) {
00688     NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
00689     return barNCBackground;
00690   }
00691   else if (s == kNCNQ) {
00692     NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
00693     return nuNCBackground;
00694   }
00695   else if (s == kTauPQ) {
00696     NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);
00697     potentialTauBars.InverseOscillate(pars.Dm2Bar(),pars.Sn2Bar());
00698     return potentialTauBars;
00699   }
00700   else if (s == kTauNQ) {
00701     NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
00702     potentialNuTaus.InverseOscillate(pars.Dm2(),pars.Sn2());
00703     return potentialNuTaus;
00704   }
00705   else {
00706     MSG("NuMMRunTransitions",Msg::kWarning) << "Requested unknown prediction #" << s << ", returning blank." << endl;
00707     NuMatrixSpectrum blank(*PreCalcnuPrediction);
00708     blank.SetName("Blank");
00709     blank.Spectrum()->Scale(0);
00710     return blank;
00711   }
00712 }

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

Implements NuMMRun.

Definition at line 163 of file NuMMRunFC.cxx.

References NuMatrixSpectrum::Add(), NuMMParameters::Dm2(), NuMMParameters::Dm2Bar(), NuMMHelperCPT::DoTaus(), NuMMHelperCPT::FDBarRecoVsTrue(), NuMMHelperCPT::FDNuRecoVsTrue(), NuMMHelperCPT::FDNuTauRecoVsTrue(), NuMMHelperCPT::FDTauBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignBarRecoVsTrue(), NuMMHelperCPT::FDWrongSignNuRecoVsTrue(), NuMatrixSpectrum::Integral(), NuMatrixSpectrum::InverseOscillate(), NuMatrixSpectrum::Oscillate(), PreCalcbarNCBackground, PreCalcbarPrediction, PreCalcnuNCBackground, PreCalcnuPrediction, PreCalcpotentialNuTaus, PreCalcpotentialTauBars, PreCalcwrongSignNuBars, PreCalcwrongSignNuMus, NuMatrixSpectrum::SetName(), NuMatrixSpectrum::SetTitle(), NuMMParameters::Sn2(), NuMMParameters::Sn2Bar(), NuMatrixSpectrum::Spectrum(), and NuMatrixSpectrum::TrueToReco().

00164 {    
00165   //Set up a vector to push the histograms into.
00166   vector<TH1D> vHistos;
00167 
00168   //Put the ND data in the vector:
00169   TH1D hNDNuData(*(fndNuData->Spectrum()));
00170   hNDNuData.SetName("ndDataNQ");
00171   hNDNuData.SetTitle("ndDataNQ");
00172   vHistos.push_back(*(new TH1D(hNDNuData)));
00173   TH1D hNDBarData(*(fndBarData->Spectrum()));
00174   hNDBarData.SetName("ndDataPQ");
00175   hNDBarData.SetTitle("ndDataPQ");
00176   vHistos.push_back(*(new TH1D(hNDBarData)));
00177 
00178   if (!fQuietMode) {
00179   cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
00180      << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
00181      << endl;
00182   }
00183 
00184   // Make copies of the prepared extrapolation variables
00185   NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);
00186   NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
00187   
00188   NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
00189   NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);
00190 
00191   NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
00192   NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
00193   
00194   NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
00195   NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
00196   
00197   cout << "NC Integral: " << barNCBackground.Spectrum()->Integral() << endl;
00198 
00199 
00200 
00201 // 
00202 //   //Add in backgrounds
00203 //   nuPrediction.Add(wrongSignNuBars);
00204 //   barPrediction.Add(wrongSignNuMus);
00205 //   nuPrediction.Add(nuNCBackground);
00206 //   nuPrediction.Add(potentialNuTaus);
00207 //   barPrediction.Add(barNCBackground);
00208 //   barPrediction.Add(potentialTauBars);
00209   
00211   // Processes for neutrinos
00212   
00213   if (fPredictNeutrinos)
00214   {  
00215     // Oscillate the taus
00216     if (fHelper->DoTaus()) {
00217       potentialNuTaus.InverseOscillate(pars.Dm2(),pars.Sn2());
00218     
00219       // Write out the true tau spectra
00220       TH1D hFDTausNuMu(*(potentialNuTaus.Spectrum()));
00221       hFDTausNuMu.SetName("fdTausNuMu");
00222       vHistos.push_back(hFDTausNuMu);
00223       
00224       potentialNuTaus.TrueToReco(fHelper->FDNuTauRecoVsTrue());
00225     }
00226 
00227     // Antineutrinos in the neutrino spectrum
00228     if (!fDoneWsAntineutrinos) wrongSignNuBars.Oscillate(pars.Dm2Bar(),pars.Sn2Bar());
00229 
00230     // Now convert wrong sign to reco
00231     if (!fDoneWsAntineutrinos) wrongSignNuBars.TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
00232     
00233     // Write out the true wrong sign components
00234     TH1D hFDWrongSignNQ(*(wrongSignNuBars.Spectrum()));
00235     hFDWrongSignNQ.SetName("fdWrongSignNQ");
00236     vHistos.push_back(hFDWrongSignNQ);
00237     
00238     // Oscillation and efficiency for the Neutrino spectrum
00239     nuPrediction.Oscillate(pars.Dm2(),pars.Sn2());
00240 //    nuPrediction.Multiply(fHelper->FDNuEfficiency());
00241 
00242     // Write out the true spectra for the prediction components
00243     // before we add in backgrounds
00244     TH1D hFDNoBackTrueNQ(*(nuPrediction.Spectrum()));
00245     hFDNoBackTrueNQ.SetName("fdBasePredictionNuMus");
00246     vHistos.push_back(hFDNoBackTrueNQ);
00247 
00248     // True to Reco
00249     nuPrediction.TrueToReco(fHelper->FDNuRecoVsTrue());
00250 
00251     // Dump out the reco spectrum before adding in the backgrounds
00252     TH1D hFDNoBackNQ(*(nuPrediction.Spectrum()));
00253     hFDNoBackNQ.SetName("fdBasePredictionNQ");
00254     vHistos.push_back(hFDNoBackNQ);
00255 
00256     //Add in backgrounds
00257     nuPrediction.Add(wrongSignNuBars);
00258     nuPrediction.Add(nuNCBackground);
00259     if (fHelper->DoTaus()) nuPrediction.Add(potentialNuTaus);
00260     
00261     //Put the other componants of the predictions in the vector
00262     TH1D hFDPredictionNQ(*(nuPrediction.Spectrum()));
00263     hFDPredictionNQ.SetName("fdPredictionNQ");
00264     vHistos.push_back(hFDPredictionNQ);
00265 
00266     TH1D hFDNCNQ(*(nuNCBackground.Spectrum()));
00267     hFDNCNQ.SetName("fdNCNQ");
00268     vHistos.push_back(hFDNCNQ);
00269 
00270     if (fHelper->DoTaus()) {
00271       TH1D hFDTausNQ(*(potentialNuTaus.Spectrum()));
00272       hFDTausNQ.SetName("fdTausNQ");
00273       vHistos.push_back(hFDTausNQ);
00274     }
00275     
00276     TH1D hFDDataNQ(*(ffdNuData->Spectrum()));
00277     hFDDataNQ.SetName("fdDataNQ");
00278     vHistos.push_back(hFDDataNQ);
00279     
00280   } else {
00281       // Scale the histogram to zero, so as not to confuse people
00282       nuPrediction.Spectrum()->Scale(0);
00283   }
00284   
00286   // Processes for Antineutrinos
00287   
00288   if (fPredictAntiNeutrinos)
00289   {
00290     if (fHelper->DoTaus()) {
00291       // Oscillate the taubars
00292       potentialTauBars.InverseOscillate(pars.Dm2Bar(),pars.Sn2Bar());
00293       // Write out the True Tau Spectrum
00294       TH1D hFDTausNuBar(*(potentialTauBars.Spectrum()));
00295       hFDTausNuBar.SetName("fdTausNuBar");
00296       vHistos.push_back(hFDTausNuBar);
00297       // Convert taus to reco energy
00298       potentialTauBars.TrueToReco(fHelper->FDTauBarRecoVsTrue());
00299     }
00300     // Oscillate the wrong sign component
00301     // Neutrinos for the antineutrino spectrum
00302     if (!fDoneWsNeutrinos) wrongSignNuMus.Oscillate(pars.Dm2(),pars.Sn2());
00303 
00304     // Now, convert wrong sign to reco energy
00305     if (!fDoneWsNeutrinos) wrongSignNuMus.TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
00306     
00307     // write out the true wrong sign spectra
00308     TH1D hFDWrongSignPQ(*(wrongSignNuMus.Spectrum()));
00309     hFDWrongSignPQ.SetName("fdWrongSignPQ");
00310     vHistos.push_back(hFDWrongSignPQ);
00311     
00312     //Oscillation and efficiency for the antineutrino spectrum
00313     barPrediction.Oscillate(pars.Dm2Bar(),pars.Sn2Bar());
00314 
00315     // Write out the true antineutrino spectrum, without backgrounds
00316     TH1D hFDNoBackTruePQ(*(barPrediction.Spectrum()));
00317     hFDNoBackTruePQ.SetName("fdBasePredictionNuBars");
00318     vHistos.push_back(hFDNoBackTruePQ);
00319 
00320     //True to reco
00321     barPrediction.TrueToReco(fHelper->FDBarRecoVsTrue());
00322 
00323     // Antineutrino reco spectrum, before backgrounds
00324     TH1D hFDNoBackPQ(*(barPrediction.Spectrum()));
00325     hFDNoBackPQ.SetName("fdBasePredictionPQ");
00326     vHistos.push_back(hFDNoBackPQ);
00327 
00328     //Add in backgrounds
00329     barPrediction.Add(wrongSignNuMus);
00330     barPrediction.Add(barNCBackground);
00331     if (fHelper->DoTaus()) barPrediction.Add(potentialTauBars);
00332     
00333     TH1D hFDPredictionPQ(*(barPrediction.Spectrum()));
00334     hFDPredictionPQ.SetName("fdPredictionPQ");
00335     vHistos.push_back(hFDPredictionPQ);
00336 
00337     TH1D hFDNCPQ(*(barNCBackground.Spectrum()));
00338     hFDNCPQ.SetName("fdNCPQ");
00339     vHistos.push_back(hFDNCPQ);
00340 
00341     if (fHelper->DoTaus()) {
00342       TH1D hFDTausPQ(*(potentialTauBars.Spectrum()));
00343       hFDTausPQ.SetName("fdTausPQ");
00344       vHistos.push_back(hFDTausPQ);
00345     }
00346 
00347     TH1D hFDDataPQ(*(ffdBarData->Spectrum()));
00348     hFDDataPQ.SetName("fdDataPQ");
00349     vHistos.push_back(hFDDataPQ);
00350     
00351   } else {
00352       // Scale the histogram to zero, so as not to confuse people
00353       barPrediction.Spectrum()->Scale(0);
00354   }
00355 
00356   return vHistos;
00357 }

Member Data Documentation

Bool_t NuMMRunFC::fDoneWsAntineutrinos [private]
 

Flags to remember if the wrong sign has been precalculated.

Definition at line 95 of file NuMMRunFC.h.

Referenced by CacheExtrapolation(), NuMMRunFC(), and PreCalcWrongSign().

Bool_t NuMMRunFC::fDoneWsNeutrinos [private]
 

Flags to remember if the wrong sign has been precalculated.

Definition at line 95 of file NuMMRunFC.h.

Referenced by CacheExtrapolation(), NuMMRunFC(), PreCalcWrongSign(), and TrueComponents().

Bool_t NuMMRunFC::fPredictAntiNeutrinos [private]
 

Controls antineutrino component of prediction.

Definition at line 92 of file NuMMRunFC.h.

Referenced by NuMMRunFC(), and PredictNuBars().

Bool_t NuMMRunFC::fPredictNeutrinos [private]
 

Controls neutrino component of prediction.

Definition at line 90 of file NuMMRunFC.h.

Referenced by NuMMRunFC(), and PredictNus().

NuMatrixSpectrum* NuMMRunFC::PreCalcbarNCBackground [private]
 

Definition at line 81 of file NuMMRunFC.h.

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

NuMatrixSpectrum* NuMMRunFC::PreCalcbarPrediction [private]
 

Definition at line 72 of file NuMMRunFC.h.

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

NuMatrixSpectrum* NuMMRunFC::PreCalcnuNCBackground [private]
 

Definition at line 80 of file NuMMRunFC.h.

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

NuMatrixSpectrum* NuMMRunFC::PreCalcnuPrediction [private]
 

Definition at line 71 of file NuMMRunFC.h.

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

NuMatrixSpectrum* NuMMRunFC::PreCalcpotentialNuTaus [private]
 

Definition at line 76 of file NuMMRunFC.h.

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

NuMatrixSpectrum* NuMMRunFC::PreCalcpotentialTauBars [private]
 

Definition at line 77 of file NuMMRunFC.h.

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

NuMatrixSpectrum* NuMMRunFC::PreCalcwrongSignNuBars [private]
 

Definition at line 87 of file NuMMRunFC.h.

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

NuMatrixSpectrum* NuMMRunFC::PreCalcwrongSignNuMus [private]
 

Definition at line 86 of file NuMMRunFC.h.

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

The documentation for this class was generated from the following files:
Generated on Mon Feb 15 11:09:54 2010 for loon by  doxygen 1.3.9.1