NuMMRunFCNSINubar Class Reference

#include <NuMMRunFCNSINubar.h>

Inheritance diagram for NuMMRunFCNSINubar:

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< NuMatrix >	GetNDData (void) const
	Returns the ND data used in extrapolation.
virtual std::auto_ptr< NuMatrix >	GetFDData (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)
NuMMRunFCNSINubar &	operator= (const NuMMRunFCNSINubar &rhs)
	Disallow assignment: This is broken, so don't let people do it.
void	CacheExtrapolation (void)
Private Attributes
NuMatrixSpectrum *	PreCalcnuPrediction
NuMatrixSpectrum *	PreCalcbarPrediction
NuMatrixSpectrum *	PreCalcpotentialNuTaus
NuMatrixSpectrum *	PreCalcpotentialTauBars
NuMatrixSpectrum *	PreCalcnuNCBackground
NuMatrixSpectrum *	PreCalcbarNCBackground
NuMatrixSpectrum *	PreCalcwrongSignNuMus
NuMatrixSpectrum *	PreCalcwrongSignNuBars
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.

  : NuMMRunNuBar()
{
  // Duplicate this test here, as we try to use the helper before moving to init
  if (!helper) {
    MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for helper" << endl;
    assert(helper);
  }
  
  // We haven't been passed a FD histogram yet, but we know what the binning
  // will be because we know the algorithm.
  assert(helper->FDNuPurity());
  TH1D hBlank(*reinterpret_cast<const TH1D*>(helper->FDNuPurity()));
  hBlank.SetNameTitle("herror", "Blank default FD data: Something went wrong");

  NuMatrixSpectrum *tmpNu = new NuMatrixSpectrum(hBlank, pot);
  NuMatrixSpectrum *tmpBar = new NuMatrixSpectrum(hBlank, pot);
  Init(helper, ndNuData, ndBarData, tmpNu, tmpBar);
  // Delete these temporary histograms - they should have been copied by the function
  delete tmpNu;
  delete tmpBar;
}

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

                   : NuMMRunNuBar()
{
  Init(helper, ndNuData, ndBarData, fdNuData, fdBarData);
}

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.

                                                                 : NuMMRunNuBar(old)
{
  // Copy all the old histograms
  fndNuData =  new NuMatrixSpectrum(*old.fndNuData);
  fndBarData = new NuMatrixSpectrum(*old.fndBarData);
  ffdNuData =  new NuMatrixSpectrum(*old.ffdNuData);
  ffdBarData = new NuMatrixSpectrum(*old.ffdBarData);

  fHelper = old.fHelper;
  
  // Blank out all the Precache variables before reassignment
  PreCalcnuPrediction   = PreCalcbarPrediction      = 0;
  PreCalcpotentialNuTaus= PreCalcpotentialTauBars   = 0;
  PreCalcnuNCBackground = PreCalcbarNCBackground    = 0;
  PreCalcwrongSignNuMus = PreCalcwrongSignNuBars    = 0;
    
  // Make copies of all the precalculations frmo the old runner
  if (old.PreCalcnuPrediction)
    PreCalcnuPrediction = new NuMatrixSpectrum(*old.PreCalcnuPrediction);
  if (old.PreCalcbarPrediction)
    PreCalcbarPrediction = new NuMatrixSpectrum(*old.PreCalcbarPrediction);
  if (old.PreCalcpotentialNuTaus)
    PreCalcpotentialNuTaus = new NuMatrixSpectrum(*old.PreCalcpotentialNuTaus);
  if (old.PreCalcpotentialTauBars)
    PreCalcpotentialTauBars = new NuMatrixSpectrum(*old.PreCalcpotentialTauBars);
  
  if (old.PreCalcnuNCBackground)
    PreCalcnuNCBackground = new NuMatrixSpectrum(*old.PreCalcnuNCBackground);
  if (old.PreCalcbarNCBackground)
    PreCalcbarNCBackground = new NuMatrixSpectrum(*old.PreCalcbarNCBackground);

  if (old.PreCalcwrongSignNuMus)
    PreCalcwrongSignNuMus = new NuMatrixSpectrum(*old.PreCalcwrongSignNuMus);
  if (old.PreCalcwrongSignNuBars)
    PreCalcwrongSignNuBars = new NuMatrixSpectrum(*old.PreCalcwrongSignNuBars);
  
  fPredictNeutrinos = old.fPredictNeutrinos;
  fPredictAntiNeutrinos = old.fPredictAntiNeutrinos;
  fLinearInterpolation = old.fLinearInterpolation;  
  
  // Set the wrong sign to false however - this copy may want different
  // oscillation parameters!
  fDoneWsNeutrinos = fDoneWsAntineutrinos = false;
}

NuMMRunFCNSINubar::~NuMMRunFCNSINubar

(

)

Definition at line 216 of file NuMMRunFCNSINubar.cxx.

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

{
  ResetCache();
  
  // We now take copies of the data histograms - clean them up
  if (fndNuData)  delete fndNuData;   fndNuData   = 0;
  if (fndBarData) delete fndBarData;  fndBarData  = 0;
  if (ffdNuData)  delete ffdNuData;   ffdNuData   = 0;
  if (ffdBarData) delete ffdBarData;  ffdBarData  = 0;
}

---

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

