#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-11-28/3FlavorAna/Decomp/MichelDecomp.h"

Inheritance diagram for ana::MichelDecomp:

Public Member Functions
	MichelDecomp (SpectrumLoaderBase &NDMCloader, SpectrumLoaderBase &NDdataloader, const HistAxis &axis, const Cut &cut, const IDecomp *nNueEstimate, const SystShifts &shiftMC=kNoShift, const SystShifts &shiftData=kNoShift, const Var &wei=kUnweighted)

	MichelDecomp (SpectrumLoaderBase &NDMCloader, SpectrumLoaderBase &NDdataloader, std::string label, const Binning &bins, const Var &var, const Cut &cut, const IDecomp *nNueEstimate, const SystShifts &shiftMC=kNoShift, const SystShifts &shiftData=kNoShift, const Var &wei=kUnweighted)

	MichelDecomp (Loaders &loaders, const HistAxis &axis, const Cut &cut, const IDecomp *nNueEstimate, const SystShifts &shiftMC=kNoShift, const SystShifts &shiftData=kNoShift, const Var &wei=kUnweighted)

	~MichelDecomp ()

virtual Spectrum	NCTotalComponent () const override

virtual Spectrum	NCComponent () const override

virtual Spectrum	NCAntiComponent () const override

virtual Spectrum	NumuComponent () const override

virtual Spectrum	AntiNumuComponent () const override

virtual Spectrum	NueComponent () const override

virtual Spectrum	AntiNueComponent () const override

virtual Spectrum	Data_Component () const override

virtual Spectrum	MCTotal () const

Spectrum	MC_NCTotalComponent () const override

Spectrum	MC_NCComponent () const override

Spectrum	MC_NCAntiComponent () const override

Spectrum	MC_NumuComponent () const override

Spectrum	MC_AntiNumuComponent () const override

Spectrum	MC_NueComponent () const override

Spectrum	MC_AntiNueComponent () const override

virtual Spectrum	MC_MCTotal () const

void	SavePlots (TDirectory *dir) const

virtual void	SaveTo (TDirectory *dir, const std::string &name) const override

const IDecomp *	GetNueEstimateDecomp () const

Static Public Member Functions
static std::unique_ptr< MichelDecomp >	LoadFrom (TDirectory *dir, const std::string &name)

Protected Member Functions
	MichelDecomp (Spectrum nc, Spectrum antinc, Spectrum numu, Spectrum antinumu, Spectrum nue, Spectrum antinue, Spectrum data, ReweightableSpectrum michelnc, ReweightableSpectrum michelnumu, ReweightableSpectrum michelnue, ReweightableSpectrum micheldata, const IDecomp *nueestimate)

void	Decompose () const
	Calls ComputeScaleFactor for every process / E Bin, saves scale factors. More...

void	SplitByProp (MDCMPHelper hSums, std::vector< double > &numuScales, std::vector< double > &ncScales, std::vector< double > &nueScales) const

void	SplitByNue (MDCMPHelper hSums, std::vector< double > &numuScales, std::vector< double > &ncScales, std::vector< double > &nueScales) const

void	SplitByMichels (int EIdx, MDCMPHelper hSums, std::vector< double > &numuScales, std::vector< double > &ncScales, std::vector< double > &nueScales) const

double	GetNueScale (int EIdx) const
	Nue scale from input decomp. More...

double	GetNumuScale (int EIdx) const
	Numu scale from input decomp. More...

double	GetNCScale (int EIdx) const
	NC scale from input decomp. More...

double	GetNumuMCContent (int EIdx) const
	Getting numu relative MC content. More...

double	GetNCMCContent (int EIdx) const

double	ComputeScaleFactor (int EIdx, MDCMPHelper hSums) const
	Starting code to run through decomp algebra //////////////////////////////////////////////////////////////////////// Compute scale factors. More...

double	CalculateMCMean (double h, double Numu, double NC, double Nue, MDCMPHelper hSums) const
	Calculates the expected MC events, for a given scale factor. More...

double	MDCMPLogLikelihood (double h, int EIdx, MDCMPHelper hSums) const
	Calculates the LL for a given scale, based on the data. More...

double	ComputeMaxScale (MDCMPHelper hSums) const

double	GetSum (ReweightableSpectrum spect, int EIdx) const
	Sums given spectrum over NME bins, for a given E Bin. More...

double	GetTemplateContent (ReweightableSpectrum spect, int EIdx, int mIdx) const
	Gets bin content in template histogram, for a given E / NME bin. More...

virtual Spectrum	MCToDCMPComp (std::vector< double >, Spectrum) const
	Ending code to run through decomp algebra. More...

void	SaveCompPlots (TDirectory *dir, std::string comp, Spectrum dcmp, Spectrum mc) const

void	SaveTempPlots (TDirectory *dir) const

Protected Attributes
Spectrum	fNC

Spectrum	fAntiNC

Spectrum	fNumu

Spectrum	fAntiNumu

Spectrum	fNue

Spectrum	fAntiNue

Spectrum	fData

ReweightableSpectrum	fMichelNC

ReweightableSpectrum	fMichelNumu

ReweightableSpectrum	fMichelNue

ReweightableSpectrum	fMichelData

const IDecomp *	fNueEstimate

bool	fOwnNueEstimate

bool	isDecomposed

MDCMPFitResults	fFitResult

Detailed Description

Definition at line 44 of file MichelDecomp.h.

Constructor & Destructor Documentation

ana::MichelDecomp::MichelDecomp	(	SpectrumLoaderBase &	NDMCloader,
		SpectrumLoaderBase &	NDdataloader,
		const HistAxis &	axis,
		const Cut &	cut,
		const IDecomp *	nNueEstimate,
		const SystShifts &	shiftMC = `kNoShift`,
		const SystShifts &	shiftData = `kNoShift`,
		const Var &	wei = `kUnweighted`
	)

Definition at line 40 of file MichelDecomp.cxx.

