ana::SBNOsc::Chi2Sensitivity Class Reference

#include <Chi2Sensitivity.h>

Inheritance diagram for ana::SBNOsc::Chi2Sensitivity:

Classes
class	EventSample

Public Member Functions
	Chi2Sensitivity ()
void	Initialize (fhicl::ParameterSet *config)
void	ProcessEvent (const event::Event *event)
void	ProcessSubRun (const SubRun *subrun)
void	FileCleanup (TTree *eventTree)
void	Finalize ()
void	Scale ()
void	GetChi2 ()
void	GetContours ()
void	Write ()
TH1D *	Oscillate (double sinth, double dm2)
Public Member Functions inherited from core::PostProcessorBase
	PostProcessorBase ()
virtual	~PostProcessorBase ()
void	Run (std::vector< std::string > filelist)
void	Initialize (char *config=NULL, const std::string &output_fname="", unsigned n_workers=1)

Public Attributes
TGraph2D *	chisqplot
TGraph *	contour_90pct
TGraph *	contour_3sigma
TGraph *	contour_5sigma

Private Attributes
std::string	fEnergyType
double	fSelectionEfficiency
double	fBackgroundRejection
int	fNumDm2
int	fNumSin
std::vector< double >	fLogDm2Lims
std::vector< double >	fLogSinLims
std::string	fOutputFile
int	fSavePDFs
bool	fSaveSignal
bool	fSaveBackground
std::vector< std::array < double, 2 > >	fSaveOscillations
unsigned	fSampleIndex
Covariance	fCovariance
std::vector< EventSample >	fEventSamples
std::vector< double >	sin2theta
std::vector< double >	dm2
std::vector< std::vector < double > >	chisq_diffs
	Container for chi2 values. More...

Additional Inherited Members
Protected Member Functions inherited from core::PostProcessorBase
virtual void	ProcessFileMeta (const FileMeta *filemeta)
virtual void	FileSetup (TFile *f, TTree *eventTree)
virtual void	InitializeThread ()
unsigned	NWorkers ()
unsigned	WorkerID ()
Protected Attributes inherited from core::PostProcessorBase
ProviderManager *	fProviderManager
	Interface for provider access. More...
int	fConfigExperimentID

Detailed Description

Definition at line 21 of file Chi2Sensitivity.h.

Constructor & Destructor Documentation

ana::SBNOsc::Chi2Sensitivity::Chi2Sensitivity ( )

inline

Definition at line 26 of file Chi2Sensitivity.h.

{}

Member Function Documentation

void ana::SBNOsc::Chi2Sensitivity::FileCleanup ( TTree *  eventTree )

virtual

Any cleanup needed per file

Parameters

eventTree

the TTree associated with the sbncode event.

Reimplemented from core::PostProcessorBase.

Definition at line 244 of file Chi2Sensitivity.cxx.

                                                  {
    // cleanup for Covariance
    fCovariance.FileCleanup(eventTree);

    // onto the next sample
    fSampleIndex ++;
}

void ana::SBNOsc::Chi2Sensitivity::Finalize ( )

inlinevirtual

Perform user-level finalization. Called after all events have been processed.

Reimplemented from core::PostProcessorBase.

Definition at line 33 of file Chi2Sensitivity.h.

                        { 
          for (int i = 0; i < fEventSamples.size(); i++) {
            std::cout << "POT: " << fEventSamples[i].fPOT << " to: " << fEventSamples[i].fScalePOT << " factor: " << fEventSamples[i].fScalePOT / fEventSamples[i].fPOT << std::endl;
          }

        fCovariance.Finalize(); Scale(); GetChi2(); GetContours(); Write(); }

void ana::SBNOsc::Chi2Sensitivity::GetChi2

(

)