{
    // Only cache once.
    if (fCached) return;
  
    ResetCache();
  
    // Disable this output for now - this process should be fast anyway!
    // if (!fQuietMode)
    //     cout << "Pre-calculating static extrapolation variables..." << endl;
    
    // Caching variables, to reduce the workload of each step of the fitter
    // Initialise these the way they would be before
    PreCalcnuPrediction = new NuMatrixSpectrum(*fndNuData);
    PreCalcbarPrediction = new NuMatrixSpectrum(*fndBarData);
    
    // Be lazy and just alias the pointers to references so can keep
    // the code the same
    NuMatrixSpectrum &nuPrediction = *PreCalcnuPrediction;
    NuMatrixSpectrum &barPrediction = *PreCalcbarPrediction;
    
    // Now we have prepared the extrapolation variables, calculate them
    // Get the neutrinos to ND Flux x Xsec
    nuPrediction.Multiply(fHelper->NDNuPurity());
    nuPrediction.RecoToTrue(fHelper->NDNuRecoVsTrue());
    nuPrediction.Divide(fHelper->NDNuEfficiency());
    nuPrediction.Divide(fndNuData->GetPOT());
    nuPrediction.Divide(fNDFidMass);

    // Get the antineutrinos to ND Flux x Xsec
    barPrediction.Multiply(fHelper->NDBarPurity());
    barPrediction.RecoToTrue(fHelper->NDBarRecoVsTrue());
    barPrediction.Divide(fHelper->NDBarEfficiency());
    barPrediction.Divide(fndBarData->GetPOT());
    barPrediction.Divide(fNDFidMass);
    

    // Create and link to the Tau components, before we include the
    // cross section in the predictions (tau Xsec is different)
    PreCalcpotentialNuTaus = new NuMatrixSpectrum(nuPrediction);
    PreCalcpotentialTauBars = new NuMatrixSpectrum(barPrediction);
    NuMatrixSpectrum &potentialNuTaus = *PreCalcpotentialNuTaus;
    NuMatrixSpectrum &potentialTauBars = *PreCalcpotentialTauBars;

    
    // Get the Neutrinos to the FD
    nuPrediction.ExtrapolateNDToFD(fHelper->NuBeamMatrixNuMuCCXSec());
    nuPrediction.Multiply(fFDFidMass);
    nuPrediction.Multiply(ffdNuData->GetPOT());
    // Reset the spectrum to the new POT
    nuPrediction.ResetPOT(ffdNuData->GetPOT());

    // Get the Antineutrinos to the FD
    barPrediction.ExtrapolateNDToFD(fHelper->BarBeamMatrixNuMuCCXSec());
    barPrediction.Multiply(fFDFidMass);
    barPrediction.Multiply(ffdBarData->GetPOT());
    // Reset the spectrum to the new PoT
    barPrediction.ResetPOT(ffdBarData->GetPOT());


    if (fHelper->DoTaus()) {
        // Get the Neutrinos to the FD
        if (fHelper->NuBeamMatrixTauCCXSec()) {
            potentialNuTaus.ExtrapolateNDToFD(fHelper->NuBeamMatrixTauCCXSec());
            potentialTauBars.ExtrapolateNDToFD(fHelper->BarBeamMatrixTauCCXSec());
        }
        else {
            MAXMSG("NuMMRunFCNSINubar",Msg::kWarning,10) << "Doing tau extrapolation the old way." << endl;
            potentialNuTaus.Divide(fHelper->NuXSecGraph());
            potentialNuTaus.ExtrapolateNDToFD(fHelper->NuBeamMatrix());
            potentialNuTaus.Multiply(fHelper->XSecGraphNuTaus());
            potentialTauBars.Divide(fHelper->BarXSecGraph());
            potentialTauBars.ExtrapolateNDToFD(fHelper->BarBeamMatrix());
            potentialTauBars.Multiply(fHelper->XSecGraphTauBars());
        }
            
        potentialNuTaus.Multiply(fFDFidMass);
        potentialNuTaus.Multiply(ffdNuData->GetPOT());
        // Reset the spectrum to the new PoT
        potentialNuTaus.ResetPOT(ffdNuData->GetPOT());
        potentialNuTaus.Multiply(fHelper->FDNuTauEfficiency());
        
        // Get the Antineutrinos to the FD
        potentialTauBars.Multiply(fFDFidMass);
        potentialTauBars.Multiply(ffdBarData->GetPOT());
        // Reset the spectrum to the new PoT
        potentialTauBars.ResetPOT(ffdBarData->GetPOT());
        potentialTauBars.Multiply(fHelper->FDTauBarEfficiency());
    }
    else {
        PreCalcpotentialNuTaus->Multiply(0.0);
        PreCalcpotentialTauBars->Multiply(0.0);
    }
  
    // Now build the NC Spectrum, after the cross section calculation!
    PreCalcnuNCBackground = new NuMatrixSpectrum(*PreCalcnuPrediction);;
    PreCalcbarNCBackground = new NuMatrixSpectrum(*PreCalcbarPrediction);
    NuMatrixSpectrum &nuNCBackground = *PreCalcnuNCBackground;
    NuMatrixSpectrum &barNCBackground = *PreCalcbarNCBackground;  

    //Get the neutrino NC background
    nuNCBackground.Multiply(fHelper->FDNuEfficiency());
    nuNCBackground.TrueToReco(fHelper->FDNuRecoVsTrue());
    nuNCBackground.Divide(fHelper->FDNuPurity());
    nuNCBackground.Multiply(fHelper->FDNuNCContamination());

    //Get the antineutrino NC background
    barNCBackground.Multiply(fHelper->FDBarEfficiency());
    barNCBackground.TrueToReco(fHelper->FDBarRecoVsTrue());
    barNCBackground.Divide(fHelper->FDBarPurity());
    barNCBackground.Multiply(fHelper->FDBarNCContamination());
    
    // Now build the wrong sign spectrum
    PreCalcwrongSignNuMus = new NuMatrixSpectrum(*PreCalcnuPrediction);
    PreCalcwrongSignNuBars = new NuMatrixSpectrum(*PreCalcbarPrediction);
    NuMatrixSpectrum &wrongSignNuMus = *PreCalcwrongSignNuMus;
    NuMatrixSpectrum &wrongSignNuBars = *PreCalcwrongSignNuBars;
    
    // Do the Neutrino background for the antineutrino spectrum
    wrongSignNuMus.Multiply(fHelper->FDWrongSignNuEfficiency());
    
    // Do the Antineutrino background for the neutrino spectrum
    wrongSignNuBars.Multiply(fHelper->FDWrongSignBarEfficiency());
    
    // Apply the efficiency to the predictions
    barPrediction.Multiply(fHelper->FDBarEfficiency());
    nuPrediction.Multiply(fHelper->FDNuEfficiency());
    
  
    nuPrediction.SetName("NuMus");
    barPrediction.SetName("NuMuBars");
    
    if (fHelper->DoTaus()) {
      potentialNuTaus.SetName("NuTaus");
      potentialTauBars.SetName("NuTauBars");
    }
    
    wrongSignNuMus.SetName("WrongSign_NuMus");
    wrongSignNuBars.SetName("WrongSign_NuMuBars");
    
    nuNCBackground.SetName("NC_NuMus");
    barNCBackground.SetName("NC_NuMuBars");
  
    fCached = true;
  
    // If we have precalculated the wrong sign oscillations,
    // then we need to recalculate them next time we are given
    // the oscilaltion parameters. Reset the flags used to
    // control this  
    fDoneWsNeutrinos = fDoneWsAntineutrinos = false;
}