Referenced by LoadFrom().

     : fNC         (NDMCloader, EAxis,
                    cut && kIsNC && !kIsAntiNu, shiftMC, wei),
       fAntiNC     (NDMCloader, EAxis,
                    cut && kIsNC && kIsAntiNu, shiftMC, wei),
       fNumu       (NDMCloader, EAxis,
                    cut && kIsNumuCC && !kIsAntiNu, shiftMC, wei),
       fAntiNumu   (NDMCloader, EAxis,
                    cut && kIsNumuCC && kIsAntiNu, shiftMC, wei),
       fNue        (NDMCloader, EAxis,
                    cut && kIsBeamNue && !kIsAntiNu, shiftMC, wei),
       fAntiNue    (NDMCloader, EAxis,
                    cut && kIsBeamNue && kIsAntiNu, shiftMC, wei),
       fData       (NDDataloader, EAxis, cut, shiftData, wei),
       fMichelNC   (NDMCloader, EAxis, MEAxis,
                    cut && kIsNC, shiftMC, wei),
       fMichelNumu (NDMCloader, EAxis, MEAxis,
                    cut && kIsNumuCC, shiftMC, wei),
       fMichelNue  (NDMCloader, EAxis, MEAxis,
                    cut && kIsBeamNue, shiftMC, wei),
       fMichelData (NDDataloader, EAxis, MEAxis,
                    cut, shiftData, wei),
       fNueEstimate(nueEstimate),
       fOwnNueEstimate(false),
       isDecomposed(false)
   {}

ana::MichelDecomp::MichelDecomp	(	SpectrumLoaderBase &	NDMCloader,
		SpectrumLoaderBase &	NDdataloader,
		std::string	label,
		const Binning &	bins,
		const Var &	var,
		const Cut &	cut,
		const IDecomp *	nNueEstimate,
		const SystShifts &	shiftMC = `kNoShift`,
		const SystShifts &	shiftData = `kNoShift`,
		const Var &	wei = `kUnweighted`
	)

Definition at line 74 of file MichelDecomp.cxx.

     : MichelDecomp(NDMCloader, NDDataloader,
                    HistAxis(label, bins, var),
                    cut, nueEstimate, shiftMC, shiftData, wei)
   {}

ana::MichelDecomp::MichelDecomp	(	Loaders &	loaders,
		const HistAxis &	axis,
		const Cut &	cut,
		const IDecomp *	nNueEstimate,
		const SystShifts &	shiftMC = `kNoShift`,
		const SystShifts &	shiftData = `kNoShift`,
		const Var &	wei = `kUnweighted`
	)

Definition at line 89 of file MichelDecomp.cxx.

     : MichelDecomp(loaders.GetLoader(caf::kNEARDET, Loaders::kMC),
                    loaders.GetLoader(caf::kNEARDET, Loaders::kData),
                    axis, cut, nueEstimate, shiftMC, shiftData, wei)
   {}

ana::MichelDecomp::~MichelDecomp ( )

Definition at line 101 of file MichelDecomp.cxx.

References fNueEstimate, and fOwnNueEstimate.

   {
     if(fOwnNueEstimate) delete fNueEstimate;
   }

ana::MichelDecomp::MichelDecomp	(	Spectrum	nc,
		Spectrum	antinc,
		Spectrum	numu,
		Spectrum	antinumu,
		Spectrum	nue,
		Spectrum	antinue,
		Spectrum	data,
		ReweightableSpectrum	michelnc,
		ReweightableSpectrum	michelnumu,
		ReweightableSpectrum	michelnue,
		ReweightableSpectrum	micheldata,
		const IDecomp *	nueestimate
	)

inlineprotected

Definition at line 110 of file MichelDecomp.h.

References make_syst_table_plots::h, mc, ana::NC, ana::MDCMPFitResults::ncScales, ana::MDCMPFitResults::nueScales, ana::MDCMPFitResults::numuScales, and string.

       : fNC(nc),
         fAntiNC(antinc),
         fNumu(numu),
         fAntiNumu(antinumu),
         fNue(nue),
         fAntiNue(antinue),
         fData(data),
         fMichelNC(michelnc),
         fMichelNumu(michelnumu),
         fMichelNue(michelnue),
         fMichelData(micheldata),
         fNueEstimate(nueestimate),
         fOwnNueEstimate(false),
         isDecomposed(false) {}

Member Function Documentation

Spectrum ana::MichelDecomp::AntiNueComponent ( ) const

overridevirtual

Implements ana::IDecomp.

Definition at line 426 of file MichelDecomp.cxx.

References Decompose(), fAntiNue, fFitResult, isDecomposed, MCToDCMPComp(), and ana::MDCMPFitResults::nueScales.

Referenced by MakeResultPlot(), MichelDecompTest(), NDHists(), nue_decomp_scales(), nue_decomp_scales_for_make_decomp(), and SavePlots().

                                                 {
     if (!isDecomposed)
       Decompose();
     return MCToDCMPComp(fFitResult.nueScales, fAntiNue);
   }

Spectrum ana::MichelDecomp::AntiNumuComponent ( ) const

overridevirtual

Implements ana::IDecomp.

Definition at line 440 of file MichelDecomp.cxx.

References Decompose(), fAntiNumu, fFitResult, isDecomposed, MCToDCMPComp(), and ana::MDCMPFitResults::numuScales.

Referenced by MakeResultPlot(), MichelDecompTest(), NDHists(), nue_decomp_scales(), nue_decomp_scales_for_make_decomp(), and SavePlots().

                                                  {
     if (!isDecomposed)
       Decompose();
     return MCToDCMPComp(fFitResult.numuScales, fAntiNumu);
   }

double ana::MichelDecomp::CalculateMCMean	(	double	h,
		double	Numu,
		double	NC,
		double	Nue,
		MDCMPHelper	hSums
	)		const

protected

Calculates the expected MC events, for a given scale factor.

Definition at line 280 of file MichelDecomp.cxx.