Definition at line 358 of file Chi2Sensitivity.cxx.

                              {
    
    //// Invert Error Matrix
    //// ~~~~~~~~~~~~~~~~~~~
    
    std::cout << std::endl << "Inverting full error matrix, E_{ij}..." << std::endl;
    
    // Create error (statistical and systematic) matrix
    //
    // Take covariance matrix from Covariance calculator
    TMatrixDSym E_mat = fCovariance.CovarianceMatrix();
    // Invert it
    TMatrixD E_inv = E_mat.Invert();
        // Find a way to stop code if the matrix doesn't invert! 
        // Check error message? See if E_inv exists?
    
    std::cout << "   Inverted." << std::endl;
    
    
    //// Get chi squareds
    //// ~~~~~~~~~~~~~~~~
    
    // Phase space of oscillation parameters
    for (int i = 0; i < fNumSin; i++) {
        sin2theta.push_back(TMath::Power(10, fLogSinLims[0] + i*(fLogSinLims[1] - fLogSinLims[0])/(fNumSin-1)));
    }
    for (int j = 0; j < fNumDm2; j++) {
        dm2.push_back(TMath::Power(10, fLogDm2Lims[0] + j*(fLogDm2Lims[1] - fLogDm2Lims[0])/(fNumDm2-1)));
    }

    // Loop over phase space calculating Chisq
    clock_t startchi = clock();
    std::cout << std::endl << "Calculating chi squareds..." << std::endl;
    
    double minchisq = 1e99;
    std::vector <double> chisq_dm2(fNumDm2, 0);
    std::vector <std::vector <double> > chisq(fNumSin, chisq_dm2);

    std::vector<double> signal; // non-oscillated signal
    // push all event samples into the vector
    for (auto const &sample: fEventSamples) {
        // flatten the signal
        std::vector<double> this_signal = sample.Signal();
        signal.insert(signal.end(), this_signal.begin(), this_signal.end());
    }

    for (int j = 0; j < fNumDm2; j++) {
        std::vector<std::vector<double>> oscillated; // oscilalted signal at sin2==1

        // push all event samples into the vector
        for (auto const &sample: fEventSamples) {
            // oscillate each event sample w/ sin == 1
            oscillated.push_back(sample.Oscillate(1., dm2[j]));
        }

        // oscillated signal for general sin2 (set in loop below)
        std::vector<double> sin2_oscillated(signal.size(), 0);

        for (int i = 0; i < fNumSin; i++) {
            // Scale the oscillated samples based on the sin2 value and flatten them
            unsigned count_ind = 0;
            for (unsigned sample_ind = 0; sample_ind < oscillated.size(); sample_ind++) {
                for (unsigned bin_ind = 0; bin_ind < oscillated[sample_ind].size(); bin_ind++) {
                    // No oscillation
                    if (fEventSamples[sample_ind].fOscType == 0) {
                        sin2_oscillated[count_ind] = signal[count_ind];
                    }
                    // numu -> nue
                    else if (fEventSamples[sample_ind].fOscType == 1) {
                        sin2_oscillated[count_ind] = sin2theta[i] * oscillated[sample_ind][bin_ind];
                    }
                    // numu -> numu
                    else if (fEventSamples[sample_ind].fOscType == 2) {
                        // These two formulas are equivalent:
                        // 1.
                        // sin2_oscillated[count_ind] = signal[count_ind] - 
                        //     sin2theta[i] * (signal[count_ind] - oscillated[sample_ind][bin_ind]);
                        // 2.
                        // sin2_oscillated[count_ind] = signal[count_ind] * (1 - sin2theta[i]) +
                        //     sin2theta[i] * oscillated[sample_ind][bin_ind];
                        //     
                        // Use the second one b.c. it reduces possible floating point error

                        sin2_oscillated[count_ind] = signal[count_ind] * (1 - sin2theta[i]) +
                             sin2theta[i] * oscillated[sample_ind][bin_ind];

                    }

                    // update count ind
                    count_ind ++;
                } 
            }
            assert(count_ind == signal.size());

            // Calculate chisq for sin2th = 1
            for (int k = 0; k < signal.size(); k++) {
                for (int l = 0; l < signal.size(); l++) {
                    chisq[i][j] += (signal[k] - sin2_oscillated[k]) * (signal[l] - sin2_oscillated[l]) * E_inv[k][l];
                }
            }

            // Check if min chisq
            if (chisq[i][j] < minchisq) {
                minchisq = chisq[i][j];
            }
        
        }
    }
    
    clock_t endchi = clock();
    clock_t tickschi = endchi - startchi;                    // in n of ticks
    double timechi = tickschi / (double) CLOCKS_PER_SEC;     // make into secs
    
    std::cout << "   Done in " << timechi << "s. " << std::endl;
    
    
    // Gen TGraph2D for output
    chisqplot = new TGraph2D();
    for (int i = 0; i < fNumSin; i++) {
        for (int j = 0; j < fNumDm2; j++) {
            chisqplot->SetPoint(i*fNumSin + j, TMath::Log10(sin2theta[i]), TMath::Log10(dm2[j]), chisq[i][j]);
        }
    }
    
    // Get differences
    chisq_diffs = chisq;
    for (int i = 0; i < fNumSin; i++) {
        for (int j = 0; j < fNumDm2; j++) {
            chisq_diffs[i][j] -= minchisq;
        }
    }
    
}