Double_t NuMMRunFCNSINubar::ComparePredWithData

(

const NuMMParameters &

pars

)

[virtual]

Implements NuMMRun.

Definition at line 854 of file NuMMRunFCNSINubar.cxx.

{
  // Generate a prediction
  const pair<NuMatrixSpectrum,NuMatrixSpectrum> predictions =
    this->MakeFDPred(pars);
  Double_t like = 0;
  // Now, only count a likelihood for components we want - this is just
  // a constant offset, but should help speed things up a little.
  if (fPredictNeutrinos)
  {
    like += this->StatsLikelihood(predictions.first.Spectrum(),
        ffdNuData->Spectrum());
  }
  if (fPredictAntiNeutrinos) {
    like += this->StatsLikelihood(predictions.second.Spectrum(),
        ffdBarData->Spectrum());
  }
  return like;
}

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.

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

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.

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

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

{
  fLinearInterpolation = true;
  fDoneWsNeutrinos = false;
  fDoneWsAntineutrinos = false;  
  fPredictNeutrinos = true;
  fPredictAntiNeutrinos = true;
  
  if (!helper) {
    MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for helper" << endl;
    assert(helper);
  }
  if (!ndNuData) {
    MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for ndNuData" << endl;
    assert(ndNuData);
  }
  if (!ndBarData) {
    MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for ndBarData" << endl;
    assert(ndBarData);
  }
  if (!fdNuData) {
    MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for fdNuData" << endl;
    assert(fdNuData);
  }
  if (!fdBarData) {
    MSG("NuMMRunFCNSINubar",Msg::kError) << "Passed a null pointer for fdBarData" << endl;
    assert(fdBarData);
  }  
  
  
  fndNuData   = new NuMatrixSpectrum(*ndNuData);
  fndBarData  = new NuMatrixSpectrum(*ndBarData);
  ffdNuData   = new NuMatrixSpectrum(*fdNuData);
  ffdBarData  = new NuMatrixSpectrum(*fdBarData);

  fHelper = helper;
  
  // Protect against cases where the FD data is not the same
  // binning as the prediction would be. Use the helper file
  // as a guide to what this should be...
  // Only perform this check if the passed in data has a spectrum
  if (fdNuData->Spectrum()) {
    if (fdNuData->Spectrum()->GetNbinsX() != fHelper->FDNuEfficiency()->GetNbinsX()) {
      MSG("NuMMRunFCNSINubar",Msg::kError) << "Nu Binning Mismatch: fdNuData # bins: " << fdNuData->Spectrum()->GetNbinsX() 
      << " and fHelper # bins: " << fHelper->FDNuEfficiency()->GetNbinsX() << endl;
      assert(fdNuData->Spectrum()->GetNbinsX() == fHelper->FDNuEfficiency()->GetNbinsX());
    }
  }
  if (fdBarData->Spectrum()) {
    if (fdBarData->Spectrum()->GetNbinsX() != fHelper->FDBarEfficiency()->GetNbinsX()) {
      MSG("NuMMRunFCNSINubar",Msg::kError) << "Bar Binning Mismatch: fdNuData # bins: " << fdBarData->Spectrum()->GetNbinsX() 
      << " and fHelper # bins: " << fHelper->FDBarEfficiency()->GetNbinsX() << endl;
      assert(fdBarData->Spectrum()->GetNbinsX() == fHelper->FDBarEfficiency()->GetNbinsX());
    }
  }
  
  // Blank out all the Precache variables
  PreCalcnuPrediction   = PreCalcbarPrediction      = 0;
  PreCalcpotentialNuTaus= PreCalcpotentialTauBars   = 0;
  PreCalcnuNCBackground = PreCalcbarNCBackground    = 0;
  PreCalcwrongSignNuMus = PreCalcwrongSignNuBars    = 0;
  
  // We should now be completely capable of calculating the
  // halfway point of the prediction. Do so now.
  CacheExtrapolation();
}

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