References ana::assert(), ana::MDCMPHelper::fNueScale, ana::MDCMPHelper::fSumData, ana::MDCMPHelper::fSumNC, ana::MDCMPHelper::fSumNue, ana::MDCMPHelper::fSumNumu, extractScale::mean, and ana::NC.

Referenced by MDCMPLogLikelihood().

                                                                {
     assert(hSums.fSumNC > 0 && "Don't have enough stats.  Bailing.");
 
     double mean =
       h*(Numu - hSums.fSumNumu / hSums.fSumNC * NC) +
       hSums.fSumData / hSums.fSumNC * NC -
       hSums.fNueScale*hSums.fSumNue / hSums.fSumNC * NC + hSums.fNueScale*Nue;
     return mean;
   }

double ana::MichelDecomp::ComputeMaxScale ( MDCMPHelper hSums ) const

protected

Definition at line 272 of file MichelDecomp.cxx.

References ana::assert(), ana::MDCMPHelper::fNueScale, ana::MDCMPHelper::fSumData, ana::MDCMPHelper::fSumNue, and ana::MDCMPHelper::fSumNumu.

Referenced by ComputeScaleFactor().

                                                              {
     assert(hSums.fSumNumu > 0 && "Don't have enough stats.  Bailing.");
     double MaxScale = (hSums.fSumData - hSums.fNueScale*hSums.fSumNue) /
                        hSums.fSumNumu;
     return MaxScale;
   }

double ana::MichelDecomp::ComputeScaleFactor	(	int	EIdx,
		MDCMPHelper	hSums
	)		const

protected

Starting code to run through decomp algebra //////////////////////////////////////////////////////////////////////// Compute scale factors.

Definition at line 249 of file MichelDecomp.cxx.

References ComputeMaxScale(), dx, MDCMPLogLikelihood(), and scale.

Referenced by SplitByMichels().

                                                                            {
     double dx = 0.01;
 
     // Gives the bounds for the scale factor after each iteration
     double MinScale = 0;
     double MaxScale =  ComputeMaxScale(hSums);
     double scale = (MaxScale-MinScale) / 2;
 
     // Continue for 10 iterations
     for (double N = 0; N < 10; N++){
       // Adjust dx to be within the current allowed scale factors
       if ((MaxScale - MinScale) < 2*dx)
         dx = (MaxScale - MinScale)/4;
       double likeplus  = MDCMPLogLikelihood(scale+dx, EIdx, hSums);
       double likeminus = MDCMPLogLikelihood(scale-dx, EIdx, hSums);
       MaxScale = (likeplus > likeminus) ? MaxScale : scale;
       MinScale = (likeplus > likeminus) ? scale : MinScale;
       scale = (MaxScale+MinScale)/2;
     }
     return scale;
   }

Spectrum ana::MichelDecomp::Data_Component ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 502 of file MichelDecomp.cxx.

References fData.

Referenced by nue_decomp_scales_for_make_decomp(), PlotNueDecompFourBins(), TableNueNDComponents(), and TableNueNDDataMC().

                                               {
     return fData;
   }

void ana::MichelDecomp::Decompose ( ) const

protected

Calls ComputeScaleFactor for every process / E Bin, saves scale factors.

Definition at line 107 of file MichelDecomp.cxx.

References fFitResult, fMichelData, fMichelNC, fMichelNue, fMichelNumu, ana::MDCMPHelper::fNCScale, ana::MDCMPHelper::fNueScale, fNumu, ana::MDCMPHelper::fNumuScale, ana::MDCMPHelper::fSumData, ana::MDCMPHelper::fSumNC, ana::MDCMPHelper::fSumNue, ana::MDCMPHelper::fSumNumu, GetNCMCContent(), GetNCScale(), GetNueScale(), GetNumuMCContent(), GetNumuScale(), GetSum(), isDecomposed, ana::MDCMPFitResults::ncScales, ana::MDCMPFitResults::nueScales, ana::MDCMPFitResults::numuScales, SplitByMichels(), SplitByNue(), and ana::Spectrum::ToTH1().

Referenced by AntiNueComponent(), AntiNumuComponent(), NCAntiComponent(), NCComponent(), NCTotalComponent(), NueComponent(), and NumuComponent().

                                     {
     std::vector<double> numuScales;
     std::vector<double> ncScales;
     std::vector<double> nueScales;
 
     TH1* EIdxLimitHist = fNumu.ToTH1(1e20);
     for (int EIdx = 1; EIdx <= EIdxLimitHist->GetNbinsX(); EIdx++){
       // Get appropriate nuescale from input decomp
 
       // Stores sums of our histograms, to reduce computing in functions
       MDCMPHelper hSums;
       hSums.fSumData   = GetSum(fMichelData, EIdx);
       hSums.fSumNumu   = GetSum(fMichelNumu, EIdx);
       hSums.fSumNC     = GetSum(fMichelNC,   EIdx);
       hSums.fSumNue    = GetSum(fMichelNue,  EIdx);
       hSums.fNueScale  = GetNueScale(EIdx);
       hSums.fNumuScale = GetNumuScale(EIdx);
       hSums.fNCScale   = GetNCScale(EIdx);
 
       // Typical nue slices have about 1/8 SlcME's per slice
       // So, if there are more than about 80 events in a bin, we have 
       // at least 10 SlcME's in that bin, which is enough to run MDCMP
       // If we have fewer, proportionally split NC's and CC's
 
       // Instead of cheacking total number of events in a bin, look at 
       // number of data events seen, less the nue component predicted
       /*if (EIdx == 1 || EIdx == 2 || EIdx == 8 || EIdx == 9 || EIdx == 10 ||
           EIdx ==11 || EIdx ==16 || EIdx ==17 || EIdx ==18 || EIdx == 19 ||
           EIdx ==20 || EIdx ==21 || EIdx > 23)*/
       if ((GetNumuMCContent(EIdx) < .2) || (GetNCMCContent(EIdx) == .0))
         //SplitByProp(hSums, numuScales, ncScales, nueScales);
         SplitByNue(hSums, numuScales, ncScales, nueScales);
       else
         SplitByMichels(EIdx, hSums, numuScales, ncScales, nueScales);
     }
     delete EIdxLimitHist;
 
     fFitResult.numuScales = numuScales;
     fFitResult.ncScales   = ncScales;
     fFitResult.nueScales  = nueScales;
     isDecomposed = true;
   }

