make_fc_mass_and_oct_nersc_2018.C
Go to the documentation of this file.
2 #include "CAFAna/Core/Spectrum.h"
4 
7 
10 
11 #include "CAFAna/Vars/FitVars.h"
12 
13 #include "CAFAna/FC/FCPoint.h"
14 #include "CAFAna/FC/FCCollection.h"
15 #include "CAFAna/FC/FCSurface.h"
16 
20 
22 
23 #include "CAFAna/Analysis/Calcs.h"
24 #include "OscLib/IOscCalc.h"
25 
26 #include "TRandom3.h"
27 #include "TH1.h"
28 #include "TGraph.h"
29 
30 using namespace ana;
31 
32 
33 void make_fc_mass_and_oct_nersc_2018(TString options, int NPts, int N, int jid, int npts_flush = 0)
34 {
35 
36  // specify octant and hierarchy as the option arg
37  assert(options == "LOIH" || options == "LONH" ||
38  options == "UOIH" || options == "UONH");
39  bool lo = options.Contains("LO");
40  bool nh = options.Contains("NH");
41 
42  std::string fcout = TString::Format("FCCol_%s_number_v%d_%d.root", options.Data(), N, jid).Data();
43 // std::string fcout = "FCCol_" + options.Data() + "_number_v"
44 // + number
45 // + "_"
46 // + std::to_string(jid)
47 // +".root";
48 
49  FCCollection fccol;
51 
52  double thisPOT;
53  double thisLivetime;
54 
55  // Grab the systs
56  // bools to make the function calls a little more readable
57  bool nueOnly = true;
58  bool numuOnly= true;
59  bool isFHC = true;
60  bool isRHC = true;
61 
62  // joint
63  std::vector<const ISyst*> systs = GetJointFitSystematicList(true, !nueOnly, !numuOnly, true, true, true);
64 
65  // nue fhc
66  std::vector<const ISyst*> snue_fhc = getAllAna2018Systs(kNueAna2018, true, kFHC);
67 
68  // nue rhc
69  std::vector<const ISyst*> snue_rhc = getAllAna2018Systs(kNueAna2018, true, kRHC);
70 
71  // numu
72  std::vector<const ISyst*> snumu = GetJointFitSystematicList(true, !nueOnly, numuOnly, isFHC, isRHC, true);
73 
74  // We're setting up the requisite inputs to the nue experiment
75  // nue prediction
76  std::vector <const IPrediction*> nue_preds;
77  std::vector <std::pair <TH1D*, double > > nue_cosmics;
78  std::vector <Spectrum> nue_cosmics_spectra;
79  bool minimizeMemory = true;
80 
81  // Grab the nue predictions for fhc and rhc
82  nue_preds.push_back(GetNuePrediction2018("combo", calc, true, "fhc", false, false, minimizeMemory, true));
83  nue_preds.push_back(GetNuePrediction2018("prop", calc, true, "rhc", false, false, minimizeMemory, true));
84 
85  std::cout << "\nDone getting Nue Predictions\n\n" ;
86 
87  nue_cosmics.push_back(GetNueCosmics2018("fhc", false, true));
88  nue_cosmics.push_back(GetNueCosmics2018("rhc", false, true));
89 
90  // We need to store cosmic hists as spectra to add into our fake data
91  // FHC and RHC have different POT and Livetimes
92  for(int i = 0; i < 2; i++) {
93  if(i==0) {
94  thisPOT = kAna2018FHCPOT;
95  thisLivetime = kAna2018FHCLivetime;
96  }
97  else {
98  thisPOT = kAna2018RHCPOT;
99  thisLivetime = kAna2018RHCLivetime;
100  }
101  nue_cosmics_spectra.push_back(Spectrum(nue_cosmics[i].first,
102  thisPOT, thisLivetime));
103  }
104 
105 
106  //////////////////////////////////////////////////////////////////////
107  // Numu Prediction
108  //////////////////////////////////////////////////////////////////////
109  std::vector<const IPrediction*> numu_preds;
110  std::vector< std::pair<TH1D*, double> > numu_cosmics;
111  std::vector<Spectrum> numu_cosmics_spectra;
112 
113  std::vector<const IPrediction*> this_numu_preds;
114  std::vector< std::pair<TH1D*, double> > this_numu_cosmics;
115 
116  // Construct numu inputs
117  for(std::string beam : {"fhc", "rhc"}){
118  this_numu_preds = GetNumuPredictions2018(4,true, beam, false, kNuMu, minimizeMemory, true);
119  this_numu_cosmics = GetNumuCosmics2018(4, beam, false, true);
120  numu_preds.insert(numu_preds.end(),
121  this_numu_preds.begin(),
122  this_numu_preds.end());
123  numu_cosmics.insert(numu_cosmics.end(),
124  this_numu_cosmics.begin(),
125  this_numu_cosmics.end());
126 
127  for(std::pair<TH1D*, double> h : this_numu_cosmics){
128  thisPOT = kAna2018FHCPOT;
129  thisLivetime = kAna2018FHCLivetime;
130  if(beam == "rhc") {
131  thisPOT = kAna2018RHCPOT;
132  thisLivetime = kAna2018RHCLivetime;
133  }
134  numu_cosmics_spectra.push_back(Spectrum(h.first, thisPOT, thisLivetime));
135  }
136 
137  }
138 
139  // Grab analysis slices to find the bin centers and the best
140  // fit point
141  std::string helperupsname = std::string(getenv("FCHELPERANA2018_LIB_PATH"));
142 
143  std::string helpername =
144  helperupsname
145  + "/FCInput/"
146  + "mass_and_oct_rejection_FCInput_2018.root";
147 
148  // helperupsname
149  // + "/FCInput/"
150  // + "/slices_FCInput_2018_joint_realData_bothcombo_systs_th23_noOct.root";
151 
152  TFile* fchelp = TFile::Open(helpername.c_str());
153 
154  TGraph* hssth23 = (TGraph*)fchelp->Get(options+"_ssth23");
155  TGraph *hdmsq32 = (TGraph*)fchelp->Get(options+"_dmsq32");
156  double true_th23 = hssth23->Eval(0);
157  double true_dmsq = hdmsq32->Eval(0);
158 
159 
160  // Get profiled parameters at best fit
161  TGraph *hdelta = (TGraph*)fchelp->Get(options+"_delta(pi)");
162  TGraph *hss2th13 = (TGraph*)fchelp->Get(options+"_ss2th13");
163 
164  //// double seeddmsq32 = hdmsq32->Eval(0.);
165  double seeddelta = hdelta->Eval(0.);
166  double seedss2th13 = hss2th13->Eval(0.);
167  std::cout << "Got all of the parameters to make mock data" << endl;
168 
169  delete hssth23;
170  delete hdmsq32;
171  delete hdelta;
172  delete hss2th13;
173 
174  // Now, look for all the systematics
175  std::map<std::string,double> seedsyst;
176  for(const ISyst* syst :systs) {
177  TGraph* h = (TGraph*) fchelp->Get((options+"_"+syst->ShortName()).Data());
178  if(!h){
179  std::cout << "Don't see a prof hist for " << options+"_"+syst->ShortName() << ". Continuing, but check your ups version." << std::endl;
180  continue;
181  }
182  double seedval = h->Eval(0);
183 
184  seedsyst.insert(std::pair<std::string,double>(syst->ShortName(),seedval));
185  }
186 
187 
188  // Now everything is set up, we can start throwing FC mock experiments
189 
190  for(int i = 0; i < NPts; i++){
191  ResetOscCalcToDefault(calc);
192 
193 
194  // The variable you're plotting isn't a nuisance parameter, should
195  // be set to the trueX that you threw for this experiment.
196  // Other oscillation parameters are nuisance parameters and
197  // should be seeded at their best fit
198  kFitDeltaInPiUnits.SetValue(calc, seeddelta);
199  kFitSinSq2Theta13.SetValue(calc, seedss2th13);
200  kFitDmSq32.SetValue(calc, true_dmsq);
201  kFitSinSqTheta23LowerOctant->SetValue(calc, true_th23);
202 
203  // Set syst shift - they're nuisance parameters, so set them
204  // to the best fit. Nue and Numu predictions are taught about
205  // slightly different sets of systematics, so we need to throw
206  // the predictions with different seeds
207  SystShifts seednue_fhc;
208  for(const ISyst *syst : snue_fhc){
209  if(seedsyst.find(syst->ShortName()) == seedsyst.end()) continue;
210  seednue_fhc.SetShift(syst, seedsyst[syst->ShortName()]);
211  }
212  SystShifts seednue_rhc;
213  for(const ISyst *syst : snue_rhc){
214  if(seedsyst.find(syst->ShortName()) ==seedsyst.end()) continue;
215  seednue_rhc.SetShift(syst, seedsyst[syst->ShortName()]);
216  }
217  SystShifts seednumu;
218  for(const ISyst *syst : snumu){
219  if(seedsyst.find(syst->ShortName()) ==seedsyst.end()) continue;
220  seednumu.SetShift(syst, seedsyst[syst->ShortName()]);
221  }
222 
223  // Make a mock data spectrum for nue
224  // use mock data + cosmic as predictions
225  double mock_integral_fhc = 0;
226  double mock_integral_rhc = 0;
227  assert(nue_preds.size()==2 && "Something is wrong with nue preds. Size !=2");
228  std::vector<Spectrum> mocknue;
229  SystShifts this_seednue;
230  for (int j = 0; j < (int) nue_preds.size(); j++){
231  std::cout << "\n\n Lets make some nue fake data \n\n";
232  double thisPOT = j == 0? kAna2018FHCPOT : kAna2018RHCPOT;
233  std::cout << "Getting fake data for j=" << std::to_string(j);
234  if(j==0) this_seednue = seednue_fhc;
235  else this_seednue = seednue_rhc;
236  Spectrum fakenue = nue_preds[j]->PredictSyst(calc,this_seednue);
237  std::cout << "\n\n Thats some nice nue fake data \n\n";
238  // Add in cosmic prediction here, make sure it gets Poisson fluctuated
239  fakenue += nue_cosmics_spectra[j];
240  mocknue.push_back(fakenue.MockData(thisPOT));
241  // Save this, for posterity's sake
242  if(j==0) mock_integral_fhc += mocknue[j].Integral(thisPOT);
243  if(j==1) mock_integral_rhc += mocknue[j].Integral(thisPOT);
244  }
245 
246  std::cout << "\n\n Got Nue Preds \n\n";
247  std::vector<Spectrum> mocknumu;
248  // Make a mock data spectrum for numu
249  assert(numu_cosmics_spectra.size()==8 && "Issue with N quantiles in cosmics");
250  assert(numu_preds.size()==8 && "Issue with N quantiles in predictions");
251  for (int j = 0; j < 8; j++){
252  double thisPOT = kAna2018FHCPOT;
253  if(j > 3) thisPOT = kAna2018RHCPOT;
254  Spectrum fakenm = numu_preds[j]->PredictSyst(calc,seednumu);
255  fakenm += numu_cosmics_spectra[j]; // Again, add cosmic spectra pre-fluctuation
256  mocknumu.push_back(fakenm.MockData(thisPOT)); // Fluctuate
257  }
258  std::cout << "Got Numu Preds" << endl;
259 
260 
261  // Set up experiment, nova nue + nova numu (4 quantiles) + PDG reactor
262  std::vector<const IExperiment*> expts;
263  std::vector<const IExperiment*> numu_expts;
264  // Nue experiments
265  for(int j = 0; j < 2; j++) {
266  expts.push_back(new SingleSampleExperiment(nue_preds[j], mocknue[j],
267  nue_cosmics[j].first,
268  nue_cosmics[j].second)); // Nue
269  }
270  for (int j = 0; j < 8; j++) {
271  expts.push_back(new SingleSampleExperiment(numu_preds[j], mocknumu[j],
272  numu_cosmics[j].first,
273  numu_cosmics[j].second));
274  numu_expts.push_back(new SingleSampleExperiment(numu_preds[j], mocknumu[j],
275  numu_cosmics[j].first,
276  numu_cosmics[j].second));
277 
278  }
279 
280  // Add reactor
281  expts.push_back( WorldReactorConstraint2017() );
282  numu_expts.push_back(WorldReactorConstraint2017());
283  MultiExperiment expt(expts);
284  MultiExperiment numu_expt(numu_expts);
285 
286  // Correlate your systs
287  // A bit tricky since nue and numu predictions know about a
288  // different list of systs, but there are functions to do this
289  // in joint_fit_2018_tools.h
290  expt.SetSystCorrelations(0, GetCorrelations(true,true));
291  expt.SetSystCorrelations(1, GetCorrelations(true, false));
292 
293  auto notfornumu = GetCorrelations(false, false);
294 
295  for(int j = 0; j < 8; j++) {
296  expt.SetSystCorrelations(j+2, notfornumu);
297  }
298 
299  // Finally, we get to do some FC
300  //////////////////////////////////////////////////////////////////
301  // Use numu only fit to find th23 and dmsq seeds for the joint fit
302  //////////////////////////////////////////////////////////////////
303 
305  SystShifts auxShifts = SystShifts::Nominal();
306  double maxmixing = 0.514;
307  MinuitFitter fitnumu_only(&numu_expt, {kFitSinSqTheta23LowerOctant, &kFitDmSq32});
308 
309  std::cout << "\nFinding the seeds from numu only fit" << endl;
310  double minchi_numu = fitnumu_only.Fit(numu_calc, auxShifts,
311  {{&kFitDmSq32, {-2.35e-3}},
312  {kFitSinSqTheta23LowerOctant, {0.4}}},
313  {},
314  IFitter::kQuiet)->EvalMetricVal();
315  double pre_seed_th23 = kFitSinSqTheta23LowerOctant->GetValue(numu_calc);
316  double pre_seed_dmsq = kFitDmSq32.GetValue(numu_calc);
317 
318  double pre_seed_th23_LO = ( pre_seed_th23 > maxmixing ) ?
319  (2*maxmixing - pre_seed_th23) : pre_seed_th23;
320  double pre_seed_th23_UO = ( pre_seed_th23 > maxmixing ) ?
321  pre_seed_th23 : (2*maxmixing-pre_seed_th23);
322  if(pre_seed_th23_LO > 0.5) pre_seed_th23_LO = 0.45;
323 
324  // done getting pre seeds
325  //-----------------------------------------------------------------
326 
327  // Set up fitter for chi best
328  // make a vector of oscillation parameters that are our
329  // nuisance parameters
330  const IFitVar* th23_fit_var;
331  const IFitVar* dmsq_fit_var;
332  if(nh) dmsq_fit_var = &kFitDmSq32NormalHierarchy;
333  else dmsq_fit_var = &kFitDmSq32InvertedHierarchy;
334  if(lo) th23_fit_var = kFitSinSqTheta23LowerOctant;
335  else th23_fit_var = kFitSinSqTheta23UpperOctant;
336  std::vector<const IFitVar*> constrained_fitVars = {&kFitDeltaInPiUnits,
337  th23_fit_var,
339  dmsq_fit_var};
340 
341  MinuitFitter constrained_fit(&expt, constrained_fitVars, systs);
342  SystShifts seedShifts = {};
343 
344  double bestdelta = 0;
345  double bestssth23 = 0;
346  double bestth13 = 0;
347  double bestdmsq = 0;
348  double bestchi = 1e10;
349  double cf_dmsq = 0;
350  double cf_delta = 0;
351  double cf_ssth23 = 0;
352  double cf_th13 = 0;
353 
354  std::vector <double> cf_delta_seeds = {0., 0.5, 1.0, 1.5};
355  std::vector <double> th23_seeds = {lo? pre_seed_th23_LO : pre_seed_th23_UO};
356  std::vector <double> dmsq_seeds = {nh? abs(pre_seed_dmsq) : -1 * abs(pre_seed_dmsq)};
357  std::map <const IFitVar*, std::vector<double>> cf_seedPts =
358  {{th23_fit_var, th23_seeds},
359  {&kFitDeltaInPiUnits, cf_delta_seeds},
360  {dmsq_fit_var, dmsq_seeds}};
361  std::cout << "Starting " << options << " fit ----->" << endl;
362  auxShifts.ResetToNominal();
363  double chi_cf = constrained_fit.Fit(calc,
364  auxShifts,
365  cf_seedPts,
366  {},
367  IFitter::kQuiet)->EvalMetricVal();
368  cf_dmsq = kFitDmSq32.GetValue(calc);
369  cf_delta = kFitDeltaInPiUnits.GetValue(calc);
370  cf_ssth23 = kFitSinSqTheta23LowerOctant->GetValue(calc);
371  cf_th13 = kFitSinSq2Theta13.GetValue(calc);
372 
373  std::vector <double> bf_delta_seeds = {0., 0.5, 1.0, 1.5};
374  std::vector <double> bf_ssth23_seeds = {pre_seed_th23_LO, pre_seed_th23_UO, maxmixing};
375  std::map <const IFitVar*, std::vector<double>> bf_seedPts =
376  {{&kFitSinSqTheta23, bf_ssth23_seeds},
377  {&kFitDeltaInPiUnits, bf_delta_seeds},
378  {&kFitDmSq32, {fabs(pre_seed_dmsq), -1*fabs(pre_seed_dmsq)}},
379  {&kFitSinSq2Theta13, {0.082}}};
380 
381  std::vector <const IFitVar*> bestVars =
383  MinuitFitter bestfit(&expt, bestVars, systs);
384 
385  std::cout << "Starting the best fit ----->" << endl;
386  auxShifts.ResetToNominal();
387  double chi_bf = bestfit.Fit(calc,
388  auxShifts,
389  bf_seedPts,
390  {},
391  IFitter::kQuiet)->EvalMetricVal();
392  bestdmsq = kFitDmSq32.GetValue(calc);
393  bestssth23 = kFitSinSqTheta23.GetValue(calc);
394  bestdelta = kFitDeltaInPiUnits.GetValue(calc);
395  bestth13 = kFitSinSq2Theta13.GetValue(calc);
396  //bestchi = std::min(chi_cf, chi_bf);
397  bestchi = chi_bf;
398 
399  FCPoint pt(seeddelta, true_th23, seedss2th13, true_dmsq,
400  pre_seed_th23, pre_seed_dmsq,
401  cf_delta, cf_ssth23, cf_th13, cf_dmsq,
402  chi_cf,
403  bestdelta, bestssth23, bestth13, bestdmsq,
404  bestchi);
405 
406  fccol.AddPoint(pt);
407  unsigned int nfc_pts = fccol.NPoints();
408 
409  if(npts_flush != 0){
410  if(nfc_pts % npts_flush == 0){
411  std::cout << "Saving " + std::to_string(nfc_pts) +
412  " points to " << fcout << endl;
413  fccol.SaveToFile(fcout);
414  }
415  }
416  } // end loop over N points
417  fccol.SaveToFile(fcout);
418 }
419 
void make_fc_mass_and_oct_nersc_2018(TString options, int NPts, int N, int jid, int npts_flush=0)
TSpline3 lo("lo", xlo, ylo, 12,"0")
Cuts and Vars for the 2020 FD DiF Study.
Definition: vars.h:6
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
double GetValue(const osc::IOscCalcAdjustable *osc) const override
Definition: FitVars.cxx:141
double GetValue(const osc::IOscCalcAdjustable *osc) const override
double GetValue(const osc::IOscCalcAdjustable *osc) const override
Forward to wrapped Var&#39;s GetValue()
const FitDmSq32 kFitDmSq32
Definition: FitVars.cxx:18
Simple record of shifts applied to systematic parameters.
Definition: SystShifts.h:20
void SetValue(osc::IOscCalcAdjustable *osc, double val) const override
Definition: FitVars.cxx:177
double GetValue(const osc::IOscCalcAdjustable *osc) const override
Definition: FitVars.cxx:171
const FitSinSqTheta23UpperOctant kFitSinSqTheta23UpperOctant
Definition: FitVars.cxx:16
void AddPoint(const FCPoint &p)
Definition: FCCollection.h:17
void abs(TH1 *hist)
void SetValue(osc::IOscCalcAdjustable *osc, double val) const override
Forward to wrapped Var&#39;s SetValue()
std::vector< const IPrediction * > GetNumuPredictions2018(const int nq=4, bool useSysts=true, std::string beam="fhc", bool GetFromUPS=false, ENu2018ExtrapType numuExtrap=kNuMu, bool minimizeMemory=false, bool NERSC=false)
double Integral(double exposure, double *err=0, EExposureType expotype=kPOT) const
Return total number of events scaled to pot.
Definition: Spectrum.cxx:249
void SetValue(osc::IOscCalcAdjustable *osc, double val) const override
Definition: FitVars.cxx:48
static SystShifts Nominal()
Definition: SystShifts.h:34
double GetValue(const osc::IOscCalcAdjustable *osc) const override
Definition: FitVars.cxx:42
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
Spectrum MockData(double pot, int seed=0) const
Mock data is FakeData with Poisson fluctuations applied.
Definition: Spectrum.cxx:300
Representation of a spectrum in any variable, with associated POT.
Definition: Spectrum.h:40
const double kAna2018RHCPOT
Definition: Exposures.h:208
unsigned int NPoints() const
Definition: FCCollection.h:26
Represents the results of a single Feldman-Cousins pseudo-experiment.
Definition: FCPoint.h:8
std::vector< const ISyst * > getAllAna2018Systs(const EAnaType2018 ana, const bool smallgenie, const BeamType2018 beam, bool isFit)
expt
Definition: demo5.py:34
std::string getenv(std::string const &name)
virtual std::unique_ptr< IFitSummary > Fit(osc::IOscCalcAdjustable *seed, SystShifts &bestSysts=junkShifts, const SeedList &seedPts=SeedList(), const std::vector< SystShifts > &systSeedPts={}, Verbosity verb=kVerbose) const
Master fitting method. Depends on FitHelper and FitHelperSeeded.
Definition: IFitter.cxx:69
const ReactorExperiment * WorldReactorConstraint2017()
Reactor constraint from PDG 2017.
const double j
Definition: BetheBloch.cxx:29
void SetValue(osc::IOscCalcAdjustable *osc, double val) const override
Definition: FitVars.cxx:147
std::vector< float > Spectrum
Definition: Constants.h:610
std::vector< std::pair< TH1D *, double > > GetNumuCosmics2018(const int nq=4, std::string beam="fhc", bool GetFromUPS=false, bool NERSC=false)
static bool isFHC
OStream cout
Definition: OStream.cxx:6
Combine multiple component experiments.
std::pair< TH1D *, double > GetNueCosmics2018(std::string beam, bool GetFromUPS=false, bool NERSC=false)
const FitSinSqTheta23LowerOctant kFitSinSqTheta23LowerOctant
Definition: FitVars.cxx:17
void ResetToNominal()
Definition: SystShifts.cxx:144
const ConstrainedFitVarWithPrior fitSsqTh23_UniformPriorSsqTh23 & kFitSinSqTheta23
assert(nhit_max >=nhit_nbins)
Interface definition for fittable variables.
Definition: IFitVar.h:16
std::vector< std::pair< const ISyst *, const ISyst * > > GetCorrelations(bool isNue, bool isFHC, bool ptExtrap)
void Format(TGraph *gr, int lcol, int lsty, int lwid, int mcol, int msty, double msiz)
Definition: Style.cxx:154
const FitSinSq2Theta13 kFitSinSq2Theta13
Definition: FitVars.cxx:13
const IPrediction * GetNuePrediction2018(std::string decomp, osc::IOscCalc *calc, bool corrSysts, std::string beam, bool isFakeData, bool GetFromUPS=false, bool minimizeMemory=false, bool NERSC=false)
const double kAna2018FHCPOT
Definition: Exposures.h:207
std::string to_string(ModuleType mt)
Definition: ModuleType.h:32
void SaveToFile(const std::string &fname) const
const FitDmSq32InvertedHierarchy kFitDmSq32InvertedHierarchy
Definition: FitVars.cxx:23
const FitVarWithPrior fitDeltaInPiUnits_UniformPriordCP & kFitDeltaInPiUnits
const FitDmSq32NormalHierarchy kFitDmSq32NormalHierarchy
Definition: FitVars.cxx:20
std::vector< const ISyst * > GetJointFitSystematicList(bool corrSysts, bool nueExclusive=false, bool numuExclusive=false, bool isFHC=true, bool isRHC=true, bool intersection=true, bool ptExtrap=true)
void SetShift(const ISyst *syst, double shift, bool force=false)
Definition: SystShifts.cxx:81
const double kAna2018FHCLivetime
Definition: Exposures.h:213
void SetSystCorrelations(int idx, const std::vector< std::pair< const ISyst *, const ISyst * >> &corrs)
const double kAna2018RHCLivetime
Definition: Exposures.h:214
Compare a single data spectrum to the MC + cosmics expectation.
Collection of FCPoint. Serializable to/from a file.
Definition: FCCollection.h:12
Perform MINUIT fits in one or two dimensions.
Definition: MinuitFitter.h:17
enum BeamMode string