{
  if(fDisappearanceModel == 0) {
    if(fLinearInterpolation)
      nutau.InverseOscillateLinearInterp(pars.Dm2(), pars.Sn2());
    else
      nutau.InverseOscillatePreAveraged(pars.Dm2(), pars.Sn2());
  }
  if(fDisappearanceModel == 1)
    nutau.DecayMuToTau(pars.Dm2(), pars.Sn2(), pars.Alpha());
  if(fDisappearanceModel == 2)
    nutau.InverseDecohere(pars.Dm2(), pars.Sn2(), pars.Mu2());
  if(fDisappearanceModel == 3)
    nutau.InverseOscillateNSI(pars.Dm2(), pars.Sn2(), pars.Epsilon(), 1.0);
}

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

{
  if(fDisappearanceModel == 0) {
    if(fLinearInterpolation)
      nutau.InverseOscillateLinearInterp(pars.Dm2Bar(), pars.Sn2Bar());
    else
      nutau.InverseOscillatePreAveraged(pars.Dm2Bar(), pars.Sn2Bar());
  }
  if(fDisappearanceModel == 1)
    nutau.DecayMuToTau(pars.Dm2Bar(), pars.Sn2Bar(), pars.Alpha());
  if(fDisappearanceModel == 2)
    nutau.InverseDecohere(pars.Dm2Bar(), pars.Sn2Bar(), pars.Mu2());
  if(fDisappearanceModel == 3)
    nutau.InverseOscillateNSI(pars.Dm2Bar(), pars.Sn2Bar(), pars.Epsilon(), -1.0);
}

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

                                           {  
      fLinearInterpolation = predict; 
  }

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

{
  // Precache extrap, but only if needed
  CacheExtrapolation(); 
  
  // Output the oscillation settings!
  if (!fQuietMode) {
      //pars.PrintStatus();
    cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
         << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
         << "; epsilon: "<< pars.Epsilon() << endl;
  }
  
  // For all neutrinos

  // Make copies of the prepared extrapolation variables, so that
  // we can alter them locally with the oscillation parameters
  NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);
  NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
  
  NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
  NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);

  NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
  NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
  
  NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
  NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);

  // Processes for neutrinos
  
  if (fPredictNeutrinos)
  {  
    if (fHelper->DoTaus()) {
      // Oscillate the taus
      InverseOscillateNuTau(potentialNuTaus,pars);
      potentialNuTaus.TrueToReco(fHelper->FDNuTauRecoVsTrue());
    }

    // If we have pre-oscillated the wrong sign, do not do so again
    if (!fDoneWsAntineutrinos) {
        // Antineutrinos in the neutrino spectrum
        OscillateNuBar(wrongSignNuBars,pars);
        wrongSignNuBars.TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
    }

    // Oscillate the Neutrino spectrum!
    OscillateNuMu(nuPrediction,pars);

    // True to Reco
    nuPrediction.TrueToReco(fHelper->FDNuRecoVsTrue());

    //Add in backgrounds
    nuPrediction.Add(wrongSignNuBars);
    nuPrediction.Add(nuNCBackground);
    if (fHelper->DoTaus()) nuPrediction.Add(potentialNuTaus);
  } else {
      // Scale the histogram to zero, so as not to confuse people
      // if they look at the spectrum with neutrinos turned off
      nuPrediction.Spectrum()->Scale(0);
  }
  
  // Processes for Antineutrinos
  
  if (fPredictAntiNeutrinos)
  {
      if (fHelper->DoTaus()) {
        // Oscillate the taubars
        InverseOscillateTauBar(potentialTauBars,pars);
        potentialTauBars.TrueToReco(fHelper->FDTauBarRecoVsTrue());
      }

      // Only oscillate the wrong sign if it hasn't been done already
      if (!fDoneWsNeutrinos) {
          // Oscillate the wrong sign component
          // Neutrinos for the antineutrino spectrum
          OscillateNuMu(wrongSignNuMus,pars);
          wrongSignNuMus.TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
      }
      // Oscillate the antineutrino spectrum!
      OscillateNuBar(barPrediction,pars);

      // True to reco
     barPrediction.TrueToReco(fHelper->FDBarRecoVsTrue());
      
      // Add in backgrounds
      barPrediction.Add(wrongSignNuMus);
      barPrediction.Add(barNCBackground);
      if (fHelper->DoTaus()) barPrediction.Add(potentialTauBars);
  } else {
      // Scale the histogram to zero, so as not to confuse people
      barPrediction.Spectrum()->Scale(0);
  }
  
  // Return the two predictions, as a pair
  pair<NuMatrixSpectrum,NuMatrixSpectrum>
    predictions(nuPrediction,barPrediction);
  return predictions;
}

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