double ana::MichelDecomp::GetNCMCContent ( int EIdx ) const

protected

Definition at line 236 of file MichelDecomp.cxx.

References fAntiNC, fAntiNue, fAntiNumu, fNC, fNue, fNumu, nc, and ana::Ratio::ToTH1().

Referenced by Decompose().

                                                     {
     Spectrum nc = fNC+fAntiNC;
     Ratio ncrat = nc / (nc+fNumu+fAntiNumu+fNue+fAntiNue);
     TH1* hncrat = ncrat.ToTH1();
     double nccont = hncrat->GetBinContent(EIdx);
     delete hncrat;
     return nccont;
   }

double ana::MichelDecomp::GetNCScale ( int EIdx ) const

protected

NC scale from input decomp.

Definition at line 217 of file MichelDecomp.cxx.

References fAntiNC, fNC, fNueEstimate, nc, ana::IDecomp::NCTotalComponent(), scale, and ana::Ratio::ToTH1().

Referenced by Decompose().

                                                 {
     Spectrum nc = fNueEstimate->NCTotalComponent();
     Ratio ncrat = nc / (fNC+fAntiNC);
     TH1* hncrat = ncrat.ToTH1();
     double scale = hncrat->GetBinContent(EIdx);
     delete hncrat;
     return scale;
   }

const IDecomp* ana::MichelDecomp::GetNueEstimateDecomp ( ) const

inline

Definition at line 108 of file MichelDecomp.h.

108 {return fNueEstimate;}

ana::MichelDecomp::fNueEstimate

const IDecomp * fNueEstimate

Definition: MichelDecomp.h:195

double ana::MichelDecomp::GetNueScale ( int EIdx ) const

protected

Nue scale from input decomp.

Definition at line 195 of file MichelDecomp.cxx.

References ana::IDecomp::AntiNueComponent(), fAntiNue, fNue, fNueEstimate, ana::nue, ana::IDecomp::NueComponent(), scale, and ana::Ratio::ToTH1().

Referenced by Decompose().

                                                  {
     Spectrum nue = fNueEstimate->NueComponent() +
                    fNueEstimate->AntiNueComponent();
     Ratio nuerat = nue / (fNue+fAntiNue);
     TH1* hnuerat = nuerat.ToTH1();
     double scale = hnuerat->GetBinContent(EIdx);
     delete hnuerat;
     return scale;
   }

double ana::MichelDecomp::GetNumuMCContent ( int EIdx ) const

protected

Getting numu relative MC content.

Definition at line 227 of file MichelDecomp.cxx.

References fAntiNC, fAntiNue, fAntiNumu, fNC, fNue, fNumu, and ana::Ratio::ToTH1().

Referenced by Decompose().

                                                       {
     Spectrum numu = fNumu+fAntiNumu;
     Ratio numurat = numu / (numu+fNC+fAntiNC+fNue+fAntiNue);
     TH1* hnumurat = numurat.ToTH1();
     double numucont = hnumurat->GetBinContent(EIdx);
     delete hnumurat;
     return numucont;
   }

double ana::MichelDecomp::GetNumuScale ( int EIdx ) const

protected

Numu scale from input decomp.

Definition at line 206 of file MichelDecomp.cxx.

References ana::IDecomp::AntiNumuComponent(), fAntiNumu, fNueEstimate, fNumu, ana::IDecomp::NumuComponent(), scale, and ana::Ratio::ToTH1().

Referenced by Decompose().

                                                   {
     Spectrum numu = fNueEstimate->NumuComponent() +
                     fNueEstimate->AntiNumuComponent();
     Ratio numurat = numu / (fNumu+fAntiNumu);
     TH1* hnumurat = numurat.ToTH1();
     double scale = hnumurat->GetBinContent(EIdx);
     delete hnumurat;
     return scale;
   }

double ana::MichelDecomp::GetSum	(	ReweightableSpectrum	spect,
		int	EIdx
	)		const

protected

Sums given spectrum over NME bins, for a given E Bin.

Definition at line 322 of file MichelDecomp.cxx.

References fData, analysePickle::hist, ana::Spectrum::POT(), sum, and ana::ReweightableSpectrum::ToTH2().

Referenced by Decompose().

                                                                        {
     TH2* hist = spect.ToTH2(fData.POT());
     double sum = hist->ProjectionX()->GetBinContent(EIdx);
     delete hist;
     return sum;
   }

double ana::MichelDecomp::GetTemplateContent	(	ReweightableSpectrum	spect,
		int	EIdx,
		int	mIdx
	)		const

protected

Gets bin content in template histogram, for a given E / NME bin.

Definition at line 330 of file MichelDecomp.cxx.

References fData, analysePickle::hist, ana::Spectrum::POT(), and ana::ReweightableSpectrum::ToTH2().

Referenced by MDCMPLogLikelihood().

                                                                    {
     TH2* hist = spec.ToTH2(fData.POT());
     double content = hist->GetBinContent(EIdx, mIdx);
     delete hist;
     return content;
   }

std::unique_ptr< MichelDecomp > ana::MichelDecomp::LoadFrom	(	TDirectory *	dir,
		const std::string &	name
	)

static

Definition at line 534 of file MichelDecomp.cxx.

References ana::assert(), dir, fOwnNueEstimate, ana::LoadFrom< IDecomp >(), MichelDecomp(), nc, ana::nue, runNovaSAM::release, and runNovaSAM::ret.