void ana::SBNOsc::Chi2Sensitivity::GetContours

(

)

Definition at line 492 of file Chi2Sensitivity.cxx.

                                  {
    
    //// Get contours
    //// ~~~~~~~~~~~~
    
    /*
       Note: I'm just copying my own code I'd written to get contours. I've heard that there is some 
       function on TH2Ds that does it automatically but haven't used it. This one is pretty fast so 
       I'm leaving it in, at least for now.
    */
    
    clock_t startcont = clock();
    std::cout << std::endl << "Getting contours..." << std::endl;
    
    // Get contours
    double target;
    std::vector <double> target_dchisq = {1.64, 7.75, 23.40}, corners(4, 0), twozeros(2, 0);
    std::vector <std::vector <double> > contour, sin_contour(target_dchisq.size()), dm2_contour(target_dchisq.size()), vecof2vecs(fNumDm2, twozeros);
    std::vector <std::vector <std::vector <double> > > box_minmax(fNumSin, vecof2vecs);
    for  (int k = 0; k < target_dchisq.size(); k++){
        
        target = target_dchisq[k];
        
        // Initialise box_minmax
        for (int i = 0; i < fNumSin-1; i++) {
            for (int j = 0; j < fNumDm2-1; j++) {
                box_minmax[i][j] = {0, 0};
            }
        }
        
        // Fill box_minmax out
        for (int i = 0; i < fNumSin-1; i++) {
            for (int j = 0; j < fNumDm2-1; j++) {
                
                corners = {chisq_diffs[i][j], chisq_diffs[i+1][j], chisq_diffs[i][j+1], chisq_diffs[i+1][j+1]};
                box_minmax[i][j] = {corners[0], corners[0]};
                for (int l = 1; l < 4; l++) {
                    if (corners[l] > box_minmax[i][j][1]) {
                        box_minmax[i][j][1] = corners[l];
                    } else if (corners[l] < box_minmax[i][j][0]) {
                        box_minmax[i][j][0] = corners[l];
                    }
                }
                
            }
        }
        
        // Get the contour
        contour.clear();
        for (int i = 0; i < fNumSin-1; i++) {
            for (int j = 0; j < fNumDm2-1; j++) {
                
                if ((target >= box_minmax[i][j][0]) && (target <= box_minmax[i][j][1])) {
                    contour.push_back({(sin2theta[i] + sin2theta[i+1])/2, (dm2[j] + dm2[j+1])/2});
                }
            
            }
        }
        
        // Save the contour
        for (int j = 0; j < contour.size(); j++) {
            sin_contour[k].push_back(contour[j][0]);
            dm2_contour[k].push_back(contour[j][1]);
        }
        
    }
    
    clock_t endcont = clock();
    clock_t tickscont = endcont - startcont;                    // in n of ticks
    double timecont = tickscont / (double) CLOCKS_PER_SEC;      // make into secs
    
    std::cout << "   Done in " << timecont << "s." << std::endl;
    
    // Create TGraphs
    std::vector <TGraph*> graphs;
    for (int i = 0; i < sin_contour.size(); i++) {
        
        graphs.push_back(new TGraph());
        
        for (int j = 0; j < sin_contour[i].size(); j++) {
            graphs[i]->SetPoint(j, sin_contour[i][j], dm2_contour[i][j]);
        }
        
    }
    
    
    //// Output stuff
    //// ~~~~~~~~~~~~
    
    contour_90pct = graphs[0];
    contour_3sigma = graphs[1];
    contour_5sigma = graphs[2];
    
}

void ana::SBNOsc::Chi2Sensitivity::Initialize ( fhicl::ParameterSet *  config )

virtual

Perform user-level initialization.

Parameters

config

A configuration, as a JSON object.

Implements core::PostProcessorBase.