{
  switch(fDisappearanceModel){
  case 0:
    if(fLinearInterpolation)
      numu.OscillateLinearInterp(pars.Dm2Bar(), pars.Sn2Bar());
    else
      numu.OscillatePreAveraged(pars.Dm2Bar(), pars.Sn2Bar());
    return;
  case 1:
    numu.DecayCC(pars.Dm2Bar(), pars.Sn2Bar(), pars.Alpha());
    return;
  case 2:
    numu.Decohere(pars.Dm2Bar(), pars.Sn2Bar(), pars.Mu2());
    return;
  case 3: 
    numu.OscillateNSI(pars.Dm2Bar(), pars.Sn2Bar(), pars.Epsilon(), -1.0);
    return;

  default:
    assert(0 && "Badly configured disappearance model");
  }
}   

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

{
  switch(fDisappearanceModel){
  case 0:
    if(fLinearInterpolation)
      numu.OscillateLinearInterp(pars.Dm2(), pars.Sn2());
    else
      numu.OscillatePreAveraged(pars.Dm2(), pars.Sn2());
    return;
  case 1:
    numu.DecayCC(pars.Dm2(), pars.Sn2(), pars.Alpha());
    return;
  case 2:
    numu.Decohere(pars.Dm2(), pars.Sn2(), pars.Mu2());
    return;
  case 3: 
    numu.OscillateNSI(pars.Dm2(), pars.Sn2(), pars.Epsilon(), 1.0);
    return;
  default:
    assert(0 && "Badly configured disappearance model");
  }
}

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

{
    // Did we change anything in this run?
    Bool_t change = false;
    
    // Precalculate the wrong sign, if we have disabled predictions
    // for that class, and it hasn't been done already. This should only
    // be done once, unless of course the user does something strange like
    // turning on neutrino prediction in the middle of an extrapolation.
    if(!fDoneWsNeutrinos) {
        if (!fPredictNeutrinos)
        {
            change = true;
            if (!fQuietMode) cout << "Neutrino prediction off: Precalculating wrong sign oscillation." << endl;
            OscillateNuMu(*PreCalcwrongSignNuMus,pars);
            PreCalcwrongSignNuMus->TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
            fDoneWsNeutrinos = true;
        }
    }
    if(!fPredictAntiNeutrinos) {
        if (!fDoneWsAntineutrinos)
        {
            change = true;
            if (!fQuietMode) cout << "Antineutrino prediction off: Precalculating wrong sign oscillation." << endl;
            OscillateNuBar(*PreCalcwrongSignNuBars,pars);
            PreCalcwrongSignNuBars->TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
            fDoneWsAntineutrinos = true;
        }
    }
    
    // Return the flag saying if we have changed anything
    return change;
}

virtual Bool_t NuMMRunFCNSINubar::PredictNuBars

(

)

[inline, virtual]

Reimplemented from NuMMRunNuBar.

Definition at line 71 of file NuMMRunFCNSINubar.h.

References NuMMRunNuBar::fPredictAntiNeutrinos.