Referenced by draw_decomp_plots(), nue_decomp_scales(), and plot_nominal_spectra().

                                                                                           {
     dir = dir->GetDirectory(name.c_str()); // switch to subdir
     assert(dir);
 
     Spectrum* nc       = ana::LoadFrom<Spectrum>
       (dir, "NC").release();
     Spectrum* antinc   = ana::LoadFrom<Spectrum>
       (dir, "AntiNC").release();
     Spectrum* numu     = ana::LoadFrom<Spectrum>
       (dir, "Numu").release();
     Spectrum* antinumu = ana::LoadFrom<Spectrum>
       (dir, "AntiNumu").release();
     Spectrum* nue      = ana::LoadFrom<Spectrum>
       (dir, "Nue").release();
     Spectrum* antinue  = ana::LoadFrom<Spectrum>
       (dir, "AntiNue").release();
     Spectrum* data  = ana::LoadFrom<Spectrum>
       (dir, "Data").release();
     ReweightableSpectrum* tempnc   = ana::LoadFrom<ReweightableSpectrum>
       (dir, "TempNC").release();
     ReweightableSpectrum* tempnumu = ana::LoadFrom<ReweightableSpectrum>
       (dir, "TempNumu").release();
     ReweightableSpectrum* tempnue  = ana::LoadFrom<ReweightableSpectrum>
       (dir, "TempNue").release();
     ReweightableSpectrum* tempdata = ana::LoadFrom<ReweightableSpectrum>
       (dir, "TempData").release();
     const IDecomp* nueEst = ana::LoadFrom<IDecomp>
       (dir, "NueEstimate").release();
 
     MichelDecomp* ret =
       new MichelDecomp(*nc, *antinc,
                        *numu, *antinumu, *nue, *antinue, *data,
                        *tempnc, *tempnumu, *tempnue, *tempdata, nueEst);
 
     ret->fOwnNueEstimate = true;
 
     delete dir;
 
     return std::unique_ptr<MichelDecomp>(ret);
   }

Spectrum ana::MichelDecomp::MC_AntiNueComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 472 of file MichelDecomp.cxx.

References fAntiNue.

Referenced by GetNueNDComponentsMC(), MakeResultPlot(), NDHists(), and nue_decomp_scales_for_make_decomp().

                                                    {
     return fAntiNue;
   }

Spectrum ana::MichelDecomp::MC_AntiNumuComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 482 of file MichelDecomp.cxx.

References fAntiNumu.

Referenced by GetNueNDComponentsMC(), MakeResultPlot(), NDHists(), and nue_decomp_scales_for_make_decomp().

                                                     {
     return fAntiNumu;
   }

virtual Spectrum ana::MichelDecomp::MC_MCTotal ( ) const

inlinevirtual

Definition at line 100 of file MichelDecomp.h.

References dir, ana::LoadFrom(), ana::SaveTo(), and string.

100 {return MC_NCTotalComponent() + MC_NumuComponent() + MC_AntiNumuComponent() + MC_NueComponent() + MC_AntiNueComponent();}

ana::MichelDecomp::MC_AntiNumuComponent

Spectrum MC_AntiNumuComponent() const override

Definition: MichelDecomp.cxx:482

ana::MichelDecomp::MC_NCTotalComponent

Spectrum MC_NCTotalComponent() const override

Definition: MichelDecomp.cxx:487

ana::MichelDecomp::MC_NumuComponent

Spectrum MC_NumuComponent() const override

Definition: MichelDecomp.cxx:477

ana::MichelDecomp::MC_NueComponent

Spectrum MC_NueComponent() const override

Definition: MichelDecomp.cxx:467

ana::MichelDecomp::MC_AntiNueComponent

Spectrum MC_AntiNueComponent() const override

Definition: MichelDecomp.cxx:472

Spectrum ana::MichelDecomp::MC_NCAntiComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 497 of file MichelDecomp.cxx.

References fAntiNC.

                                                   {
     return fAntiNC;
   }

Spectrum ana::MichelDecomp::MC_NCComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 492 of file MichelDecomp.cxx.

References fNC.

Referenced by nue_decomp_scales_for_make_decomp().

                                               {
     return fNC;
   }

Spectrum ana::MichelDecomp::MC_NCTotalComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 487 of file MichelDecomp.cxx.

References fAntiNC, and fNC.

Referenced by GetNueNDComponentsMC(), MakeResultPlot(), and NDHists().

                                                    {
     return fNC+fAntiNC;
   }

Spectrum ana::MichelDecomp::MC_NueComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 467 of file MichelDecomp.cxx.

References fNue.

Referenced by GetNueNDComponentsMC(), MakeResultPlot(), NDHists(), and nue_decomp_scales_for_make_decomp().

                                                {
     return fNue;
   }

Spectrum ana::MichelDecomp::MC_NumuComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 477 of file MichelDecomp.cxx.

References fNumu.

Referenced by GetNueNDComponentsMC(), MakeResultPlot(), NDHists(), and nue_decomp_scales_for_make_decomp().

                                                 {
     return fNumu;
   }

Spectrum ana::MichelDecomp::MCToDCMPComp	(	std::vector< double >	scales,
		Spectrum	MCComp
	)		const

protectedvirtual

Ending code to run through decomp algebra.

Definition at line 343 of file MichelDecomp.cxx.

References fData, fMichelData, ana::ReweightableSpectrum::GetBinnings(), ana::Spectrum::GetEigen(), ana::ReweightableSpectrum::GetLabels(), ana::Spectrum::Livetime(), and ana::Spectrum::POT().

Referenced by AntiNueComponent(), AntiNumuComponent(), NCAntiComponent(), NCComponent(), NueComponent(), and NumuComponent().

                                                             {
     Eigen::ArrayXd scaledMC = MCComp.GetEigen(fData.POT());
     for (int EIdx = 0; EIdx < scaledMC.size()-2; EIdx++){
       // Bin content in new histogram is old content * fit scale
       int    binidx  = EIdx+1; // Root counts bins starting at 1
       double bincont = scales[EIdx]*scaledMC[binidx];
       scaledMC[binidx] = bincont;
     }
     return Spectrum(std::move(scaledMC),
                     HistAxis(fMichelData.GetLabels(), fMichelData.GetBinnings()),
                     fData.POT(), fData.Livetime());
   }