Definition at line 110 of file Chi2Sensitivity.cxx.

                                                          {
    //// Get parameters from config file
    //// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    // must have config
    assert(config != NULL);

    // initialize covariance
    fCovariance.Initialize(config);

    // Output directory
    fhicl::ParameterSet pconfig = config->get<fhicl::ParameterSet>("Sensitivity");
    fOutputFile = pconfig.get<std::string>("OutputFile", "output.root");

    // Get energy from covariance
    fEnergyType = pconfig.get<std::string>("EnergyType", "Reco");

    // Further selection and rejection 'efficiencies'
    fSelectionEfficiency = pconfig.get<double>("SelectionEfficiency", 1.0);
    fBackgroundRejection = pconfig.get<double>("BackgroundRejection", 0.0);

    // Event Samples
    std::vector<fhicl::ParameterSet> samples = \
      config->get<std::vector<fhicl::ParameterSet> >("EventSamples");
    for (const fhicl::ParameterSet& sample: samples) {
      fEventSamples.emplace_back(sample);
    }

    // Phase space parameters
    fNumDm2 = pconfig.get<int>("NumDm2", 50);
    fLogDm2Lims = pconfig.get<std::vector<double> >("LogDm2Lims");
    fNumSin = pconfig.get<int>("NumSin", 50);
    fLogSinLims = pconfig.get<std::vector<double> >("LogSinLims");

    // Whether to save stuff
    fSavePDFs = pconfig.get<bool>("SavePDFs", true);
    fSaveSignal = pconfig.get<bool>("SaveSignal", true);
    fSaveBackground = pconfig.get<bool>("SaveBackground", true);

    if (pconfig.is_key_to_sequence("SaveOscillations")) {
      std::vector<std::vector<double> > pairs = \
        pconfig.get<std::vector<std::vector<double> > >("SaveOscillations");
      for (size_t i=0; i<pairs.size(); i++) {
        fSaveOscillations.push_back({ pairs[i].at(0), pairs[i].at(1) });
      }
    }

    // start at 0th event sample
    fSampleIndex = 0;
}

TH1D* ana::SBNOsc::Chi2Sensitivity::Oscillate	(	double	sinth,
		double	dm2
	)

void ana::SBNOsc::Chi2Sensitivity::ProcessEvent ( const event::Event *  event )

virtual

Process one event.

Parameters

event

The sbncode event for the current event

Implements core::PostProcessorBase.

Definition at line 257 of file Chi2Sensitivity.cxx.

                                                          {
    // have the covariance process the event
    fCovariance.ProcessEvent(event);

    // Iterate over each interaction in the event
    for (int n = 0; n < event->reco.size(); n++) {
        unsigned truth_ind = event->reco[n].truth_index;
    
        // Get energy
        int idx = event->reco[n].truth_index;
        if (idx < 0 || idx > event->truth.size()) {
          continue;
        }
        double true_nuE = event->truth[idx].neutrino.energy;
        double nuE = 0;
        if (fEnergyType == "CCQE") {
            nuE = event->truth[truth_ind].neutrino.eccqe;
        } else if (fEnergyType == "True") {
            nuE = true_nuE;
        } else if (fEnergyType == "Reco") {
            nuE = event->reco[n].reco_energy;
        }

        // get distance travelled from decay vertex
        // parent decay vertex
        TVector3 p_decay_vtx = event->truth[truth_ind].neutrino.parentDecayVtx;
        TVector3 neutrino_vtx = event->truth[truth_ind].neutrino.position;

        double dz = fEventSamples[fSampleIndex].fBaseline - p_decay_vtx.Z() + neutrino_vtx.Z() - fEventSamples[fSampleIndex].fBeamFrontZ;
        double dy = p_decay_vtx.Y() - neutrino_vtx.Y() + fEventSamples[fSampleIndex].fBeamCenterY;
        double dx = p_decay_vtx.X() - neutrino_vtx.X() + fEventSamples[fSampleIndex].fBeamCenterX;
        double dist = sqrt(dx*dx + dy*dy + dz*dz) / 100000. /* cm -> km */;
    
        // check if energy is within bounds
        if (nuE < fEventSamples[fSampleIndex].fBins[0] || nuE > fEventSamples[fSampleIndex].fBins[fEventSamples[fSampleIndex].fBins.size()-1]) {
            continue;
        } 
        else if (nuE < fEventSamples[fSampleIndex].fTrueEBins[0] || 
            nuE > fEventSamples[fSampleIndex].fTrueEBins[fEventSamples[fSampleIndex].fTrueEBins.size()-1]) {
            std::cout << std::endl << "NUE IN RANGE, TRUE E NOT!!!   nuE = " << nuE << " and true_nuE = " << true_nuE << std::endl;
            continue;
        }
        else if (dist < fEventSamples[fSampleIndex].fDistBins[0] ||
            dist > fEventSamples[fSampleIndex].fDistBins[fEventSamples[fSampleIndex].fDistBins.size() -1]) {
            std::cout << std::endl << "NUE IN RANGE, DISTANCE NOT!! nuE = " << nuE << " and distance = " << dist << std::endl;
            std::cout << "DIST MIN: " << fEventSamples[fSampleIndex].fDistBins[0] << std::endl;
            std::cout << "DIST MAX: " << fEventSamples[fSampleIndex].fDistBins[fEventSamples[fSampleIndex].fDistBins.size() -1] << std::endl;
            continue;
        }
    
        // Apply selection (or rejection) efficiencies
        int isCC = event->truth[truth_ind].neutrino.iscc;
        // double wgt = isCC*(fSelectionEfficiency) + (1-isCC)*(1 - fBackgroundRejection);
        // and scale weight
        // wgt *= fEventSamples[fSampleIndex].fScaleFactor;
        // apply uniform weights
        // for (auto const &key: fUniformWeights) {
        //    wgt *= event->truth[truth_ind].weights.at(key)[0];
        // }
        double wgt = event->reco[n].weight;
        if (fEventSamples[fSampleIndex].fScalePOT > 0) {
          wgt *= fEventSamples[fSampleIndex].fScalePOT / fEventSamples[fSampleIndex].fPOT;
        }
    
        // fill in hitograms
        //
        // Signal
        if (isCC) {
            fEventSamples[fSampleIndex].fSignalCounts->Fill(nuE, true_nuE, dist, wgt);
        }
        // background
        else {
            fEventSamples[fSampleIndex].fBkgCounts->Fill(nuE, wgt);
        }
    }
}

void ana::SBNOsc::Chi2Sensitivity::ProcessSubRun ( const SubRun *  subrun )

virtual

Reimplemented from core::PostProcessorBase.

Definition at line 252 of file Chi2Sensitivity.cxx.

                                                        {
  fCovariance.ProcessSubRun(subrun);
  fEventSamples[fSampleIndex].fPOT += subrun->totgoodpot;
}

void ana::SBNOsc::Chi2Sensitivity::Scale

(

)

Definition at line 335 of file Chi2Sensitivity.cxx.

                            {
  for (int sample = 0; sample < fEventSamples.size(); sample++) {
    for (int i = 1; i < fEventSamples[sample].fSignalCounts->GetNbinsX()+1; i++) {
      double scale = fEventSamples[sample].fEnergyBinScale[i-1]; 
      for (int j = 1; j < fEventSamples[sample].fSignalCounts->GetNbinsY()+1; j++) {
        for (int k = 1; k < fEventSamples[sample].fSignalCounts->GetNbinsZ()+1; k++) {
          double content = fEventSamples[sample].fSignalCounts->GetBinContent(i, j, k);
      //std::cout << "pre sample: " << sample << " bin content: " << fEventSamples[sample].fSignalCounts->GetBinContent(i);
          fEventSamples[sample].fSignalCounts->SetBinContent(i, j, k, content * scale);
      //std::cout << "post sample: " << sample << " bin content: " << fEventSamples[sample].fSignalCounts->GetBinContent(i);
        }
      }
    }

    for (int i = 1; i < fEventSamples[sample].fBkgCounts->GetNbinsX()+1; i++) {
      double scale = fEventSamples[sample].fEnergyBinScale[i-1]; 
      double content = fEventSamples[sample].fBkgCounts->GetBinContent(i);
      fEventSamples[sample].fBkgCounts->SetBinContent(i, content * scale);
    }
  }
}

void ana::SBNOsc::Chi2Sensitivity::Write

(

)

Definition at line 587 of file Chi2Sensitivity.cxx.

                            {
    
    // Wite to file
    TFile* chi2file = TFile::Open(fOutputFile.c_str(), "recreate");
    assert(chi2file && chi2file->IsOpen());
    
    if (fSavePDFs) {
        contour_90pct->SetName("90pct"); contour_90pct->Write();
        contour_3sigma->SetName("3sigma"); contour_3sigma->Write();
        contour_5sigma->SetName("5sigma"); contour_5sigma->Write();
        
        chisqplot->SetName("chisq"); chisqplot->Write();
    }

    // save histos
    if (fSaveBackground) {
        for (auto const &sample: fEventSamples) {
            sample.fBkgCounts->Write();
        }
    }

    if (fSaveSignal) {
        for (auto const &sample: fEventSamples) {
            sample.fSignalCounts->Write();
        }
    }

    for (auto const &osc_vals: fSaveOscillations) {
        for (auto const &sample: fEventSamples) {
            std::string name = sample.fName + " sin2th: " + std::to_string(osc_vals[0]) + " dm2: " + std::to_string(osc_vals[1]);
            TH1D *hist = new TH1D(name.c_str(), name.c_str(), sample.fBins.size()-1, &sample.fBins[0]);
            std::vector<double> oscillated = sample.Oscillate(osc_vals[0], osc_vals[1]);
            for (unsigned i = 0; i < oscillated.size(); i++) {
                hist->SetBinContent(i+1, oscillated[i]);
            }
            hist->Write();
        }
    }

    chi2file->Close();
    
}

Member Data Documentation

std::vector<std::vector <double> > ana::SBNOsc::Chi2Sensitivity::chisq_diffs

private

Container for chi2 values.

Definition at line 118 of file Chi2Sensitivity.h.

TGraph2D* ana::SBNOsc::Chi2Sensitivity::chisqplot

Definition at line 50 of file Chi2Sensitivity.h.

TGraph * ana::SBNOsc::Chi2Sensitivity::contour_3sigma

Definition at line 51 of file Chi2Sensitivity.h.

TGraph * ana::SBNOsc::Chi2Sensitivity::contour_5sigma

Definition at line 51 of file Chi2Sensitivity.h.

TGraph* ana::SBNOsc::Chi2Sensitivity::contour_90pct

Definition at line 51 of file Chi2Sensitivity.h.

std::vector<double> ana::SBNOsc::Chi2Sensitivity::dm2

private

Definition at line 116 of file Chi2Sensitivity.h.

double ana::SBNOsc::Chi2Sensitivity::fBackgroundRejection

private

Definition at line 93 of file Chi2Sensitivity.h.

Covariance ana::SBNOsc::Chi2Sensitivity::fCovariance

private

Definition at line 110 of file Chi2Sensitivity.h.

std::string ana::SBNOsc::Chi2Sensitivity::fEnergyType

private

Definition at line 91 of file Chi2Sensitivity.h.

std::vector<EventSample> ana::SBNOsc::Chi2Sensitivity::fEventSamples

private

Definition at line 112 of file Chi2Sensitivity.h.

std::vector<double> ana::SBNOsc::Chi2Sensitivity::fLogDm2Lims

private

Definition at line 97 of file Chi2Sensitivity.h.

std::vector<double> ana::SBNOsc::Chi2Sensitivity::fLogSinLims

private

Definition at line 97 of file Chi2Sensitivity.h.

int ana::SBNOsc::Chi2Sensitivity::fNumDm2

private

Definition at line 95 of file Chi2Sensitivity.h.

int ana::SBNOsc::Chi2Sensitivity::fNumSin

private

Definition at line 96 of file Chi2Sensitivity.h.

std::string ana::SBNOsc::Chi2Sensitivity::fOutputFile

private

Definition at line 99 of file Chi2Sensitivity.h.

unsigned ana::SBNOsc::Chi2Sensitivity::fSampleIndex

private

Definition at line 107 of file Chi2Sensitivity.h.

bool ana::SBNOsc::Chi2Sensitivity::fSaveBackground

private

Definition at line 103 of file Chi2Sensitivity.h.

std::vector<std::array<double, 2> > ana::SBNOsc::Chi2Sensitivity::fSaveOscillations

private

Definition at line 104 of file Chi2Sensitivity.h.

int ana::SBNOsc::Chi2Sensitivity::fSavePDFs

private

Definition at line 101 of file Chi2Sensitivity.h.

bool ana::SBNOsc::Chi2Sensitivity::fSaveSignal

private

Definition at line 102 of file Chi2Sensitivity.h.

double ana::SBNOsc::Chi2Sensitivity::fSelectionEfficiency

private

Definition at line 93 of file Chi2Sensitivity.h.

std::vector<double> ana::SBNOsc::Chi2Sensitivity::sin2theta

private

Definition at line 115 of file Chi2Sensitivity.h.

---

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

• Chi2Sensitivity.h
• Chi2Sensitivity.cxx