{ 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.

                                             {
      fPredictAntiNeutrinos = predict;
      if(fDoneWsAntineutrinos) CacheExtrapolation();
  }

virtual Bool_t NuMMRunFCNSINubar::PredictNus

(

)

[inline, virtual]

Reimplemented from NuMMRunNuBar.

Definition at line 70 of file NuMMRunFCNSINubar.h.

References NuMMRunNuBar::fPredictNeutrinos.

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

                                          {
      fPredictNeutrinos = predict;
      if(fDoneWsNeutrinos) CacheExtrapolation();
  }

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

{
  // delete the precalculated MM spectra we previously created
  if (PreCalcnuPrediction)    delete PreCalcnuPrediction;
  if (PreCalcbarPrediction)   delete PreCalcbarPrediction;
  
  if (PreCalcpotentialNuTaus) delete PreCalcpotentialNuTaus; 
  if (PreCalcpotentialTauBars)delete PreCalcpotentialTauBars; 
  
  if (PreCalcnuNCBackground)  delete PreCalcnuNCBackground; 
  if (PreCalcbarNCBackground) delete PreCalcbarNCBackground; 
  
  if (PreCalcwrongSignNuMus)  delete PreCalcwrongSignNuMus; 
  if (PreCalcwrongSignNuBars) delete PreCalcwrongSignNuBars; 
  
  PreCalcnuPrediction    = PreCalcbarPrediction    = 0;
  PreCalcpotentialNuTaus = PreCalcpotentialTauBars = 0;
  PreCalcnuNCBackground  = PreCalcbarNCBackground  = 0;
  PreCalcwrongSignNuMus  = PreCalcwrongSignNuBars  = 0;
  
  fCached = false;
}

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

{
  // Attempt downcast to a CPT object
  const NuMatrixCPT *cpt = dynamic_cast<const NuMatrixCPT*>(&fddata);
  if (!cpt) {
    MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: Have not been passed a CPT matrix object to reset ND Data" << endl;
  }

  // Pointers to temporary storage if we need to convert NuMatrix1D->NuMatrixspectrum
  // This is because we use borrowed pointers normally, but by creating a new NuMatrixSpectrum
  // we become responsible for destroying the objects, and leaking them is not an option.
  auto_ptr<NuMatrixSpectrum> tmpPQ, tmpNQ;
  
  // Extract the NQ and PQ spectra
  const NuMatrixSpectrum *pq = dynamic_cast<const NuMatrixSpectrum*>(cpt->PQ());
  if (!pq) {
    // Try a NuMatrix1D, then convert it to a NuMatrixSpecturm if it is
    const NuMatrix1D *nm1d = dynamic_cast<const NuMatrix1D*>(cpt->PQ());
    if (!nm1d) {
      // Fail if we cannot handle this histogram
      MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: PQ spectrum appears not to be a NuMatrixSpectrum or NuMatrix1D" << endl;
    }
    tmpPQ.reset(nm1d->GetNuMatrixSpectrum().Copy());
    pq = tmpPQ.get();
  }
  
  const NuMatrixSpectrum *nq = dynamic_cast<NuMatrixSpectrum*>(cpt->NQ());
  if (!nq) {
    // Try a NuMatrix1D, then convert it to a NuMatrixSpecturm if it is
    const NuMatrix1D *nm1d = dynamic_cast<const NuMatrix1D*>(cpt->NQ());
    if (!nm1d) {
      // Fail if we cannot handle this histogram
      MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: NQ spectrum appears not to be a NuMatrixSpectrum" << endl;
    }
    tmpNQ.reset(nm1d->GetNuMatrixSpectrum().Copy());
    nq = tmpNQ.get();
  }
  
  // Store the old FD data POT
  Double_t oldPOT = ffdNuData->GetPOT();
  
  // Delete the old spectra, if they exist
  if (ffdNuData) delete ffdNuData; ffdNuData = 0;
  if (ffdBarData) delete ffdBarData; ffdBarData = 0;
  
  // Copy the spectra to this object
  ffdNuData = nq->Copy();
  ffdBarData = pq->Copy();
  
  // If the POT has changed, we need to recache the extrapolation
  if (ffdNuData->GetPOT() != oldPOT)
  {
    // cout << "POT CHANGE: " << oldPOT << " -> " << ffdNuData->GetPOT()
    //   << " = change of " << ffdNuData->GetPOT() - oldPOT << " POT" << endl;
    ResetCache();
    CacheExtrapolation();
  }
}

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

{
  // Attempt downcast to a CPT object
  const NuMatrixCPT *cpt = dynamic_cast<const NuMatrixCPT*>(&nddata);
  if (!cpt) {
    MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: Have not been passed a CPT matrix object to reset ND Data" << endl;
  }
  
  // Extract the NQ and PQ spectra
  const NuMatrixSpectrum *pq = dynamic_cast<NuMatrixSpectrum*>(cpt->PQ());
  if (!pq) {
    MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: PQ spectrum appears not to be a NuMatrixSpectrum" << endl;
  }
  
  const NuMatrixSpectrum *nq = dynamic_cast<NuMatrixSpectrum*>(cpt->NQ());
  if (!nq) {
    MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Error: NQ spectrum appears not to be a NuMatrixSpectrum" << endl;
  }
  
  // Delete the old spectra, if they exist
  if (fndNuData) delete fndNuData; fndNuData = 0;
  if (fndBarData) delete fndBarData; fndBarData = 0;
  
  // Now we have the spectra!
  fndNuData = nq->Copy();
  fndBarData = pq->Copy();
  
  // Recalculate the extrapolation caches
  ResetCache();
  CacheExtrapolation();
}

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

{
  if (fDoneWsNeutrinos || fDoneWsAntineutrinos) {
    MAXMSG("NuMMRunFCNSINubar",Msg::kWarning,10) << "Already True-To-Recoed the wrong signs.  Re-caching -- this may be slow event-by-event." << endl;
    ResetCache();
  }

  CacheExtrapolation(); 
  
  return static_cast<const NuMMRunFCNSINubar *>(this)->TrueComponents(pars, s);
}

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

{
  if (fDoneWsNeutrinos || fDoneWsAntineutrinos) {
    MAXMSG("NuMMRunFCNSINubar",Msg::kWarning,10) << "Already True-To-Recoed the wrong signs.  Re-caching -- this may be slow event-by-event." << endl;
    MSG("NuMMRunFCNSINubar",Msg::kFatal) << "Cannot recache as TrueComponents is now constant" << endl;    
    // ResetCache();
  } 
  
  // Check that we are cached and throw an error otherwise
  if (!fCached) {
    MSG("NuMMRunFCNSINubar",Msg::kError) << "Have not cached extrapolation prior to asking for true components!" << endl;
    assert(fCached);
  }
  
  // Output the oscillation settings!
  if (!fQuietMode) {
    cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
    << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
    << endl;
  }
  
  // No appeared spectrum for oscillations
  if (s == kAppearedPQ || s == kAppearedNQ) {
    NuMatrixSpectrum blank(*PreCalcnuPrediction);
    blank.SetName("Blank");
    blank.Spectrum()->Scale(0);
    return blank;    
  }
  
  // Request NQ spectrum, but no NuBar Predictions OR
  // Request PQ spectrum, but no NuMu Predictions
  if ( (s < 0 && !fPredictNeutrinos) || 
      (s > 0 && !fPredictAntiNeutrinos) ) {
    NuMatrixSpectrum blank(*PreCalcnuPrediction);
    blank.SetName("Blank");
    blank.Spectrum()->Scale(0);
    return blank;
  }
  
  if (s == kSignalPQ) {
    NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
    OscillateNuBar(barPrediction,pars);
    return barPrediction;
  }
  else if (s == kSignalNQ) {
    NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);  
    OscillateNuMu(nuPrediction,pars);
    return nuPrediction;
  }
  else if (s == kWrongSignPQ) {
    NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
    OscillateNuMu(wrongSignNuMus,pars);
    return wrongSignNuMus;
  }
  else if (s == kWrongSignNQ) {
    NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
    OscillateNuBar(wrongSignNuBars,pars);
    return wrongSignNuBars;
  }  
  else if (s == kNCPQ) {
    NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
    return barNCBackground;
  }
  else if (s == kNCNQ) {
    NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
    return nuNCBackground;
  }
  else if (s == kTauPQ) {
    NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);
    InverseOscillateTauBar(potentialTauBars,pars);
    return potentialTauBars;
  }
  else if (s == kTauNQ) {
    NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
    InverseOscillateNuTau(potentialNuTaus,pars);
    return potentialNuTaus;
  }
  else {
    MSG("NuMMRunTransitions",Msg::kWarning) << "Requested unknown prediction #" << s << ", returning blank." << endl;
    NuMatrixSpectrum blank(*PreCalcnuPrediction);
    blank.SetName("Blank");
    blank.Spectrum()->Scale(0);
    return blank;
  }
}

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