virtual Spectrum ana::MichelDecomp::MCTotal ( ) const

inlinevirtual

Definition at line 89 of file MichelDecomp.h.

89 {return NCAntiComponent() +NCComponent()+NumuComponent()+AntiNumuComponent()+NueComponent()+AntiNueComponent();}

ana::MichelDecomp::AntiNumuComponent

virtual Spectrum AntiNumuComponent() const override

Definition: MichelDecomp.cxx:440

ana::MichelDecomp::NCComponent

virtual Spectrum NCComponent() const override

Definition: MichelDecomp.cxx:453

ana::MichelDecomp::NumuComponent

virtual Spectrum NumuComponent() const override

Definition: MichelDecomp.cxx:433

ana::MichelDecomp::AntiNueComponent

virtual Spectrum AntiNueComponent() const override

Definition: MichelDecomp.cxx:426

ana::MichelDecomp::NueComponent

virtual Spectrum NueComponent() const override

Definition: MichelDecomp.cxx:419

ana::MichelDecomp::NCAntiComponent

virtual Spectrum NCAntiComponent() const override

Definition: MichelDecomp.cxx:459

double ana::MichelDecomp::MDCMPLogLikelihood	(	double	h,
		int	EIdx,
		MDCMPHelper	hSums
	)		const

protected

Calculates the LL for a given scale, based on the data.

Definition at line 295 of file MichelDecomp.cxx.

References CalculateMCMean(), e, fMichelData, fMichelNC, fMichelNue, fMichelNumu, GetTemplateContent(), extractScale::mean, ana::NC, and ana::ReweightableSpectrum::ToTH2().

Referenced by ComputeScaleFactor().

                                                                   {
     double LL = 0;
 
     TH1* mIdxLimitHist = fMichelNumu.ToTH2(1e20);
     for (int mIdx = 1; mIdx <= mIdxLimitHist->GetNbinsY(); mIdx++){
       double Data = GetTemplateContent(fMichelData, EIdx, mIdx);
       double Numu = GetTemplateContent(fMichelNumu, EIdx, mIdx);
       double NC   = GetTemplateContent(fMichelNC,   EIdx, mIdx);
       double Nue  = GetTemplateContent(fMichelNue,  EIdx, mIdx);
       double mean = CalculateMCMean(h, Numu, NC, Nue, hSums);
       if (mean == 0 && Data == 0)
         continue;
       if (Data == 0){
         LL += Data - mean;
         continue;
       }
       if (mean == 0)
         mean = 1e-10;
       LL += Data - Data * TMath::Log(Data / mean) - mean;
     }
     delete mIdxLimitHist;
 
     return LL;
   }

Spectrum ana::MichelDecomp::NCAntiComponent ( ) const

overridevirtual

Implements ana::IDecomp.

Definition at line 459 of file MichelDecomp.cxx.

References Decompose(), fAntiNC, fFitResult, isDecomposed, MCToDCMPComp(), and ana::MDCMPFitResults::ncScales.

Referenced by NCTotalComponent(), and SavePlots().

                                                {
     if (!isDecomposed)
       Decompose();
     return MCToDCMPComp(fFitResult.ncScales, fAntiNC);
   }

Spectrum ana::MichelDecomp::NCComponent ( ) const

overridevirtual

Implements ana::IDecomp.

Definition at line 453 of file MichelDecomp.cxx.

References Decompose(), fFitResult, fNC, isDecomposed, MCToDCMPComp(), and ana::MDCMPFitResults::ncScales.

Referenced by NCTotalComponent(), nue_decomp_scales(), nue_decomp_scales_for_make_decomp(), and SavePlots().

                                            {
     if (!isDecomposed)
       Decompose();
     return MCToDCMPComp(fFitResult.ncScales, fNC);
   }

Spectrum ana::MichelDecomp::NCTotalComponent ( ) const

overridevirtual

Reimplemented from ana::IDecomp.

Definition at line 447 of file MichelDecomp.cxx.

References Decompose(), isDecomposed, NCAntiComponent(), and NCComponent().

Referenced by MakeResultPlot(), MichelDecompTest(), and NDHists().

                                                 {
     if (!isDecomposed)
       Decompose();
     return NCComponent()+NCAntiComponent();
   }

Spectrum ana::MichelDecomp::NueComponent ( ) const

overridevirtual

Implements ana::IDecomp.

Definition at line 419 of file MichelDecomp.cxx.

References Decompose(), fFitResult, fNue, isDecomposed, MCToDCMPComp(), and ana::MDCMPFitResults::nueScales.

Referenced by draw_decomp_plots(), MakeResultPlot(), MichelDecompTest(), NDHists(), nue_decomp_scales(), nue_decomp_scales_for_make_decomp(), and SavePlots().

                                             {
     if (!isDecomposed)
       Decompose();
     return MCToDCMPComp(fFitResult.nueScales, fNue);
   }

Spectrum ana::MichelDecomp::NumuComponent ( ) const

overridevirtual

Implements ana::IDecomp.

Definition at line 433 of file MichelDecomp.cxx.

References Decompose(), fFitResult, fNumu, isDecomposed, MCToDCMPComp(), and ana::MDCMPFitResults::numuScales.

Referenced by MakeResultPlot(), MichelDecompTest(), NDHists(), nue_decomp_scales(), nue_decomp_scales_for_make_decomp(), SavePlots(), and test_micheldecomp().

                                              {
     if (!isDecomposed)
       Decompose();
     return MCToDCMPComp(fFitResult.numuScales, fNumu);
   }

