Nus18SystsCalibRelAna.C
Go to the documentation of this file.
1 /////////////////////////////////////////////////////////////////////
2 // Absolute Calibration systematics for Nus18
3 //
4 // Author: Sijith Edayath
5 // Modified by Mike Wallbank (wallbank@fnal.gov)
6 /////////////////////////////////////////////////////////////////////
7 
12 #include "CAFAna/Vars/HistAxes.h"
13 #include "NuXAna/Vars/HistAxes.h"
14 
17 
18 using namespace ana;
19 
21  TH1* hNC_ND;
22  TH1* hBG_ND;
23  TH1* hNC_FD;
24  TH1* hBG_FD;
25  TH1* hNC_EX;
26  TH1* hBG_EX;
28  if (type == "NC") {
29  if (det == "ND") return hNC_ND;
30  else if (det == "FD") return hNC_FD;
31  else if (det == "EX") return hNC_EX;
32  else std::cout << "Detector must be ND, FD or EX" << std::endl;
33  } else if (type == "BG") {
34  if (det == "ND") return hBG_ND;
35  else if (det == "FD") return hBG_FD;
36  else if (det == "EX") return hBG_EX;
37  else std::cout << "Detector must be ND, FD or EX" << std::endl;
38  } else
39  std::cout << "Type must be NC or BG" << std::endl;
40  return nullptr;
41  }
42 };
43 
44 void PlotSysts(TH1* nom, TH1* hfu, TH1* hfd, TH1* hnu, TH1* hnd,
45  TDirectory* rootOUT, FILE* textOFS,
46  strings strs);
47 
49 
50  TH1::AddDirectory(0);
51 
52  // Set up path to file with filled CAFAna objects and for output of analysis
53  std::string fileName = inFile.substr(0, inFile.find(".root"));
54  std::string saveName = fileName + "_ana.root";
55  std::string textName = fileName + "_ana.txt";
56 
57  // Get options
58  std::string polarity = "";
59  bool extrap = false;
60  if (opt.Contains("rhc", TString::kIgnoreCase) and
61  !opt.Contains("fhc", TString::kIgnoreCase))
62  polarity = "rhc";
63  else if (opt.Contains("fhc", TString::kIgnoreCase) and
64  !opt.Contains("rhc", TString::kIgnoreCase))
65  polarity = "fhc";
66  else {
67  std::cout << "Flux required: fhc or rhc" << std::endl;
68  abort();
69  }
70  if (opt.Contains("extrap", TString::kIgnoreCase))
71  extrap = true;
72 
73  double kNDScale, kFDScale;
74  if (polarity == "fhc") {
75  kNDScale = kAna2018RHCNDPOT;
76  kFDScale = kAna2018RHCPOT;
77  } else if (polarity == "rhc") {
78  kNDScale = kAna2018FHCNDPOT;
79  kFDScale = kAna2018FHCPOT;
80  }
81 
82  // A map of systematic labels
83  std::map<std::string, std::string> shiftLabels;
84  shiftLabels["CalFlatDownND"] = "Flat Miscalibration Down at ND";
85  shiftLabels["CalFlatUpND"] = "Flat Miscalibration Up at ND";
86  shiftLabels["CalFlatDownFD"] = "Flat Miscalibration Down at FD";
87  shiftLabels["CalFlatUpFD"] = "Flat Miscalibration Up at FD";
88 
89  // Get the vector of samples to analyse
90  std::vector<std::string> cut_samples;
91  cut_samples.push_back("Nus18");
92 
93  // Set up maps to the decompositions/predictions (each flavor component)
94  // Nominal maps are indexed purely by sample label
95  // Shifted maps are indexed by sample label, systematic label, then sigma of the shift
96  std::map<std::string, NDPredictionSterile*> predsND_nominal;
97  std::map<std::string, FDPredictionSterile*> predsFD_nominal;
98  std::map<std::string, PredictionSterile*> predsExtrap_nominal;
99  std::map<std::string, std::map<std::string, std::map<int, NDPredictionSterile*> > > predsND_shifted;
100  std::map<std::string, std::map<std::string, std::map<int, FDPredictionSterile*> > > predsFD_shifted;
101  std::map<std::string, std::map<std::string, std::map<int, PredictionSterile*> > > predsExtrap_shifted;
102 
103  // Fill the maps from the data in the input file
104  TFile* rootL = new TFile(inFile.c_str(), "READ");
105  LoadMaps(rootL, &predsND_nominal, &predsND_shifted);
106  LoadMaps(rootL, &predsFD_nominal, &predsFD_shifted);
107  if (extrap)
108  LoadMaps(rootL, &predsExtrap_nominal, &predsExtrap_shifted);
109  rootL->Close();
110 
111  // Get output files
112  TFile* rootF = new TFile(saveName.c_str(), "RECREATE");
113  FILE* textF;
114  textF = fopen(textName.c_str(), "w+");
115 
116  // Shifted spectra
117  std::map<std::string, ShiftedCalibRel> shiftedSpectra;
118 
119  // Look through all samples
120  for (const auto& sample : cut_samples) {
121 
122  strings strs;
123  strs.fComponent = "NC";
124  strs.fDet = "ND";
125  strs.fPOT = Form("%f", kNDScale);
126  strs.fSample = sample;
127  strs.fSystType = "CalibRel";
128  strs.fXLabel = kNus18AxisE.GetLabels()[0];
129 
130  InitializeSystText(textF, strs);
131 
132  // Get nominal spectra
133  TH1* hNomNC_predND = GetNC(predsND_nominal[sample], kNDScale);
134  TH1* hNomBG_predND = GetBG(predsND_nominal[sample], kNDScale);
135  TH1* hNomNC_predFD = GetNC(predsFD_nominal[sample], kFDScale);
136  TH1* hNomBG_predFD = GetBG(predsFD_nominal[sample], kFDScale);
137  TH1 *hNomNC_predExtrap, *hNomBG_predExtrap;
138  if (extrap) {
139  hNomNC_predExtrap = GetNC(predsExtrap_nominal[sample], kFDScale);
140  hNomBG_predExtrap = GetBG(predsExtrap_nominal[sample], kFDScale);
141  }
142 
143  // Look through all systematic shifts
144  for (const auto& shifts : shiftLabels) {
145 
146  strs.fSystS = shifts.first;
147  strs.fSystL = shifts.second;
148 
149  strs.fDet = "ND";
150  strs.fComponent = "NC";
151  PlotSyst(hNomNC_predND,
152  predsND_shifted[sample][shifts.first][1],
153  rootF, textF, strs, kNDScale, true, true);
154  shiftedSpectra[shifts.first].hNC_ND = GetNC(predsND_shifted[sample][shifts.first][1], kNDScale);
155 
156  strs.fComponent = "BG";
157  PlotSyst(hNomBG_predND,
158  predsND_shifted[sample][shifts.first][1],
159  rootF, textF, strs, kNDScale, false, true);
160  shiftedSpectra[shifts.first].hBG_ND = GetBG(predsND_shifted[sample][shifts.first][1], kNDScale);
161 
162  strs.fDet = "FD";
163  strs.fComponent = "NC";
164  PlotSyst(hNomNC_predFD,
165  predsFD_shifted[sample][shifts.first][1],
166  rootF, textF, strs, kFDScale, true, true);
167  shiftedSpectra[shifts.first].hNC_FD = GetNC(predsFD_shifted[sample][shifts.first][1], kFDScale);
168 
169  strs.fComponent = "BG";
170  PlotSyst(hNomBG_predFD,
171  predsFD_shifted[sample][shifts.first][1],
172  rootF, textF, strs, kFDScale, false, true);
173  shiftedSpectra[shifts.first].hBG_FD = GetBG(predsFD_shifted[sample][shifts.first][1], kFDScale);
174 
175  if (extrap) {
176  strs.fDet = "EX";
177  strs.fComponent = "NC";
178  PlotSyst(hNomNC_predExtrap,
179  predsExtrap_shifted[sample][shifts.first][1],
180  rootF, textF, strs, kFDScale, true, true);
181  shiftedSpectra[shifts.first].hNC_EX = GetNC(predsExtrap_shifted[sample][shifts.first][1], kFDScale);
182 
183  strs.fComponent = "BG";
184  PlotSyst(hNomBG_predExtrap,
185  predsExtrap_shifted[sample][shifts.first][1],
186  rootF, textF, strs, kFDScale, false, true);
187  shiftedSpectra[shifts.first].hBG_EX = GetBG(predsExtrap_shifted[sample][shifts.first][1], kFDScale);
188 
189  }
190 
191  }
192 
193  // for (const auto& det : {"ND", "FD"})
194  // for (const auto& type : {"NC", "BG", "EX"})
195  // for (const auto& syst : shiftLabels) {
196 
197  strs.fDet = "ND";
198  strs.fComponent = "NC";
199  PlotSysts(hNomNC_predND,
200  shiftedSpectra["CalFlatUpFD"].hNC_ND,
201  shiftedSpectra["CalFlatDownFD"].hNC_ND,
202  shiftedSpectra["CalFlatUpND"].hNC_ND,
203  shiftedSpectra["CalFlatDownND"].hNC_ND,
204  rootF, textF, strs);
205 
206  strs.fComponent = "BG";
207  PlotSysts(hNomBG_predND,
208  shiftedSpectra["CalFlatUpFD"].hBG_ND,
209  shiftedSpectra["CalFlatDownFD"].hBG_ND,
210  shiftedSpectra["CalFlatUpND"].hBG_ND,
211  shiftedSpectra["CalFlatDownND"].hBG_ND,
212  rootF, textF, strs);
213 
214  strs.fDet = "FD";
215  strs.fComponent = "NC";
216  PlotSysts(hNomNC_predFD,
217  shiftedSpectra["CalFlatUpFD"].hNC_FD,
218  shiftedSpectra["CalFlatDownFD"].hNC_FD,
219  shiftedSpectra["CalFlatUpND"].hNC_FD,
220  shiftedSpectra["CalFlatDownND"].hNC_FD,
221  rootF, textF, strs);
222 
223  strs.fComponent = "BG";
224  PlotSysts(hNomBG_predFD,
225  shiftedSpectra["CalFlatUpFD"].hBG_FD,
226  shiftedSpectra["CalFlatDownFD"].hBG_FD,
227  shiftedSpectra["CalFlatUpND"].hBG_FD,
228  shiftedSpectra["CalFlatDownND"].hBG_FD,
229  rootF, textF, strs);
230 
231  if (extrap) {
232  strs.fDet = "EX";
233  strs.fComponent = "NC";
234  PlotSysts(hNomNC_predExtrap,
235  shiftedSpectra["CalFlatUpFD"].hNC_EX,
236  shiftedSpectra["CalFlatDownFD"].hNC_EX,
237  shiftedSpectra["CalFlatUpND"].hNC_EX,
238  shiftedSpectra["CalFlatDownND"].hNC_EX,
239  rootF, textF, strs);
240 
241  strs.fComponent = "BG";
242  PlotSysts(hNomBG_predExtrap,
243  shiftedSpectra["CalFlatUpFD"].hBG_EX,
244  shiftedSpectra["CalFlatDownFD"].hBG_EX,
245  shiftedSpectra["CalFlatUpND"].hBG_EX,
246  shiftedSpectra["CalFlatDownND"].hBG_EX,
247  rootF, textF, strs);
248  }
249 
250  }
251 
252  fclose(textF);
253  rootF->Close();
254 
255  std::cout << "Finished. Ctrl+Z should be safe if the macro didn't quit." << std::endl;
256 
257 }
258 
259 void PlotSysts(TH1* nom, TH1* hfu, TH1* hfd, TH1* hnu, TH1* hnd,
260  TDirectory* rootOUT, FILE* textOFS,
261  strings strs) {
262 
263  double nNom = nom->Integral();
264  double nFDU = hfu->Integral();
265  double nFDD = hfd->Integral();
266  double nNDU = hnu->Integral();
267  double nNDD = hnd->Integral();
268 
269  ZeroError(nom);
270  ZeroError(hfu);
271  ZeroError(hfd);
272  ZeroError(hnu);
273  ZeroError(hnd);
274 
275  fprintf(textOFS, "\nEvent counts for %.2s %.2s %s Systs:\n",
276  strs.fDet.c_str(), strs.fComponent.c_str(), strs.fSystType.c_str());
277  fprintf(textOFS, "NC: %6.2f, FD Up: %6.2f, FD Down: %6.2f, ND Up: %6.2f, ND Down: %6.2f\n",
278  nNom, nFDU, nFDD, nNDU, nNDD);
279  fprintf(textOFS, "FD Up Diff: %6.2f, FD Down Diff: %6.2f, ND Up Diff: %6.2f, ND Down Diff: %6.2f",
280  100.*std::abs(nFDU/nNom - 1.), 100.*std::abs(nFDD/nNom - 1.),
281  100.*std::abs(nNDU/nNom - 1.), 100.*std::abs(nNDD/nNom - 1.));
282 
283  double diffs[] = {std::abs(nFDU - nNom),
284  std::abs(nFDD - nNom),
285  std::abs(nNDU - nNom),
286  std::abs(nNDD - nNom)};
287  if( *std::max_element(diffs, diffs+4) == diffs[0]) {
288  AddErrorInQuadrature(nom, hfu, true);
289  }
290  else if(*std::max_element(diffs, diffs+4) == diffs[1]){
291  AddErrorInQuadrature(nom, hfd, true);
292  }
293  else if(*std::max_element(diffs, diffs+4) == diffs[2]){
294  AddErrorInQuadrature(nom, hnu, true);
295  }
296  else {
297  AddErrorInQuadrature(nom, hnd, true);
298  }
299 
300  std::string xlabel = strs.fXLabel;
301  std::string ylabel = "Events / " + strs.fPOT + " / 0.25 GeV";
302  std::string title = strs.fDet + " " + strs.fComponent +
303  " Errors for All " + strs.fSystType + " Systematics";
304 // std::string fullTitle = title + ";" + xlabel + ";" + ylabel;
305  std::string fullTitle = ";" + xlabel + ";" + ylabel;
306  std::string name = "c" + strs.fComponent + strs.fDet +
307  strs.fSystType + "SystsAll" + strs.fSample;
308  std::string ylabelRat = "Shifted / Nominal";
309  std::string fullTitleRat = ";" + xlabel + ";" + ylabelRat;
310 
311  TH1* hRat = (TH1*)nom->Clone();
312  TH1* hFDURat = (TH1*)hfu->Clone();
313  TH1* hFDDRat = (TH1*)hfd->Clone();
314  TH1* hNDURat = (TH1*)hnu->Clone();
315  TH1* hNDDRat = (TH1*)hnd->Clone();
316 
317  int nBins = nom->GetNbinsX();
318  for(int i = 0; i <= nBins+1; ++i) {
319  hRat->SetBinContent(i, 1.);
320  }
321  hFDURat->Divide(nom);
322  hFDDRat->Divide(nom);
323  hNDURat->Divide(nom);
324  hNDDRat->Divide(nom);
325 
326  double maxval = nom->GetBinContent(nom->GetMaximumBin());
327  maxval = std::max(maxval, hfu->GetBinContent(hfu->GetMaximumBin()));
328  maxval = std::max(maxval, hfd->GetBinContent(hfd->GetMaximumBin()));
329  maxval = std::max(maxval, hnu->GetBinContent(hnu->GetMaximumBin()));
330  maxval = std::max(maxval, hnd->GetBinContent(hnd->GetMaximumBin()));
331 
332  double minval = nom->GetBinContent(nom->GetMinimumBin());
333  minval = std::min(minval, hfu->GetBinContent(hfu->GetMinimumBin()));
334  minval = std::min(minval, hfd->GetBinContent(hfd->GetMinimumBin()));
335  minval = std::min(minval, hnu->GetBinContent(hnu->GetMinimumBin()));
336  minval = std::min(minval, hnd->GetBinContent(hnd->GetMinimumBin()));
337 
338  if(maxval < minval) { std::swap(maxval, minval); }
339 
340  double maxvalRat = hRat->GetBinContent(hRat->GetMaximumBin());
341  maxvalRat = std::max(maxvalRat, hFDURat->GetBinContent(hFDURat->GetMaximumBin()));
342  maxvalRat = std::max(maxvalRat, hFDDRat->GetBinContent(hFDDRat->GetMaximumBin()));
343  maxvalRat = std::max(maxvalRat, hNDURat->GetBinContent(hNDURat->GetMaximumBin()));
344  maxvalRat = std::max(maxvalRat, hNDDRat->GetBinContent(hNDDRat->GetMaximumBin()));
345 
346  double minvalRat = hRat->GetBinContent(hRat->GetMinimumBin());
347  for(int i = 1; i <= nBins; ++i) {
348  if(hFDURat->GetBinContent(i) > 0.) {
349  minvalRat = std::min(minvalRat, hFDURat->GetBinContent(i));
350  }
351  if(hFDDRat->GetBinContent(i) > 0.) {
352  minvalRat = std::min(minvalRat, hFDDRat->GetBinContent(i));
353  }
354  if(hNDURat->GetBinContent(i) > 0.) {
355  minvalRat = std::min(minvalRat, hNDURat->GetBinContent(i));
356  }
357  if(hNDDRat->GetBinContent(i) > 0.) {
358  minvalRat = std::min(minvalRat, hNDDRat->GetBinContent(i));
359  }
360  }
361 
362  if(std::abs(maxvalRat - 1.) > std::abs(1. - minvalRat)) {
363  minvalRat = 1 - std::abs(maxvalRat - 1.);
364  maxvalRat = 1 + std::abs(maxvalRat - 1.);
365  }
366  else {
367  minvalRat = 1 - std::abs(1. - minvalRat);
368  maxvalRat = 1 + std::abs(1. - minvalRat);
369  }
370 
371  CenterTitles(nom);
372  nom->SetLineColor(kBlack);
373  nom->SetMaximum(1.1*maxval);
374  nom->SetMinimum(0);
375  nom->SetTitle(fullTitle.c_str());
376 
377  CenterTitles(hfu);
378  hfu->SetLineColor(kRed);
379  hfu->SetLineStyle(2);
380  hfu->SetMaximum(1.1*maxval);
381  hfu->SetMinimum(0);
382  hfu->SetTitle(fullTitle.c_str());
383 
384  CenterTitles(hfd);
385  hfd->SetLineColor(kBlue);
386  hfd->SetLineStyle(2);
387  hfd->SetMaximum(1.1*maxval);
388  hfd->SetMinimum(0);
389  hfd->SetTitle(fullTitle.c_str());
390 
391  CenterTitles(hnu);
392  hnu->SetLineColor(kGreen+2);
393  hnu->SetLineStyle(2);
394  hnu->SetMaximum(1.1*maxval);
395  hnu->SetMinimum(0);
396  hnu->SetTitle(fullTitle.c_str());
397 
398  CenterTitles(hnd);
399  hnd->SetLineColor(kViolet-5);
400  hnd->SetLineStyle(2);
401  hnd->SetMaximum(1.1*maxval);
402  hnd->SetMinimum(0);
403  hnd->SetTitle(fullTitle.c_str());
404 
405  CenterTitles(hRat);
406  hRat->SetLineColor(kBlack);
407  hRat->SetMaximum(1.1*maxvalRat);
408  hRat->SetMinimum(0.9*minvalRat);
409  hRat->SetTitle(fullTitleRat.c_str());
410 
411  CenterTitles(hFDURat);
412  hFDURat->SetLineColor(kRed);
413  hFDURat->SetLineStyle(2);
414  hFDURat->SetMaximum(1.1*maxvalRat);
415  hFDURat->SetMinimum(0.9*minvalRat);
416  hFDURat->SetTitle(fullTitleRat.c_str());
417 
418  CenterTitles(hFDDRat);
419  hFDDRat->SetLineColor(kBlue);
420  hFDDRat->SetLineStyle(2);
421  hFDDRat->SetMaximum(1.1*maxvalRat);
422  hFDDRat->SetMinimum(0.9*minvalRat);
423  hFDDRat->SetTitle(fullTitleRat.c_str());
424 
425  CenterTitles(hNDURat);
426  hNDURat->SetLineColor(kGreen+2);
427  hNDURat->SetLineStyle(2);
428  hNDURat->SetMaximum(1.1*maxvalRat);
429  hNDURat->SetMinimum(0.9*minvalRat);
430  hNDURat->SetTitle(fullTitleRat.c_str());
431 
432  CenterTitles(hNDDRat);
433  hNDDRat->SetLineColor(kViolet-5);
434  hNDDRat->SetLineStyle(2);
435  hNDDRat->SetMaximum(1.1*maxvalRat);
436  hNDDRat->SetMinimum(0.9*minvalRat);
437  hNDDRat->SetTitle(fullTitleRat.c_str());
438 
439  double xL = 0.6, xR = 0.85;
440  double yB = 0.6, yT = 0.85;
441  TLegend* leg = new TLegend(xL, yB, xR, yT);
442  leg->AddEntry(nom, "Nominal", "l");
443  leg->AddEntry(hfu, "FD Scale Up", "l");
444  leg->AddEntry(hfd, "FD Scale Down", "l");
445  leg->AddEntry(hnu, "ND Scale Up", "l");
446  leg->AddEntry(hnd, "ND Scale Down", "l");
447 
448  TCanvas* c = new TCanvas(name.c_str(), title.c_str(), 800, 800);
449  TPad* pSpecs = new TPad("pSpecs", "", 0., 0.375, 1., 1.);
450  TPad* pRatio = new TPad("pRatio", "", 0., 0., 1., 0.375);
451  pSpecs->Draw();
452  pRatio->Draw();
453 
454  pSpecs->cd();
455  nom->Draw("hist");
456  hfu->Draw("hist same");
457  hfd->Draw("hist same");
458  hnu->Draw("hist same");
459  hnd->Draw("hist same");
460  leg->Draw();
461  Simulation();
462 
463  pRatio->cd();
464  hRat->Draw("hist");
465  hFDURat->Draw("hist same");
466  hFDDRat->Draw("hist same");
467  hNDURat->Draw("hist same");
468  hNDDRat->Draw("hist same");
469 
470  c->Update();
471  rootOUT->WriteTObject(c);
472  return;
473 }
void Simulation()
Definition: tools.h:16
T max(const caf::Proxy< T > &a, T b)
void PlotSysts(TH1 *nom, TH1 *hfu, TH1 *hfd, TH1 *hnu, TH1 *hnd, TDirectory *rootOUT, FILE *textOFS, strings strs)
const XML_Char * name
Definition: expat.h:151
int nBins
Definition: plotROC.py:16
std::string fDet
Definition: PPFXHelper.h:104
fileName
Definition: plotROC.py:78
Cuts and Vars for the 2020 FD DiF Study.
Definition: vars.h:6
std::string fComponent
Definition: PPFXHelper.h:103
const std::vector< std::string > & GetLabels() const
Definition: HistAxis.h:90
void PlotSyst(TH1 *h, TH1 *hp1, TH1 *hm1, TH1 *hp2, TH1 *hm2, TDirectory *out, FILE *text, strings strs)
Definition: PPFXHelper.h:662
void ZeroError(TH1 *nom)
Set the errors of the input histogram to 0.
Definition: PPFXHelper.h:149
void CenterTitles(TH1 *histo)
Definition: Plots.cxx:1481
float abs(float number)
Definition: d0nt_math.hpp:39
const double kAna2018RHCPOT
Definition: Exposures.h:208
const HistAxis kNus18AxisE("Energy Deposited in Scintillator (GeV)", kNus18EnergyBinning, kNus18Energy)
Axes used in Nus18 analysis by nus group.
Definition: HistAxes.h:16
void swap(art::HLTGlobalStatus &lhs, art::HLTGlobalStatus &rhs)
TH1 * GetNC(IDecomp *specs, double POT)
Definition: PPFXHelper.h:211
fclose(fg1)
TH1 * GetSpectra(std::string type, std::string det)
ifstream inFile
Definition: AnaPlotMaker.h:34
void AddErrorInQuadrature(TH1 *nom, TH1 *up, bool use_max)
Definition: PPFXHelper.h:163
void InitializeSystText(FILE *text, strings strs)
Print some initial text about a systematic – the systematic type and sample.
Definition: PPFXHelper.h:263
std::string fSystL
Definition: PPFXHelper.h:109
std::string fPOT
Definition: PPFXHelper.h:105
OStream cout
Definition: OStream.cxx:6
std::string fXLabel
Definition: PPFXHelper.h:110
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
std::string fSystType
Definition: PPFXHelper.h:107
std::string fSystS
Definition: PPFXHelper.h:108
void LoadMaps(TDirectory *dir, std::map< std::string, IDecomp * > *nominal, std::map< std::string, std::map< std::string, std::map< int, IDecomp * > > > *shifted)
Definition: PPFXHelper.h:273
const double kAna2018FHCPOT
Definition: Exposures.h:207
T min(const caf::Proxy< T > &a, T b)
TH1 * GetBG(IDecomp *specs, double POT)
Definition: PPFXHelper.h:236
void Nus18SystsCalibRelAna(std::string inFile, TString opt)
A helper structure to contain a group of string for plotting.
Definition: PPFXHelper.h:101
std::string fSample
Definition: PPFXHelper.h:106