{    
  //Set up a vector to push the histograms into.
  vector<TH1D> vHistos;

  //Put the ND data in the vector:
  TH1D hNDNuData(*(fndNuData->Spectrum()));
  hNDNuData.SetName("ndDataNQ");
  hNDNuData.SetTitle("ndDataNQ");
  vHistos.push_back(*(new TH1D(hNDNuData)));
  TH1D hNDBarData(*(fndBarData->Spectrum()));
  hNDBarData.SetName("ndDataPQ");
  hNDBarData.SetTitle("ndDataPQ");
  vHistos.push_back(*(new TH1D(hNDBarData)));

  if (!fQuietMode) {
  cout << "sn2: " << pars.Sn2() << "; dm2: " << pars.Dm2() 
     << "; sn2bar: " << pars.Sn2Bar() << "; dm2bar: " << pars.Dm2Bar()
     << endl;
  }

  // Make copies of the prepared extrapolation variables
  NuMatrixSpectrum nuPrediction(*PreCalcnuPrediction);
  NuMatrixSpectrum barPrediction(*PreCalcbarPrediction);
  
  NuMatrixSpectrum potentialNuTaus(*PreCalcpotentialNuTaus);
  NuMatrixSpectrum potentialTauBars(*PreCalcpotentialTauBars);

  NuMatrixSpectrum nuNCBackground(*PreCalcnuNCBackground);
  NuMatrixSpectrum barNCBackground(*PreCalcbarNCBackground);
  
  NuMatrixSpectrum wrongSignNuMus(*PreCalcwrongSignNuMus);
  NuMatrixSpectrum wrongSignNuBars(*PreCalcwrongSignNuBars);
  
  cout << "NC Integral: " << barNCBackground.Spectrum()->Integral() << endl;



// 
//   //Add in backgrounds
//   nuPrediction.Add(wrongSignNuBars);
//   barPrediction.Add(wrongSignNuMus);
//   nuPrediction.Add(nuNCBackground);
//   nuPrediction.Add(potentialNuTaus);
//   barPrediction.Add(barNCBackground);
//   barPrediction.Add(potentialTauBars);
  
  // Processes for neutrinos
  
  if (fPredictNeutrinos)
  {  
    // Oscillate the taus
    if (fHelper->DoTaus()) {
      InverseOscillateNuTau(potentialNuTaus,pars);
    
      // Write out the true tau spectra
      TH1D hFDTausNuMu(*(potentialNuTaus.Spectrum()));
      hFDTausNuMu.SetName("fdTausNuMu");
      vHistos.push_back(hFDTausNuMu);
      
      potentialNuTaus.TrueToReco(fHelper->FDNuTauRecoVsTrue());
    }

    // Antineutrinos in the neutrino spectrum
    if (!fDoneWsAntineutrinos) OscillateNuBar(wrongSignNuBars,pars);

    // Now convert wrong sign to reco
    if (!fDoneWsAntineutrinos) wrongSignNuBars.TrueToReco(fHelper->FDWrongSignBarRecoVsTrue());
    
    // Write out the true wrong sign components
    TH1D hFDWrongSignNQ(*(wrongSignNuBars.Spectrum()));
    hFDWrongSignNQ.SetName("fdWrongSignNQ");
    vHistos.push_back(hFDWrongSignNQ);
    
    // Oscillation and efficiency for the Neutrino spectrum
    OscillateNuMu(nuPrediction,pars);
//    nuPrediction.Multiply(fHelper->FDNuEfficiency());

    // Write out the true spectra for the prediction components
    // before we add in backgrounds
    TH1D hFDNoBackTrueNQ(*(nuPrediction.Spectrum()));
    hFDNoBackTrueNQ.SetName("fdBasePredictionNuMus");
    vHistos.push_back(hFDNoBackTrueNQ);

    // True to Reco
    nuPrediction.TrueToReco(fHelper->FDNuRecoVsTrue());

    // Dump out the reco spectrum before adding in the backgrounds
    TH1D hFDNoBackNQ(*(nuPrediction.Spectrum()));
    hFDNoBackNQ.SetName("fdBasePredictionNQ");
    vHistos.push_back(hFDNoBackNQ);

    //Add in backgrounds
    nuPrediction.Add(wrongSignNuBars);
    nuPrediction.Add(nuNCBackground);
    if (fHelper->DoTaus()) nuPrediction.Add(potentialNuTaus);
    
    //Put the other componants of the predictions in the vector
    TH1D hFDPredictionNQ(*(nuPrediction.Spectrum()));
    hFDPredictionNQ.SetName("fdPredictionNQ");
    vHistos.push_back(hFDPredictionNQ);

    TH1D hFDNCNQ(*(nuNCBackground.Spectrum()));
    hFDNCNQ.SetName("fdNCNQ");
    vHistos.push_back(hFDNCNQ);

    if (fHelper->DoTaus()) {
      TH1D hFDTausNQ(*(potentialNuTaus.Spectrum()));
      hFDTausNQ.SetName("fdTausNQ");
      vHistos.push_back(hFDTausNQ);
    }
    
    TH1D hFDDataNQ(*(ffdNuData->Spectrum()));
    hFDDataNQ.SetName("fdDataNQ");
    vHistos.push_back(hFDDataNQ);
    
  } else {
      // Scale the histogram to zero, so as not to confuse people
      nuPrediction.Spectrum()->Scale(0);
  }
  
  // Processes for Antineutrinos
  
  if (fPredictAntiNeutrinos)
  {
    if (fHelper->DoTaus()) {
      // Oscillate the taubars
      InverseOscillateTauBar(potentialTauBars,pars);
      // Write out the True Tau Spectrum
      TH1D hFDTausNuBar(*(potentialTauBars.Spectrum()));
      hFDTausNuBar.SetName("fdTausNuBar");
      vHistos.push_back(hFDTausNuBar);
      // Convert taus to reco energy
      potentialTauBars.TrueToReco(fHelper->FDTauBarRecoVsTrue());
    }
    // Oscillate the wrong sign component
    // Neutrinos for the antineutrino spectrum
    if (!fDoneWsNeutrinos) OscillateNuMu(wrongSignNuMus,pars);

    // Now, convert wrong sign to reco energy
    if (!fDoneWsNeutrinos) wrongSignNuMus.TrueToReco(fHelper->FDWrongSignNuRecoVsTrue());
    
    // write out the true wrong sign spectra
    TH1D hFDWrongSignPQ(*(wrongSignNuMus.Spectrum()));
    hFDWrongSignPQ.SetName("fdWrongSignPQ");
    vHistos.push_back(hFDWrongSignPQ);
    
    //Oscillation and efficiency for the antineutrino spectrum
    OscillateNuBar(barPrediction,pars);

    // Write out the true antineutrino spectrum, without backgrounds
    TH1D hFDNoBackTruePQ(*(barPrediction.Spectrum()));
    hFDNoBackTruePQ.SetName("fdBasePredictionNuBars");
    vHistos.push_back(hFDNoBackTruePQ);

    //True to reco
    barPrediction.TrueToReco(fHelper->FDBarRecoVsTrue());

    // Antineutrino reco spectrum, before backgrounds
    TH1D hFDNoBackPQ(*(barPrediction.Spectrum()));
    hFDNoBackPQ.SetName("fdBasePredictionPQ");
    vHistos.push_back(hFDNoBackPQ);

    //Add in backgrounds
    barPrediction.Add(wrongSignNuMus);
    barPrediction.Add(barNCBackground);
    if (fHelper->DoTaus()) barPrediction.Add(potentialTauBars);
    
    TH1D hFDPredictionPQ(*(barPrediction.Spectrum()));
    hFDPredictionPQ.SetName("fdPredictionPQ");
    vHistos.push_back(hFDPredictionPQ);

    TH1D hFDNCPQ(*(barNCBackground.Spectrum()));
    hFDNCPQ.SetName("fdNCPQ");
    vHistos.push_back(hFDNCPQ);

    if (fHelper->DoTaus()) {
      TH1D hFDTausPQ(*(potentialTauBars.Spectrum()));
      hFDTausPQ.SetName("fdTausPQ");
      vHistos.push_back(hFDTausPQ);
    }

    TH1D hFDDataPQ(*(ffdBarData->Spectrum()));
    hFDDataPQ.SetName("fdDataPQ");
    vHistos.push_back(hFDDataPQ);
    
  } else {
      // Scale the histogram to zero, so as not to confuse people
      barPrediction.Spectrum()->Scale(0);
  }

  return vHistos;
}

---

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:

• NuMMRunFCNSINubar.h
• NuMMRunFCNSINubar.cxx

---