void ana::MichelDecomp::SaveCompPlots	(	TDirectory *	dir,
		std::string	comp,
		Spectrum	dcmp,
		Spectrum	mc
	)		const

protected

Definition at line 358 of file MichelDecomp.cxx.

References fData, plot_xsec_1d::hmc, pot, ana::Spectrum::POT(), and ana::Spectrum::ToTH1().

Referenced by SavePlots().

   {
     double pot = fData.POT();
     dir->cd();
     TH1* hdcmp = dcmp.ToTH1(pot);
     hdcmp->Write((comp+"_micheldecomp").c_str());
     TH1* hmc   = mc.ToTH1(pot);
     hmc->Write((comp+"_mc").c_str());
 
     TH1* hratio = (TH1*)hdcmp->Clone("hratio");
     hratio->Divide(hmc);
     hratio->Write((comp+"_ratio").c_str());
 
     delete hdcmp; delete hmc; delete hratio;
   }

void ana::MichelDecomp::SavePlots ( TDirectory * dir ) const

Definition at line 395 of file MichelDecomp.cxx.

References AntiNueComponent(), AntiNumuComponent(), fAntiNC, fAntiNue, fAntiNumu, fNC, fNue, fNumu, NCAntiComponent(), NCComponent(), NueComponent(), NumuComponent(), SaveCompPlots(), SaveTempPlots(), and tmp.

Referenced by make_files_for_decomp_plots().

   {
     TDirectory* tmp = gDirectory;
     dir->cd();
 
     SaveCompPlots(dir->mkdir("numu"), "numu",
                              NumuComponent(), fNumu);
     SaveCompPlots(dir->mkdir("antinumu"), "antinumu",
                              AntiNumuComponent(), fAntiNumu);
     SaveCompPlots(dir->mkdir("nc"), "nc",
                              NCComponent(), fNC);
     SaveCompPlots(dir->mkdir("antinc"), "antinc",
                              NCAntiComponent(), fAntiNC);
     SaveCompPlots(dir->mkdir("nue"), "nue",
                              NueComponent(), fNue);
     SaveCompPlots(dir->mkdir("antinue"), "antinue",
                              AntiNueComponent(), fAntiNue);
 
     SaveTempPlots(dir->mkdir("templates"));
 
     tmp->cd();
   }

void ana::MichelDecomp::SaveTempPlots ( TDirectory * dir ) const

protected

Definition at line 376 of file MichelDecomp.cxx.

References fData, fMichelData, fMichelNC, fMichelNue, fMichelNumu, pot, ana::Spectrum::POT(), ana::ReweightableSpectrum::ToTH2(), and ana::ToTH2().

Referenced by SavePlots().

   {
     double pot = fData.POT();
     dir->cd();
 
     TH2* tempnumu = fMichelNumu.ToTH2(pot);
     TH2* tempnc   = fMichelNC.  ToTH2(pot);
     TH2* tempnue  = fMichelNue. ToTH2(pot);
     TH2* tempdata = fMichelData.ToTH2(pot);
 
     tempnumu->Write("NumuTemplate");
     tempnc  ->Write("NCTemplate");
     tempnue ->Write("NueTemplate");
     tempdata->Write("DataTemplate");
 
     delete tempnumu; delete tempnc; delete tempnue; delete tempdata;
   }

void ana::MichelDecomp::SaveTo	(	TDirectory *	dir,
		const std::string &	name
	)		const

overridevirtual

Implements ana::IDecomp.

Definition at line 507 of file MichelDecomp.cxx.

References dir, fAntiNC, fAntiNue, fAntiNumu, fData, fMichelData, fMichelNC, fMichelNue, fMichelNumu, fNC, fNue, fNueEstimate, fNumu, ana::IDecomp::SaveTo(), ana::ReweightableSpectrum::SaveTo(), ana::Spectrum::SaveTo(), and tmp.

Referenced by make_files_for_decomp_plots(), and nue_decomp_scales().

                                                                        {
     TDirectory* tmp = gDirectory;
 
     dir = dir->mkdir(name.c_str()); // switch to subdir
     dir->cd();
 
     TObjString("MichelDecomp").Write("type");
 
     fNC.SaveTo(          dir, "NC");
     fAntiNC.SaveTo(      dir, "AntiNC");
     fNumu.SaveTo(        dir, "Numu");
     fAntiNumu.SaveTo(    dir, "AntiNumu");
     fNue.SaveTo(         dir, "Nue");
     fAntiNue.SaveTo(     dir, "AntiNue");
     fData.SaveTo(     dir, "Data");
     fMichelNC.SaveTo(    dir, "TempNC");
     fMichelNumu.SaveTo(  dir, "TempNumu");
     fMichelNue.SaveTo(   dir, "TempNue");
     fMichelData.SaveTo(  dir, "TempData");
     fNueEstimate->SaveTo(dir, "NueEstimate");
 
     dir->Write();
     delete dir;
 
     tmp->cd();
   }

void ana::MichelDecomp::SplitByMichels	(	int	EIdx,
		MDCMPHelper	hSums,
		std::vector< double > &	numuScales,
		std::vector< double > &	ncScales,
		std::vector< double > &	nueScales
	)		const

protected

Definition at line 150 of file MichelDecomp.cxx.

References ComputeScaleFactor(), ana::MDCMPHelper::fNueScale, ana::MDCMPHelper::fSumData, ana::MDCMPHelper::fSumNC, ana::MDCMPHelper::fSumNue, and ana::MDCMPHelper::fSumNumu.

Referenced by Decompose().

   {
       // We have enough data in this bin to do MichelDecomp
       double numuScale = ComputeScaleFactor(EIdx, hSums);
       double ncScale   =
         (hSums.fSumData - numuScale*hSums.fSumNumu -
          hSums.fNueScale*hSums.fSumNue) / hSums.fSumNC;
       numuScales.push_back(numuScale);
       ncScales.push_back(ncScale);
       nueScales.push_back(hSums.fNueScale);
   }

