nuCrystalBallDefs.h
Go to the documentation of this file.
1 #ifndef NUCRYSTALBALL_H
2 #define NUCRYSTALBALL_H
3 
4 #include "CAFAna/Vars/Vars.h"
5 #include "CAFAna/Core/Binning.h"
6 #include "CAFAna/Vars/NueVars.h"
7 #include "CAFAna/Vars/NumuVars.h"
8 #include "NuXAna/Vars/NusVars.h"
10 #include "CAFAna/Cuts/Cuts.h"
11 #include "CAFAna/Cuts/NueCuts2017.h"
12 #include "NuXAna/Cuts/NusCuts17.h"
13 #include "CAFAna/Cuts/NumuCuts2017.h"
14 
15 #include "CAFAna/Core/Utilities.h"
16 
17 #include "TString.h"
18 
19 #include <vector>
20 
21 namespace ana
22 {
23  // Define structure to hold prediction information
24  struct PredDef
25  {
26  const IPrediction *prediction;
27  const TString cutName;
28  const TString pidCutName;
29  const TString varName;
30  const TString fhcName;
31  };
32 
33  // Define a struct to hold plot information
34  struct VarDef
35  {
36  const TString name;
37  const Var var;
38  const Binning binning;
39  const TString type;
40  };
41 
42  // Define a struct to hold cut information
43  struct CutDef
44  {
45  const TString name;
46  const Cut cut;
47  const TString type;
48  };
49 
50  // Define a struct to hold PID cut information
51  struct PIDCutDef
52  {
53  const TString name;
54  const Cut cut;
55  const TString type;
56  };
57 
58  // Define binnings
59  const Binning kPIDBinning = Binning::Simple(100, 0.0, 1.);
60  const Binning kRecoEBinning = Binning::Simple(16, 0, 4);
61  const Binning kModeBinning = Binning::Simple(4, -0.5, 3.5);
62  const Binning kYBinning = Binning::Simple(50, 0, 1);
63  const Binning kYvertexBinning = Binning::Simple(40, -800, 800);
64  const Binning kXvertexBinning = Binning::Simple(40, -800, 800);
65  const Binning kZvertexBinning = Binning::Simple(40, 0, 6000);
66 
67  // Define weight
69 
70  // Some general Vars we want to plot
71  const Var kTrueEVis(//{"mc.nu.E", "mc.nu.y", "mc.nu.iscc"},
72  [](const caf::SRProxy* sr)
73  {
74  if(sr->mc.nu.empty()) return 0.;
75  double ret = sr->mc.nu[0].E;
76  if(!sr->mc.nu[0].iscc) ret *= sr->mc.nu[0].y;
77  return ret;
78  });
79 
80  /// ***Nue***
81  /// New CVN CAF variables for PIDs
82  /// \f$ \nu_e \f$ PID
83  const Var kCVNeSS([](const caf::SRProxy* sr){
84  return sr->sel.cvnProd3Train.nueid;});
85  /// \f$ \nu_e \f$ PID
86  const Var kCVNeELU([](const caf::SRProxy* sr){
87  return sr->sel.cvn.nueid;});
88  /// \f$ \nu_e \f$ PID
89  const Var kCVNe2017([](const caf::SRProxy* sr){
90  return sr->sel.cvn2017.nueid;});
91 
92  /// Nue cuts
93  /// Nearest slice cuts without CVN
94  //const Cut kNearestSliceCosRejNoCVN([](const caf::SRProxy* sr) {
95  // if(kNue2017CorePresel(sr))
96  // {
97  // return !(sr->slc.closestslicetime > -100. &&
98  // sr->slc.closestslicetime < 100. &&
99  // sr->slc.closestsliceminfromtop < 50 &&
100  // sr->slc.closestslicemindist < 500.);
101  // }
102  // return false;
103  //});
104 
105  /// Optimised CVN cuts
106  // FHC --> short-simple --> sob
107  const Cut kNueFHCSobCVNSS([](const caf::SRProxy* sr)
108  {
109  return (sr->sel.cvnProd3Train.nueid > 0.97);
110  });
111  // sosb
112  const Cut kNueFHCSosbCVNSS([](const caf::SRProxy* sr)
113  {
114  return (sr->sel.cvnProd3Train.nueid > 0.75);
115  });
116  // ELU --> sob
117  const Cut kNueFHCSobCVNELU([](const caf::SRProxy* sr)
118  {
119  return (sr->sel.cvn.nueid > 0.93);
120  });
121  // sosb
122  const Cut kNueFHCSosbCVNELU([](const caf::SRProxy* sr)
123  {
124  return (sr->sel.cvn.nueid > 0.66);
125  });
126  // CVN 2017 --> sob
127  const Cut kNueFHCSobCVN2017([](const caf::SRProxy* sr)
128  {
129  return (sr->sel.cvn2017.nueid > 0.96);
130  });
131  // sosb
132  const Cut kNueFHCSosbCVN2017([](const caf::SRProxy* sr)
133  {
134  return (sr->sel.cvn2017.nueid > 0.66);
135  });
136 
137  // RHC --> short-simple --> sob
138  const Cut kNueRHCSobCVNSS([](const caf::SRProxy* sr)
139  {
140  return (sr->sel.cvnProd3Train.nueid > 0.97);
141  });
142  // sosb
143  const Cut kNueRHCSosbCVNSS([](const caf::SRProxy* sr)
144  {
145  return (sr->sel.cvnProd3Train.nueid > 0.75);
146  });
147  // ELU --> sob
148  const Cut kNueRHCSobCVNELU([](const caf::SRProxy* sr)
149  {
150  return (sr->sel.cvn.nueid > 0.92);
151  });
152  // sosb
153  const Cut kNueRHCSosbCVNELU([](const caf::SRProxy* sr)
154  {
155  return (sr->sel.cvn.nueid > 0.67);
156  });
157  // CVN 2017 --> sob
158  const Cut kNueRHCSobCVN2017([](const caf::SRProxy* sr)
159  {
160  return (sr->sel.cvn2017.nueid > 0.94);
161  });
162  // sosb
163  const Cut kNueRHCSosbCVN2017([](const caf::SRProxy* sr)
164  {
165  return (sr->sel.cvn2017.nueid > 0.72);
166  });
167 
168  /// ***Numu***
169  // New CVN CAF variales for PIDs
170  /// \f$ \nu_e \f$ PID
171  const Var kCVNmuSS([](const caf::SRProxy* sr){
172  return sr->sel.cvnProd3Train.numuid;});
173  /// \f$ \nu_e \f$ PID
174  const Var kCVNmuELU([](const caf::SRProxy* sr){
175  return sr->sel.cvn.numuid;});
176  /// \f$ \nu_e \f$ PID
177  const Var kCVNmu2017([](const caf::SRProxy* sr){
178  return sr->sel.cvn2017.numuid;});
179 
180  /// RemID
181  const Cut kNumu2017remid([](const caf::SRProxy* sr)
182  {
183  return (sr->sel.remid.pid > 0.5);
184  });
185 
186  /// Optimised RemID cuts
187  const Cut kNumuFHCSobRemID([](const caf::SRProxy* sr)
188  {
189  return (sr->sel.remid.pid > 0.99);
190  });
191  const Cut kNumuFHCSosbRemID([](const caf::SRProxy* sr)
192  {
193  return (sr->sel.remid.pid > 0.68);
194  });
195  const Cut kNumuRHCSobRemID([](const caf::SRProxy* sr)
196  {
197  return (sr->sel.remid.pid > 0.99);
198  });
199  const Cut kNumuRHCSosbRemID([](const caf::SRProxy* sr)
200  {
201  return (sr->sel.remid.pid > 0.69);
202  });
203 
204  // Optimised CVN cuts
205  // FHC --> short-simple --> sob
206  const Cut kNumuFHCSobCVNSS([](const caf::SRProxy* sr)
207  {
208  return (sr->sel.cvnProd3Train.numuid > 0.98);
209  });
210  // sosb
211  const Cut kNumuFHCSosbCVNSS([](const caf::SRProxy* sr)
212  {
213  return (sr->sel.cvnProd3Train.numuid > 0.38);
214  });
215  // ELU --> sob
216  const Cut kNumuFHCSobCVNELU([](const caf::SRProxy* sr)
217  {
218  return (sr->sel.cvn.numuid > 0.98);
219  });
220  // sosb
221  const Cut kNumuFHCSosbCVNELU([](const caf::SRProxy* sr)
222  {
223  return (sr->sel.cvn.numuid > 0.52);
224  });
225  // CVN 2017 --> sob
226  const Cut kNumuFHCSobCVN2017([](const caf::SRProxy* sr)
227  {
228  return (sr->sel.cvn2017.numuid > 0.98);
229  });
230  // sosb
231  const Cut kNumuFHCSosbCVN2017([](const caf::SRProxy* sr)
232  {
233  return (sr->sel.cvn2017.numuid > 0.43);
234  });
235 
236  // RHC --> short-simple --> sob
237  const Cut kNumuRHCSobCVNSS([](const caf::SRProxy* sr)
238  {
239  return (sr->sel.cvnProd3Train.numuid > 0.99);
240  });
241  // sosb
242  const Cut kNumuRHCSosbCVNSS([](const caf::SRProxy* sr)
243  {
244  return (sr->sel.cvnProd3Train.numuid > 0.36);
245  });
246  // ELU --> sob
247  const Cut kNumuRHCSobCVNELU([](const caf::SRProxy* sr)
248  {
249  return (sr->sel.cvn.numuid > 0.95);
250  });
251  // sosb
252  const Cut kNumuRHCSosbCVNELU([](const caf::SRProxy* sr)
253  {
254  return (sr->sel.cvn.numuid > 0.50);
255  });
256  // CVN 2017 --> sob
257  const Cut kNumuRHCSobCVN2017([](const caf::SRProxy* sr)
258  {
259  return (sr->sel.cvn2017.numuid > 0.97);
260  });
261  // sosb
262  const Cut kNumuRHCSosbCVN2017([](const caf::SRProxy* sr)
263  {
264  return (sr->sel.cvn2017.numuid > 0.34);
265  });
266 
267  // Full FD Numu selection for 2017 analysis, minus CVN because we
268  // need to optimise this first
271 
272  /// ***NC***
273  /// New CVN CAF variables for PIDs
274  /// \f$ nc \f$ PID
275  const Var kCVNncSS([](const caf::SRProxy* sr){
276  return sr->sel.cvnProd3Train.ncid;});
277  /// \f$ nc \f$ PID
278  const Var kCVNncELU([](const caf::SRProxy* sr){
279  return sr->sel.cvn.ncid;});
280  /// \f$ nc \f$ PID
281  const Var kCVNnc2017([](const caf::SRProxy* sr){
282  return sr->sel.cvn2017.ncid;});
283 
284  /// Optimised CVN cuts
285  // FHC --> short-simple --> sob
286  const Cut kNusFHCSobCVNSS([](const caf::SRProxy* sr)
287  {
288  return (sr->sel.cvnProd3Train.ncid > 0.99);
289  });
290  // sosb
291  const Cut kNusFHCSosbCVNSS([](const caf::SRProxy* sr)
292  {
293  return (sr->sel.cvnProd3Train.ncid > 0.24);
294  });
295  // ELU --> sob
296  const Cut kNusFHCSobCVNELU([](const caf::SRProxy* sr)
297  {
298  return (sr->sel.cvn.ncid > 0.97);
299  });
300  // sosb
301  const Cut kNusFHCSosbCVNELU([](const caf::SRProxy* sr)
302  {
303  return (sr->sel.cvn.ncid > 0.21);
304  });
305  // CVN 2017 --> sob
306  const Cut kNusFHCSobCVN2017([](const caf::SRProxy* sr)
307  {
308  return (sr->sel.cvn2017.ncid > 0.88);
309  });
310  // sosb
311  const Cut kNusFHCSosbCVN2017([](const caf::SRProxy* sr)
312  {
313  return (sr->sel.cvn2017.ncid > 0.24);
314  });
315 
316  // RHC --> short-simple --> sob
317  const Cut kNusRHCSobCVNSS([](const caf::SRProxy* sr)
318  {
319  return (sr->sel.cvnProd3Train.ncid > 0.99);
320  });
321  // sosb
322  const Cut kNusRHCSosbCVNSS([](const caf::SRProxy* sr)
323  {
324  return (sr->sel.cvnProd3Train.ncid > 0.24);
325  });
326  // ELU --> sob
327  const Cut kNusRHCSobCVNELU([](const caf::SRProxy* sr)
328  {
329  return (sr->sel.cvn.ncid > 0.99);
330  });
331  // sosb
332  const Cut kNusRHCSosbCVNELU([](const caf::SRProxy* sr)
333  {
334  return (sr->sel.cvn.ncid > 0.20);
335  });
336  // CVN 2017 --> sob
337  const Cut kNusRHCSobCVN2017([](const caf::SRProxy* sr)
338  {
339  return (sr->sel.cvn2017.ncid > 0.85);
340  });
341  // sosb
342  const Cut kNusRHCSosbCVN2017([](const caf::SRProxy* sr)
343  {
344  return (sr->sel.cvn2017.ncid > 0.22);
345  });
346 
347  // Full FD Nus selection for 2017 analysis, minus CVN because we
348  // need to optimise this first
353 
354  const std::vector<VarDef> GetVars(TString opt)
355  {
356  std::vector<VarDef> vars;
357 
358  if(opt.Contains("nue", TString::kIgnoreCase))
359  {
360  // Add Nue PIDs
361  vars.push_back({"CVNeShortSimple", kCVNeSS, kPIDBinning, "pid"});
362  vars.push_back({"CVNeELU", kCVNeELU, kPIDBinning, "pid"});
363  vars.push_back({"CVNe2017", kCVNe2017, kPIDBinning, "pid"});
364 
365  // Add Reco E
366  vars.push_back({"NueEnergy2017", kNueEnergy2017, kRecoEBinning, "var"});
367 
368  }
369 
370  if(opt.Contains("numu", TString::kIgnoreCase))
371  {
372  // Add Numu PIDs
373  vars.push_back({"CVNmuShortSimple", kCVNmuSS, kPIDBinning, "pid"});
374  vars.push_back({"CVNmuELU", kCVNmuELU, kPIDBinning, "pid"});
375  vars.push_back({"CVNmu2017", kCVNmu2017, kPIDBinning, "pid"});
376 
377  // Add Reco energy
378  vars.push_back({"CCE", kCCE, kRecoEBinning, "var"});
379  vars.push_back({"HadE", kHadE, kRecoEBinning, "var"});
380  }
381 
382  if(opt.Contains("nus", TString::kIgnoreCase))
383  {
384  // Add Nus PIDs
385  vars.push_back({"CVNncShortSimple", kCVNncSS, kPIDBinning, "pid"});
386  vars.push_back({"CVNncELU", kCVNncELU, kPIDBinning, "pid"});
387  vars.push_back({"CVNnc2017", kCVNnc2017, kPIDBinning, "pid"});
388 
389  // Add Reco E
390  vars.push_back({"Nus17Energy", kNus17Energy, kRecoEBinning, "vars"});
391  }
392 
393  // Add visible energy
394  vars.push_back({"TrueEVis", kTrueEVis, kRecoEBinning, "var"});
395 
396  // Add mode
397  vars.push_back({"Mode", kMode, kModeBinning, "var"});
398 
399  return vars;
400  };
401 
402  std::vector<CutDef> GetCuts(TString opt)
403  {
404  std::vector<CutDef> cuts;
405 
406  if(opt.Contains("nue", TString::kIgnoreCase))
407  cuts.push_back({"Nue2017CorePresel", kNue2017CorePresel, "selection"});
408 
409  if(opt.Contains("numu", TString::kIgnoreCase))
410  cuts.push_back({"Numu2017MinusCVN", kNumu2017MinusCVN, "selection"});
411 
412  if(opt.Contains("nus", TString::kIgnoreCase))
413  cuts.push_back({"Nus2017MinusCVN", kNus2017MinusCVN, "selection"});
414 
415  return cuts;
416  };
417 
418  std::vector<std::vector<PIDCutDef> > GetPIDCuts(TString opt)
419  {
420  std::vector<std::vector<PIDCutDef> > pidCuts(2);
421 
422  if(opt.Contains("nue", TString::kIgnoreCase))
423  {
424  /// Fill FHC branch
425  pidCuts[0].push_back({"CVNeShortSimpleSob", kNueFHCSobCVNSS, "pidCut"});
426  pidCuts[0].push_back({"CVNeShortSimpleSosb", kNueFHCSosbCVNSS, "pidCut"});
427  pidCuts[0].push_back({"CVNeELUSob", kNueFHCSobCVNELU, "pidCut"});
428  pidCuts[0].push_back({"CVNeELUSosb", kNueFHCSosbCVNELU, "pidCut"});
429  pidCuts[0].push_back({"CVNe2017Sob", kNueFHCSobCVN2017, "pidCut"});
430  pidCuts[0].push_back({"CVNe2017Sosb", kNueFHCSosbCVN2017, "pidCut"});
431 
432  /// Fill RHC branch
433  pidCuts[1].push_back({"CVNeShortSimpleSob", kNueRHCSobCVNSS, "pidCut"});
434  pidCuts[1].push_back({"CVNeShortSimpleSosb", kNueRHCSosbCVNSS, "pidCut"});
435  pidCuts[1].push_back({"CVNeELUSob", kNueRHCSobCVNELU, "pidCut"});
436  pidCuts[1].push_back({"CVNeELUSosb", kNueRHCSosbCVNELU, "pidCut"});
437  pidCuts[1].push_back({"CVNe2017Sob", kNueRHCSobCVN2017, "pidCut"});
438  pidCuts[1].push_back({"CVNe2017Sosb", kNueRHCSosbCVN2017, "pidCut"});
439  }
440 
441  if(opt.Contains("numu", TString::kIgnoreCase))
442  {
443  /// Fill FHC branch
444  pidCuts[0].push_back({"CVNmuShortSimpleSob", kNumuFHCSobCVNSS, "pidCut"});
445  pidCuts[0].push_back({
446  "CVNmuShortSimpleSosb", kNumuFHCSosbCVNSS, "pidCut"});
447  pidCuts[0].push_back({"CVNmuELUSob", kNumuFHCSobCVNELU, "pidCut"});
448  pidCuts[0].push_back({"CVNmuELUSosb", kNumuFHCSosbCVNELU, "pidCut"});
449  pidCuts[0].push_back({"CVNmu2017Sob", kNumuFHCSobCVN2017, "pidCut"});
450  pidCuts[0].push_back({"CVNmu2017Sosb", kNumuFHCSosbCVN2017, "pidCut"});
451 
452  /// Fill RHC branch
453  pidCuts[1].push_back({"CVNmuShortSimpleSob", kNumuRHCSobCVNSS, "pidCut"});
454  pidCuts[1].push_back({
455  "CVNmuShortSimpleSosb", kNumuRHCSosbCVNSS, "pidCut"});
456  pidCuts[1].push_back({"CVNmuELUSob", kNumuRHCSobCVNELU, "pidCut"});
457  pidCuts[1].push_back({"CVNmuELUSosb", kNumuRHCSosbCVNELU, "pidCut"});
458  pidCuts[1].push_back({"CVNmu2017Sob", kNumuRHCSobCVN2017, "pidCut"});
459  pidCuts[1].push_back({"CVNmu2017Sosb", kNumuRHCSosbCVN2017, "pidCut"});
460  }
461 
462  if(opt.Contains("nus", TString::kIgnoreCase))
463  {
464  /// Fill FHC branch
465  pidCuts[0].push_back({"CVNncShortSimpleSob", kNusFHCSobCVNSS, "pidCut"});
466  pidCuts[0].push_back({
467  "CVNncShortSimpleSosb", kNusFHCSosbCVNSS, "pidCut"});
468  pidCuts[0].push_back({"CVNncELUSob", kNusFHCSobCVNELU, "pidCut"});
469  pidCuts[0].push_back({"CVNncELUSosb", kNusFHCSosbCVNELU, "pidCut"});
470  pidCuts[0].push_back({"CVNnc2017Sob", kNusFHCSobCVN2017, "pidCut"});
471  pidCuts[0].push_back({"CVNnc2017Sosb", kNusFHCSosbCVN2017, "pidCut"});
472 
473  /// Fill RHC branch
474  pidCuts[1].push_back({"CVNncShortSimpleSob", kNusRHCSobCVNSS, "pidCut"});
475  pidCuts[1].push_back({
476  "CVNncShortSimpleSosb", kNusRHCSosbCVNSS, "pidCut"});
477  pidCuts[1].push_back({"CVNncELUSob", kNusRHCSobCVNELU, "pidCut"});
478  pidCuts[1].push_back({"CVNncELUSosb", kNusRHCSosbCVNELU, "pidCut"});
479  pidCuts[1].push_back({"CVNnc2017Sob", kNusRHCSobCVN2017, "pidCut"});
480  pidCuts[1].push_back({"CVNnc2017Sosb", kNusRHCSosbCVN2017, "pidCut"});
481  }
482 
483  return pidCuts;
484  };
485 }// namespace ana
486 
487 #endif
const Binning kModeBinning
const Var kHadE
Definition: NumuVars.h:23
const Cut kNumuFHCSosbRemID([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.99);})
const Var kCVNmu2017([](const caf::SRProxy *sr){return sr->sel.cvn2017.numuid;})
CVN 2017 PID
const Var kCVNeSS([](const caf::SRProxy *sr){return sr->sel.cvnProd3Train.nueid;})
CVN short-simple PID
const Cut kNumuRHCSosbCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.99);})
const XML_Char * name
Definition: expat.h:151
const Var kMode([](const caf::SRProxy *sr){return(sr->mc.nnu==0)?-1:int(sr->mc.nu[0].mode);})
Neutrino interaction mode.
Definition: Vars.h:99
const TString cutName
const Cut kNus17EnergyCut([](const caf::SRProxy *sr){double energy=0.0;energy=kNus17Energy(sr);if(energy< 0.25) return false;if(energy > 10.0) return false;return true;})
Definition: NusCuts17.h:51
Represent the binning of a Spectrum&#39;s x-axis.
Definition: Binning.h:16
Cuts and Vars for the 2020 FD DiF Study.
Definition: vars.h:6
const Cut kNumuRHCSobRemID([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.99);})
const Binning kYBinning
const Cut kNumuFHCSosbCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.98);})
const Var kPPFXFluxCVWgt
Definition: PPFXWeights.h:16
const Cut kNusFHCSosbCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.88);})
caf::Proxy< float > ncid
Definition: SRProxy.h:904
const Cut kNumuRHCSosbCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.95);})
const Var weight
const Cut kNumu2017MinusCVN
const Cut kNueFHCSosbCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.93);})
Proxy for caf::StandardRecord.
Definition: SRProxy.h:2126
const Cut kNumuFHCSobCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.98);})
caf::Proxy< std::vector< caf::SRNeutrino > > nu
Definition: SRProxy.h:618
const Cut kNumuFHCSosbCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.98);})
const Cut kNumuRHCSobCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.95);})
caf::Proxy< float > pid
Definition: SRProxy.h:1136
const Cut kNusRHCSosbCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.85);})
const Var kTrueEVis([](const caf::SRProxy *sr){if(sr->mc.nu.empty()) return 0.;double ret=sr->mc.nu[0].E;if(!sr->mc.nu[0].iscc) ret *=sr->mc.nu[0].y;return ret;})
const Cut kNus17BackwardCut
FD backward photon rejection cut, inherited from nue, from docdb 21113.
Definition: NusCuts17.h:45
const Cut kNueFHCSosbCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.96);})
Struct to hold PID cut information.
const Var kCVNeELU([](const caf::SRProxy *sr){return sr->sel.cvn.nueid;})
CVN ELU PID
const Var kCVNmuELU([](const caf::SRProxy *sr){return sr->sel.cvn.numuid;})
CVN ELU PID
const IPrediction * prediction
const Cut kNumuRHCSosbRemID([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.99);})
const Var kNus17Energy([](const caf::SRProxy *sr){double cale=sr->slc.calE;double recoE=0.;if(sr->hdr.det==caf::kFARDET) recoE=FDscaleCalE17 *cale;if(sr->hdr.det==caf::kNEARDET) recoE=NDscaleCalE17 *cale;return recoE;})
Definition: NusVars.h:62
const Cut kNumuRHCSobCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.99);})
const Binning kXvertexBinning
const Var kNueEnergy2017([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid) return-1.0;if(sr->vtx.elastic.fuzzyk.npng< 1) return-1.0;return NueRecoE_2017FDFit(kCVNemE(sr), kCVNhadE(sr));})
Definition: NueEnergy2017.h:11
const Cut kNusFHCSosbCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.97);})
const Cut kNusRHCSobCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.99);})
std::vector< CutDef > GetCuts(TString opt, bool pastCuts=false, bool noCut=true)
const Cut kNumuContainFD2017
Definition: NumuCuts2017.h:21
const Cut kNueRHCSosbCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.92);})
caf::Proxy< caf::SRCVNResult > cvn
Definition: SRProxy.h:1253
caf::Proxy< float > nueid
Definition: SRProxy.h:906
const Cut kNueRHCSosbCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.94);})
const Cut kNus17SlcDist
Definition: NusCuts17.h:55
const Var kCVNnc2017([](const caf::SRProxy *sr){return sr->sel.cvn2017.ncid;})
CVN 2017 PID
Struct to hold Var/plot information.
const Var kCCE
Definition: NumuVars.h:21
Struct to hold cut information.
const Cut kNueRHCSobCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.94);})
const Binning kYvertexBinning
const Cut kNumuFHCSobCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.98);})
const Cut kNus17ShwPtpLow
Carve out space in shower maximum y and #p_{T}/p, from docdb 21113.
Definition: NusCuts17.h:58
const Binning kPIDBinning
caf::StandardRecord * sr
const std::map< std::pair< std::string, std::string >, Variable > vars
std::vector< std::vector< PIDCutDef > > GetPIDCuts(TString opt, bool noCut=true)
const Cut kNus17NCCosRejAlt
Until nccosrej branch is in CAFs, must use these cuts.
Definition: NusCuts17.h:70
const Cut kNueFHCSobCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.97);})
Optimised CVN cuts.
caf::Proxy< caf::SRRemid > remid
Definition: SRProxy.h:1269
const Cut kNusRHCSobCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.85);})
const Var kCVNmuSS([](const caf::SRProxy *sr){return sr->sel.cvnProd3Train.numuid;})
CVN short-simple PID
const Binning kZvertexBinning
const Var kCVNncSS([](const caf::SRProxy *sr){return sr->sel.cvnProd3Train.ncid;})
CVN short-simple PID
const Cut kNumuFHCSosbCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.98);})
const Cut kNumuCosmicRej2017([](const caf::SRProxy *sr){return(sr->sel.cosrej.anglekal > 0.5 && sr->sel.cosrej.numucontpid2020 > 0.5 && sr->slc.nhit< 400);})
Definition: NumuCuts2017.h:24
const Var kCVNncELU([](const caf::SRProxy *sr){return sr->sel.cvn.ncid;})
CVN ELU PID
const Cut kNumuFHCSobRemID([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.99);})
Optimised RemID cuts.
caf::Proxy< caf::SRTruthBranch > mc
Definition: SRProxy.h:2138
const Cut kNusRHCSobCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.99);})
const TString pidCutName
const Cut kNumuRHCSobCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.97);})
const Cut cut
Definition: exporter_fd.C:30
const std::vector< VarDef > GetVars(TString opt, TString type="all")
const Cut kNus17ShwPtpHigh
Definition: NusCuts17.h:59
const Cut kNumu2017remid([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.5);})
Numu RemID cut.
const TString fhcName
const Cut kNus17SlcTimeGap
Closest slice cuts based on approximation in space and time, from from docdb 21113.
Definition: NusCuts17.h:54
const Cut kNusFHCSobCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.99);})
Optimised CVN cuts.
const Cut kNueRHCSobCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.92);})
const Cut kNusFHCSobCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.88);})
const Cut kNumuRHCSosbCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.97);})
const Cut kNueFHCSobCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.93);})
const Cut kNusRHCSosbCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.99);})
const Var kCVNe2017([](const caf::SRProxy *sr){return sr->sel.cvn2017.nueid;})
CVN 2017 PID
const Cut kNusRHCSosbCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.99);})
caf::Proxy< caf::SRIDBranch > sel
Definition: SRProxy.h:2141
const Cut kNueRHCSobCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.97);})
const Binning kRecoEBinning
const Cut kNumuQuality
Definition: NumuCuts.h:18
const Cut kNus2017MinusCVN
const Var kXSecCVWgt2017
Definition: XsecTunes.h:36
const Cut kNus17FDPresel
The Nus17 preselection cuts for the Far Detector from docdb 21113.
Definition: NusCuts17.h:38
const Cut kNueFHCSosbCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.97);})
static Binning Simple(int n, double lo, double hi, const std::vector< std::string > &labels={})
Definition: Binning.cxx:107
const Cut kNusFHCSobCVNELU([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.97);})
const Cut kNueRHCSosbCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.98);})
const Cut kNusFHCSosbCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.99);})
const Cut kNumuFHCSobCVNSS([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.98);})
const TString varName
caf::Proxy< float > numuid
Definition: SRProxy.h:907
const Cut kNueFHCSobCVN2017([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.96);})