make_mass_and_oct_fc_input_2019.C
Go to the documentation of this file.
3 #include "CAFAna/Fit/Fit.h"
11 #include "CAFAna/FC/FCSurface.h"
16 #include "CAFAna/Vars/FitVars.h"
17 #include "OscLib/IOscCalc.h"
18 //#include "3FlavorAna/Ana2018/nue/joint_fit_2018_tools.h"
20 #include "Utilities/rootlogon.C"
21 
22 
23 void MakeMaps ( std::vector <const IFitVar*> profvars,
24  std::map<const IFitVar*, TGraph*> &profMap,
25  std::vector <const ISyst* > systs,
26  std::map<const ISyst*, TGraph*> &systMap)
27 {
28  for (const IFitVar * var:profvars)
29  profMap.insert(std::pair<const IFitVar*, TGraph*> (var, new TGraph()));
30  for (const ISyst* syst : systs)
31  systMap.insert(std::pair<const ISyst*, TGraph*> (syst, new TGraph()));
32 }
33 
34 void SaveMaps ( TDirectory * dir,
35  std::vector <const IFitVar*> profvars,
36  std::map<const IFitVar*, TGraph*> &profMap,
37  std::vector <const ISyst* > systs,
38  std::map<const ISyst*, TGraph*> &systMap,
39  double dchi_sq,
40  TString pars)
41 {
42  TDirectory *tmp = gDirectory;
43  dir->cd();
44  for (int i = 0; i < (int) profvars.size(); ++i){
45  profMap[profvars[i]]->Write((TString) pars + "_" + profvars[i]->ShortName());
46  }
47  for (const ISyst* s : systs)
48  systMap[s]->Write((TString) pars + "_" + s->ShortName());
49 
50  TGraph* g = new TGraph();
51  g->SetPoint(0,0, dchi_sq);
52  g->Write((pars + "_gaussian_significance").Data());
53  tmp->cd();
54 }
55 
56 
58  TString analysis = "joint",
59  bool corrSysts = true){
60  assert(beamMode == "RHCOnly" ||
61  beamMode == "FHCOnly" ||
62  beamMode == "both");
63  assert(analysis == "nue" ||
64  analysis == "numu" ||
65  analysis == "joint");
66 
67  bool RHCOnly = beamMode.Contains("RHCOnly");
68  bool FHCOnly = beamMode.Contains("FHCOnly");
69  bool both = beamMode.Contains("both");
70 
71  bool nueOnly = analysis.Contains("nue");
72  bool numuOnly = analysis.Contains("numu");
73  bool joint = analysis.Contains("joint");
74 
75  TString outdir = "/nova/ana/nu_e_ana/Ana2019/FC/mh_oct_rejection/";
76  // TString outdir = "./";
77  TString fcInputName (outdir + "mass_and_oct_rejection_FCInput_2019.root");
78 
79  //////////////////////////////////////////////////
80  // Load Nue and Numu experiments
81  //////////////////////////////////////////////////
82  //need numu only for prestage seeds
83  std::vector <const IPrediction * > preds;
84  std::vector <const IPrediction * > preds_numu_only;
85  std::vector <std::pair <TH1D*, double > > cosmics;
86  std::vector <std::pair <TH1D*, double > > cosmics_numu_only;
87  std::vector <Spectrum * > data;
88  std::vector <Spectrum * > data_numu_only;
89  std::vector <const IExperiment * > expts;
90  std::vector <const IExperiment * > expts_numu_only;
91 
92 
93  if(!numuOnly) {
94  if(FHCOnly || both ) {
95  preds.push_back(GetNuePrediction2019("combo", DefaultOscCalc(), corrSysts, "fhc", false)); // make decomp choosable?
96  cosmics.push_back(GetNueCosmics2019("fhc"));
97  }
98  if(RHCOnly || both ) {
99  preds.push_back(GetNuePrediction2019("prop", DefaultOscCalc(), corrSysts, "rhc", false)); //make decomp choosable?
100  cosmics.push_back(GetNueCosmics2019("rhc"));
101  }
102  }
103 
104  int nnumu = 4;
105  if(!nueOnly) {
106  if(FHCOnly || both ) {
107 
108  auto numu_preds = GetNumuPredictions2019(nnumu, corrSysts, "fhc");
109  preds.insert(preds.end(),numu_preds.begin(), numu_preds.end());
110  preds_numu_only.insert(preds_numu_only.end(),numu_preds.begin(), numu_preds.end());
111 
112  auto numu_cosmics = GetNumuCosmics2019(nnumu, "fhc");
113  cosmics.insert(cosmics.end(),numu_cosmics.begin(), numu_cosmics.end());
114  cosmics_numu_only.insert(cosmics_numu_only.end(),numu_cosmics.begin(), numu_cosmics.end());
115  }
116  if(RHCOnly || both ) {
117 
118  auto numu_preds = GetNumuPredictions2019(nnumu, corrSysts, "rhc");
119  preds.insert(preds.end(),numu_preds.begin(), numu_preds.end());
120  preds_numu_only.insert(preds_numu_only.end(),numu_preds.begin(), numu_preds.end());
121 
122  auto numu_cosmics = GetNumuCosmics2019(nnumu, "rhc");
123  cosmics.insert(cosmics.end(),numu_cosmics.begin(), numu_cosmics.end());
124  cosmics_numu_only.insert(cosmics_numu_only.end(),numu_cosmics.begin(), numu_cosmics.end());
125  }
126  }
127 
128 
129  if(!numuOnly){
130  if(FHCOnly || both ) data.push_back(GetNueData2019("fhc"));
131  if(RHCOnly || both ) data.push_back(GetNueData2019("rhc"));
132  }
133  if(!nueOnly){
134  if(FHCOnly || both ){
135  auto numu_data = GetNumuData2019(nnumu, "fhc");
136  data.insert(data.end(),numu_data.begin(), numu_data.end());
137  data_numu_only.insert(data_numu_only.end(),numu_data.begin(), numu_data.end());}
138  if(RHCOnly || both ){
139  auto numu_data = GetNumuData2019(nnumu, "rhc");
140  data.insert(data.end(),numu_data.begin(), numu_data.end());
141  data_numu_only.insert(data_numu_only.end(),numu_data.begin(), numu_data.end());}
142  }
143 
144  for(int i = 0; i < (int) preds.size(); ++i){
145  double POT;
146  if(FHCOnly) POT = kAna2019FHCPOT;
147  if(RHCOnly) POT = kAna2019RHCPOT;
148  if(both) {
149  if(nueOnly || both) {
150  if(i==0) POT = kAna2019FHCPOT;
151  if(i==1) POT = kAna2019RHCPOT;
152  }
153  if(numuOnly) {
154  if(i >= 0 && i < 4) POT = kAna2019FHCPOT;
155  if(i >= 4 && i < 8) POT = kAna2019RHCPOT;
156  }
157  if(both) {
158  if(i >= 2 && i < 6) POT = kAna2019FHCPOT;
159  if(i >= 6 && i < 10) POT = kAna2019RHCPOT;
160  }
161  }
162  expts.push_back(new SingleSampleExperiment(preds[i],*data[i], cosmics[i].first,cosmics[i].second));
163  }
164 
165  //make numu only experiment for seeds:
166  for(int i = 0; i < (int) preds_numu_only.size(); ++i){
167  double POT;
168  if(FHCOnly) POT = kAna2019FHCPOT;
169  if(RHCOnly) POT = kAna2019RHCPOT;
170  if(both) {
171  if(i >= 0 && i < 4) POT = kAna2019FHCPOT;
172  if(i >= 4 && i < 8) POT = kAna2019RHCPOT;
173  }
174  expts_numu_only.push_back(new SingleSampleExperiment(preds_numu_only[i],*data_numu_only[i], cosmics_numu_only[i].first,cosmics_numu_only[i].second));
175  }
176 
177  ////////////////////////////////////////////////////////////
178  // Add constraints, make experiments
179  ////////////////////////////////////////////////////////////
180  std::cout << "\nCreating multiexperiment\n" << std::endl;
181 
182  expts.push_back(WorldReactorConstraint2017());
183  if(nueOnly) {
184  std::cout << "Adding Dmsq32ConstraintPDG2017\n";
185  expts.push_back(&kDmsq32ConstraintPDG2017);
186  }
187  std::cout << "Creating Multiexperiment with a total of "
188  << expts.size() << " experiments\n\n" << std::endl;
189  auto exptThis = new MultiExperiment(expts);
190 
191  std::cout << "Creating Multiexperiment of numu only SimpleExp with a total of " << expts_numu_only.size() << " experiments\n\n" << std::endl;
192  auto exptThis_numu_only = new MultiExperiment(expts_numu_only);
193 
194 
195 
196  ////////////////////////////////////////////////////////////
197  // Systematics
198  ////////////////////////////////////////////////////////////
199  std::cout << "Systematics for the fit:\n";
200  auto systs = GetJointFitSystematicList(corrSysts, numuOnly, nueOnly, true, true, true);
201 
202  std::cout << "\n\nSystematic correlations...\n";
203  if(!nueOnly && ! numuOnly && corrSysts){
204  if(FHCOnly){
205  exptThis->SetSystCorrelations(0, GetCorrelations(true, true));
206  auto notfornumu = GetCorrelations(false, true);
207  for(int i =0; i < nnumu; ++i) exptThis->SetSystCorrelations(i+1, notfornumu);
208  }
209  if(RHCOnly){
210  exptThis->SetSystCorrelations(0, GetCorrelations(true, false));
211  auto notfornumu = GetCorrelations(false, true);
212  for(int i =0; i < nnumu; ++i) exptThis->SetSystCorrelations(i+1, notfornumu);
213  }
214  if(both){
215  exptThis->SetSystCorrelations(0, GetCorrelations(true, true));
216  exptThis->SetSystCorrelations(1, GetCorrelations(true, false));
217  auto notfornumu = GetCorrelations(false, true);
218  for(int i =0; i < 8; ++i) exptThis->SetSystCorrelations(i+2, notfornumu);
219  }
220  }
221 
222  std::cout << "Systematics for the numu only fit:\n";
223  auto systs_numu_only = GetJointFitSystematicList(corrSysts, false, true, true, true, true);
224 
225  /////////////////////////////////////////////////////////////////
226  // Fit
227  /////////////////////////////////////////////////////////////////
228  std::cout << "Starting the fit" << std::endl;
229 
231 
232  SystShifts auxShifts = SystShifts::Nominal();
233 
234  std::vector <SystShifts> seedShifts = {};
235 
236  //----------------------------------------
237  // Pre Fit
238  // ---------------------------------------
239  cout<<"------------------- Start prestage seeds --------------------------"<<endl;
240 
241  double pre_seed_th23;
242  double pre_seed_dmsq;
243  ResetOscCalcToDefault(calc);
244  auxShifts.ResetToNominal();
245 
246  double maxmix = 0.5; // from the numu results
247  double numu_pre_seedLONH, numu_pre_seedUONH, numu_pre_seedLOIH, numu_pre_seedUOIH, dmsq_numu_pre_seedNH, dmsq_numu_pre_seedIH;
248 
249  Fitter fitnumu_only(exptThis_numu_only,
251  {});
252  double minchi_numu = fitnumu_only.Fit(calc, auxShifts,
253  {{&kFitDmSq32, {2.5e-3}},
254  {&kFitSinSqTheta23, {0.4}}},
255  {},
256  Fitter::kQuiet);
257  pre_seed_th23 = kFitSinSqTheta23.GetValue(calc);
258  pre_seed_dmsq = kFitDmSq32.GetValue(calc);
259 
260  numu_pre_seedLONH = ((pre_seed_th23>maxmix)?(2*maxmix-pre_seed_th23):pre_seed_th23);
261  numu_pre_seedUONH = ((pre_seed_th23>maxmix)?pre_seed_th23:(2*maxmix-pre_seed_th23));
262 
263  ResetOscCalcToDefault(calc);
264  auxShifts.ResetToNominal();
265 
266  cout << "---------------------- End prestage seeds ----------------\n";
267  cout << "-------------------- Start Best fit ---------------------\n";
268  ////////////////////////////////////////////////////////////////////
269  // Best Fit
270  ////////////////////////////////////////////////////////////////////
271  std::vector<double> bf_delta_seeds = {0., 0.5, 1., 1.5};
272  std::vector<double> bf_th23_seeds = {numu_pre_seedLONH,
273  maxmix,
274  numu_pre_seedUONH};
275  std::map <const IFitVar*, std::vector<double>> bf_seedPts =
276  {{&kFitSinSqTheta23, bf_th23_seeds},
277  {&kFitDeltaInPiUnits, bf_delta_seeds},
278  {&kFitDmSq32, {fabs(pre_seed_dmsq), -1*(pre_seed_dmsq)}},
279  {&kFitSinSq2Theta13, {0.082}}};
280  std::vector <const IFitVar*> bestVars =
283  Fitter bestfit(exptThis, bestVars, systs);
284  double chi_best = bestfit.Fit(calc,
285  auxShifts,
286  bf_seedPts,
287  {},
288  Fitter::kQuiet);
289 
290  std::cout << "Best chi: " << chi_best << endl;
291  std::cout << "Best parameters --->" << endl;
292  for(const IFitVar* var : bestVars)
293  std::cout << var->ShortName() << ": " << var->GetValue(calc) << ", ";
294  std::cout << "\nBest Syst Shifts --->" << endl;
295  for(const ISyst* s : systs)
296  std::cout << s->ShortName() << ": " << auxShifts.GetShift(s) << ", ";
297  std::cout << "-----------------------------------------------------------\n";
298 
299  /////////////////////////////////////////////////////////////////////
300  // IH fit
301  /////////////////////////////////////////////////////////////////////
302  TFile* fcInput = new TFile(fcInputName, "recreate");
303  ResetOscCalcToDefault(calc);
304  auxShifts.ResetToNominal();
305 
306  std::vector<double> ih_delta_seeds = bf_delta_seeds;
307  std::vector<double> ih_th23_seeds = bf_th23_seeds;
308  std::map <const IFitVar*, std::vector<double>> ih_seedPts =
309  {{&kFitSinSqTheta23, ih_th23_seeds},
310  {&kFitDeltaInPiUnits, ih_delta_seeds},
311  {&kFitDmSq32InvertedHierarchy, {-1*fabs(pre_seed_dmsq)}},
312  {&kFitSinSq2Theta13, {0.082}}};
313  std::vector <const IFitVar*> ihVars =
315  &kFitSinSqTheta23, &kFitSinSq2Theta13};
316  Fitter ihfit(exptThis, ihVars, systs);
317  double chi_ih = ihfit.Fit(calc,
318  auxShifts,
319  ih_seedPts,
320  {},
321  Fitter::kQuiet);
322  std::cout << "IH chi: " << chi_ih << std::endl;
323  for(const IFitVar* var : ihVars)
324  std::cout << var->ShortName() << ": " << var->GetValue(calc) << ", ";
325  std::cout << "\nIH Syst Shifts --->" << endl;
326  for(const ISyst* s : systs)
327  std::cout << s->ShortName() << ": " << auxShifts.GetShift(s) << ", ";
328  std::cout << "-----------------------------------------------------------\n";
329 
330  std::map<const IFitVar*, TGraph*> profVarsMapIH;
331  std::map< const ISyst*, TGraph*> systMapIH;
332  MakeMaps(ihVars, profVarsMapIH, systs, systMapIH);
333 
334 
335  for(const IFitVar* var: ihVars) {
336  profVarsMapIH[var]->SetPoint(0, 0, var->GetValue(calc));
337  std::cout << var->ShortName() << ": " << var->GetValue(calc) << ", ";
338  }
339  std::cout << endl;
340  for(const ISyst* s: systs) {
341  systMapIH[s]->SetPoint(0, 0, auxShifts.GetShift(s));
342  std::cout << s->ShortName() << ": " << auxShifts.GetShift(s) << ", ";
343  }
344  std::cout << endl;
345  SaveMaps(fcInput, ihVars, profVarsMapIH,
346  systs, systMapIH, chi_ih - chi_best, "IH");
347 
348  /////////////////////////////////////////////////////////////////////
349  // LO fit
350  /////////////////////////////////////////////////////////////////////
351  ResetOscCalcToDefault(calc);
352  auxShifts.ResetToNominal();
353 
354  std::vector<double> lo_delta_seeds = bf_delta_seeds;
355  std::vector<double> lo_th23_seeds = {numu_pre_seedLONH, 0.499};
356  std::map <const IFitVar*, std::vector<double>> lo_seedPts =
357  {{kFitSinSqTheta23LowerOctant, lo_th23_seeds},
358  {&kFitDeltaInPiUnits, lo_delta_seeds},
359  {&kFitDmSq32, {-1*fabs(pre_seed_dmsq), fabs(pre_seed_dmsq)}},
360  {&kFitSinSq2Theta13, {0.082}}};
361  std::vector <const IFitVar*> loVars =
363  kFitSinSqTheta23LowerOctant, &kFitSinSq2Theta13};
364  Fitter lofit(exptThis, loVars, systs);
365  double chi_lo = lofit.Fit(calc,
366  auxShifts,
367  lo_seedPts,
368  {},
369  Fitter::kQuiet);
370  std::cout << "LO chi: " << chi_lo << std::endl;
371  for(const IFitVar* var : loVars)
372  std::cout << var->ShortName() << ": " << var->GetValue(calc) << ", ";
373  std::cout << "\nLO Syst Shifts --->" << endl;
374  for(const ISyst* s : systs)
375  std::cout << s->ShortName() << ": " << auxShifts.GetShift(s) << ", ";
376  std::cout << "-----------------------------------------------------------\n";
377 
378  std::map<const IFitVar*, TGraph*> profVarsMapLO;
379  std::map< const ISyst*, TGraph*> systMapLO;
380  MakeMaps(loVars, profVarsMapLO, systs, systMapLO);
381 
382 
383  for(const IFitVar* var: loVars) {
384  profVarsMapLO[var]->SetPoint(0, 0, var->GetValue(calc));
385  std::cout << var->ShortName() << ": " << var->GetValue(calc) << ", ";
386  }
387  std::cout << endl;
388  for(const ISyst* s: systs) {
389  systMapIH[s]->SetPoint(0, 0, auxShifts.GetShift(s));
390  std::cout << s->ShortName() << ": " << auxShifts.GetShift(s) << ", ";
391  }
392  std::cout << endl;
393  SaveMaps(fcInput, loVars, profVarsMapLO,
394  systs, systMapLO, chi_lo - chi_best, "LO");
395 
396 
397  //////////////////////////////////////////////////////
398  // Constrained Fits
399  //////////////////////////////////////////////////////
400  for(bool nh : {true, false}){
401  for(bool lo: {true, false}){
402  TString pars = lo? "LO" : "UO";
403  pars += nh? "NH": "IH";
404  std::cout << " *** Starting " << pars << " Fit *** " << std::endl;
405 
406  std::vector<double> delta_seeds = {0., 0.5, 1., 1.5};
407  std::vector<double> th23_seeds = {lo? numu_pre_seedLONH : numu_pre_seedUONH};
408  if(!lo) th23_seeds.push_back(maxmix);
409  std::vector<double> dmsq_seeds = {nh? abs(pre_seed_dmsq) : -1 * abs(pre_seed_dmsq)};
410 
411  const IFitVar* th23_fit_var;
412  const IFitVar* dmsq_fit_var;
413  if(nh) dmsq_fit_var = &kFitDmSq32NormalHierarchy;
414  else dmsq_fit_var = &kFitDmSq32InvertedHierarchy;
415  if(lo) th23_fit_var = kFitSinSqTheta23LowerOctant;
416  else th23_fit_var = kFitSinSqTheta23UpperOctant;
417 
418  std::map <const IFitVar*, std::vector<double>> seed_pts =
419  {{th23_fit_var, th23_seeds},
420  {&kFitDeltaInPiUnits, delta_seeds},
421  {dmsq_fit_var, {dmsq_seeds}},
422  {&kFitSinSq2Theta13, {0.082}}};
423  std::vector <const IFitVar*> fit_vars =
424  {&kFitDeltaInPiUnits, dmsq_fit_var,
425  th23_fit_var, &kFitSinSq2Theta13};
426  Fitter lo_fit(exptThis, fit_vars, systs);
427  ResetOscCalcToDefault(calc);
428  auxShifts.ResetToNominal();
429 
430  double chi_constrained = lo_fit.Fit(calc,
431  auxShifts,
432  seed_pts,
433  {},
434  Fitter::kQuiet);
435 
436  // Save best fit results in FC Input to generate
437  // mock experiments later
438  std::map<const IFitVar*, TGraph*> profVarsMap;
439  std::map< const ISyst*, TGraph*> systMap;
440  MakeMaps(bestVars, profVarsMap, systs, systMap);
441 
442 
443  for(const IFitVar* var: bestVars) {
444  profVarsMap[var]->SetPoint(0, 0, var->GetValue(calc));
445  std::cout << var->ShortName() << ": " << var->GetValue(calc) << ", ";
446  }
447  std::cout << endl;
448  for(const ISyst* s: systs) {
449  systMap[s]->SetPoint(0, 0, auxShifts.GetShift(s));
450  std::cout << s->ShortName() << ": " << auxShifts.GetShift(s) << ", ";
451  }
452  std::cout << endl;
453  SaveMaps(fcInput, bestVars, profVarsMap,
454  systs, systMap, chi_constrained - chi_best, pars);
455  }
456  }
457 
458 }
TSpline3 lo("lo", xlo, ylo, 12,"0")
void ResetOscCalcToDefault(osc::IOscCalcAdjustable *calc)
Reset calculator to default assumptions for all parameters.
Definition: Calcs.cxx:23
std::vector< SystGroupDef > systs
Definition: syst_header.h:385
fvar< T > fabs(const fvar< T > &x)
Definition: fabs.hpp:15
void SaveMaps(TDirectory *dir, std::vector< const IFitVar * > profvars, std::map< const IFitVar *, TGraph * > &profMap, std::vector< const ISyst * > systs, std::map< const ISyst *, TGraph * > &systMap, double dchi_sq, TString pars)
double GetValue(const osc::IOscCalcAdjustable *osc) const override
std::vector< const ISyst * > GetJointFitSystematicList(bool corrSysts, bool nueExclusive=false, bool numuExclusive=false, bool intersection=true)
const FitDmSq32 kFitDmSq32
Definition: FitVars.cxx:18
Simple record of shifts applied to systematic parameters.
Definition: SystShifts.h:20
std::vector< const IPrediction * > GetNumuPredictions2019(const int nq=4, bool useSysts=true, std::string beam="fhc", bool GetFromUPS=false, ENu2018ExtrapType numuExtrap=kNuMu, bool minimizeMemory=false, bool NERSC=false)
const Dmsq32Constraint kDmsq32ConstraintPDG2017(2.45e-3, 0.05e-3, 2.52e-3, 0.05e-3)
void abs(TH1 *hist)
Float_t tmp
Definition: plot.C:36
osc::OscCalcDumb calc
osc::IOscCalcAdjustable * DefaultOscCalc()
Create a new calculator with default assumptions for all parameters.
Definition: Calcs.cxx:49
Encapsulate code to systematically shift a caf::SRProxy.
Definition: ISyst.h:14
const IPrediction * GetNuePrediction2019(std::string decomp, osc::IOscCalc *calc, bool corrSysts, std::string beam, bool isFakeData, bool GetFromUPS=false, bool minimizeMemory=false, bool NERSC=false)
const XML_Char const XML_Char * data
Definition: expat.h:268
const XML_Char * s
Definition: expat.h:262
T GetShift(const ISyst *syst) const
const ReactorExperiment * WorldReactorConstraint2017()
Reactor constraint from PDG 2017.
void make_mass_and_oct_fc_input_2019(TString beamMode="both", TString analysis="joint", bool corrSysts=true)
void MakeMaps(std::vector< const IFitVar * > profvars, std::map< const IFitVar *, TGraph * > &profMap, std::vector< const ISyst * > systs, std::map< const ISyst *, TGraph * > &systMap)
const IConstrainedFitVar * kFitSinSqTheta23LowerOctant
OStream cout
Definition: OStream.cxx:6
std::vector< double > POT
Spectrum * GetNueData2019(std::string beam, bool GetFromUPS=false)
const double kAna2019RHCPOT
Definition: Exposures.h:224
Combine multiple component experiments.
std::string pars("Th23Dmsq32")
std::vector< std::pair< TH1D *, double > > GetNumuCosmics2019(const int nq=4, std::string beam="fhc", bool GetFromUPS=false, bool NERSC=false)
std::vector< Spectrum * > GetNumuData2019(const int nq=4, std::string beam="fhc", bool GetFromUPS=false)
TDirectory * dir
Definition: macro.C:5
void ResetToNominal()
Definition: SystShifts.cxx:143
const ConstrainedFitVarWithPrior fitSsqTh23_UniformPriorSsqTh23 & kFitSinSqTheta23
assert(nhit_max >=nhit_nbins)
const double kAna2019FHCPOT
Definition: Exposures.h:223
Interface definition for fittable variables.
Definition: IFitVar.h:16
std::vector< std::pair< const ISyst *, const ISyst * > > GetCorrelations(bool isNue)
const FitSinSq2Theta13 kFitSinSq2Theta13
Definition: FitVars.cxx:13
const FitDmSq32InvertedHierarchy kFitDmSq32InvertedHierarchy
Definition: FitVars.cxx:23
const FitVarWithPrior fitDeltaInPiUnits_UniformPriordCP & kFitDeltaInPiUnits
const FitDmSq32NormalHierarchy kFitDmSq32NormalHierarchy
Definition: FitVars.cxx:20
const IConstrainedFitVar * kFitSinSqTheta23UpperOctant
const std::string outdir
std::pair< TH1D *, double > GetNueCosmics2019(std::string beam, bool GetFromUPS=false, bool NERSC=false)
Compare a single data spectrum to the MC + cosmics expectation.