void ana::MichelDecomp::SplitByNue	(	MDCMPHelper	hSums,
		std::vector< double > &	numuScales,
		std::vector< double > &	ncScales,
		std::vector< double > &	nueScales
	)		const

protected

Definition at line 184 of file MichelDecomp.cxx.

References ana::MDCMPHelper::fNCScale, ana::MDCMPHelper::fNueScale, and ana::MDCMPHelper::fNumuScale.

Referenced by Decompose().

   {
       numuScales.push_back(hSums.fNumuScale);
       ncScales.push_back(hSums.fNCScale);
       nueScales.push_back(hSums.fNueScale);
   }

void ana::MichelDecomp::SplitByProp	(	MDCMPHelper	hSums,
		std::vector< double > &	numuScales,
		std::vector< double > &	ncScales,
		std::vector< double > &	nueScales
	)		const

protected

Definition at line 165 of file MichelDecomp.cxx.

References ana::MDCMPHelper::fSumData, ana::MDCMPHelper::fSumNC, ana::MDCMPHelper::fSumNue, and ana::MDCMPHelper::fSumNumu.

   {
     // Return MC if there are no events in the MC
     if (hSums.fSumNumu + hSums.fSumNC + hSums.fSumNue == 0){
       numuScales.push_back(1);
       ncScales.push_back(1);
       nueScales.push_back(1);
       return;
     }
     double DataMC = hSums.fSumData /
                     (hSums.fSumNue + hSums.fSumNumu + hSums.fSumNC);
       numuScales.push_back(DataMC);
       ncScales.push_back(DataMC);
       nueScales.push_back(DataMC);
   }

Member Data Documentation

Spectrum ana::MichelDecomp::fAntiNC

protected

Definition at line 184 of file MichelDecomp.h.

Referenced by GetNCMCContent(), GetNCScale(), GetNumuMCContent(), MC_NCAntiComponent(), MC_NCTotalComponent(), NCAntiComponent(), SavePlots(), and SaveTo().

Spectrum ana::MichelDecomp::fAntiNue

protected

Definition at line 188 of file MichelDecomp.h.

Referenced by AntiNueComponent(), GetNCMCContent(), GetNueScale(), GetNumuMCContent(), MC_AntiNueComponent(), SavePlots(), and SaveTo().

Spectrum ana::MichelDecomp::fAntiNumu

protected

Definition at line 186 of file MichelDecomp.h.

Referenced by AntiNumuComponent(), GetNCMCContent(), GetNumuMCContent(), GetNumuScale(), MC_AntiNumuComponent(), SavePlots(), and SaveTo().

Spectrum ana::MichelDecomp::fData

protected

Definition at line 189 of file MichelDecomp.h.

Referenced by Data_Component(), GetSum(), GetTemplateContent(), MCToDCMPComp(), SaveCompPlots(), SaveTempPlots(), and SaveTo().

MDCMPFitResults ana::MichelDecomp::fFitResult

mutableprotected

Definition at line 199 of file MichelDecomp.h.

Referenced by AntiNueComponent(), AntiNumuComponent(), Decompose(), NCAntiComponent(), NCComponent(), NueComponent(), and NumuComponent().

ReweightableSpectrum ana::MichelDecomp::fMichelData

protected

Definition at line 193 of file MichelDecomp.h.

Referenced by Decompose(), MCToDCMPComp(), MDCMPLogLikelihood(), SaveTempPlots(), and SaveTo().

ReweightableSpectrum ana::MichelDecomp::fMichelNC

protected

Definition at line 190 of file MichelDecomp.h.

Referenced by Decompose(), MDCMPLogLikelihood(), SaveTempPlots(), and SaveTo().

ReweightableSpectrum ana::MichelDecomp::fMichelNue

protected

Definition at line 192 of file MichelDecomp.h.

Referenced by Decompose(), MDCMPLogLikelihood(), SaveTempPlots(), and SaveTo().

ReweightableSpectrum ana::MichelDecomp::fMichelNumu

protected

Definition at line 191 of file MichelDecomp.h.

Referenced by Decompose(), MDCMPLogLikelihood(), SaveTempPlots(), and SaveTo().

Spectrum ana::MichelDecomp::fNC

protected

Definition at line 183 of file MichelDecomp.h.

Referenced by GetNCMCContent(), GetNCScale(), GetNumuMCContent(), MC_NCComponent(), MC_NCTotalComponent(), NCComponent(), SavePlots(), and SaveTo().

Spectrum ana::MichelDecomp::fNue

protected

Definition at line 187 of file MichelDecomp.h.

Referenced by GetNCMCContent(), GetNueScale(), GetNumuMCContent(), MC_NueComponent(), NueComponent(), SavePlots(), and SaveTo().

const IDecomp* ana::MichelDecomp::fNueEstimate

protected

Definition at line 195 of file MichelDecomp.h.

Referenced by GetNCScale(), GetNueScale(), GetNumuScale(), SaveTo(), and ~MichelDecomp().

Spectrum ana::MichelDecomp::fNumu

protected

Definition at line 185 of file MichelDecomp.h.

Referenced by Decompose(), GetNCMCContent(), GetNumuMCContent(), GetNumuScale(), MC_NumuComponent(), NumuComponent(), SavePlots(), and SaveTo().

bool ana::MichelDecomp::fOwnNueEstimate

protected

Definition at line 196 of file MichelDecomp.h.

Referenced by LoadFrom(), and ~MichelDecomp().

bool ana::MichelDecomp::isDecomposed

mutableprotected

Definition at line 198 of file MichelDecomp.h.

Referenced by AntiNueComponent(), AntiNumuComponent(), Decompose(), NCAntiComponent(), NCComponent(), NCTotalComponent(), NueComponent(), and NumuComponent().

The documentation for this class was generated from the following files:

/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-11-28/3FlavorAna/Decomp/MichelDecomp.h
/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-11-28/3FlavorAna/Decomp/MichelDecomp.cxx

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation