NumuCC1PiVars.h
Go to the documentation of this file.
1 #pragma once
2 #include "CAFAna/Core/Var.h"
3 #include "CAFAna/Core/MultiVar.h"
4 
5 #include "CAFAna/Vars/Vars.h"
6 
7 //#include "NDAna/nd_shared/NDXSecBPFMuonPID.h"
8 
9 #include <vector>
10 
11 
12 //#include "StandardRecord/Proxy/SRProxy.h"
14 //#include "NDAna/numucc_1Pi/NumuCC1PiVars.h"
15 
16 namespace ana
17 {
18 
19  //----- Truth Vars --------
20 
21  /*
22  const NuTruthVar kTruePionEnergy_NT([](const caf::SRNeutrinoProxy* nu)
23  {
24  // Kinetic energy of true charged pions
25  //
26  // NB: This returns one value per event, so it is really only
27  // applicable if there is a single pion.
28 
29 
30  int nPrims = nu->prim.size();
31  int nPions = 0;
32 
33  double energy = -5.0;
34 
35  for(int prim_idx = 0; prim_idx < nPrims; prim_idx++){
36  auto &prim = nu->prim[prim_idx];
37  int pdg = prim.pdg;
38 
39  if(abs(pdg) == 211){
40 
41  energy = prim.p.E;
42  energy -= pion_mass;
43  nPions++;
44  }
45  }
46  return energy;
47  });
48 
49 
50  const NuTruthVar kTrueProtonEnergy_NT([](const caf::SRNeutrinoProxy* nu)
51  {
52  // True kinetic energy of most energetic proton
53 
54  double ret_value = -5;
55 
56  int nPrims = nu->prim.size();
57 
58  double energy = -5.0;
59 
60  for(int prim_idx = 0; prim_idx < nPrims; prim_idx++){
61  auto &prim = nu->prim[prim_idx];
62  int pdg = prim.pdg;
63 
64  if(abs(pdg) == 2212){
65  energy = prim.p.E;
66  if(energy > ret_value) ret_value = energy;
67  }// end if(proton)
68 
69  }// end for(prim)
70 
71  ret_value -= proton_mass;
72  return ret_value;
73  });
74  */
75 
76  const NuTruthVar kNPions_NT([](const caf::SRNeutrinoProxy* nu)
77  {
78  int nPrims = nu->prim.size();
79 
80  int nPions = 0;
81 
82  for(int prim_idx = 0; prim_idx < nPrims; prim_idx++){
83  auto &prim = nu->prim[prim_idx];
84  int pdg = prim.pdg;
85 
86  if(abs(pdg) == 211){
87  nPions++;
88  }
89  }
90 
91  return nPions;
92 
93  });
94 
95  const NuTruthVar kNProtons_NT([](const caf::SRNeutrinoProxy* nu)
96  {
97  int nPrims = nu->prim.size();
98 
99  int nProtons = 0;
100 
101  for(int prim_idx = 0; prim_idx < nPrims; prim_idx++){
102  auto &prim = nu->prim[prim_idx];
103  int pdg = prim.pdg;
104 
105  if(abs(pdg) == 2212){
106  nProtons++;
107  }
108  }
109 
110  return nProtons;
111 
112  });
113 
114 
115 
116  // ------ Regular Vars -------
117 
118  const Var kTrueE_nu([](const caf::SRProxy* sr){
119  if(sr->mc.nnu < 1) return -5.f;
120  return float(sr->mc.nu[0].E);
121 
122  });
123 
124  const Var kN3dPngs([](const caf::SRProxy* sr){
125 
126  if(sr->vtx.elastic.IsValid == false ) return -5;
127 
128  int nPngs = sr->vtx.elastic.fuzzyk.png.size();
129 
130  return nPngs;
131 
132  });
133 
134 
135  const Var kN2dPngs([](const caf::SRProxy* sr){
136 
137  if(sr->vtx.elastic.IsValid == false ) return -5;
138 
139  int nPngs2d = sr->vtx.elastic.fuzzyk.png2d.size();
140 
141  return nPngs2d;
142 
143  });
144 
145  /*
146  const Var kTruePionTrackEnergy([](const caf::SRProxy* sr)
147  {
148 
149  int nTrks = sr->trk.kalman.ntracks;
150  double energy = -5.0;
151 
152  if(nTrks <= 0) return -5.0;
153 
154  for(int trk_idx = 0; trk_idx < nTrks; trk_idx++){
155  auto &trk = sr->trk.kalman.tracks[trk_idx];
156  if( abs(trk.truth.pdg) == 211 ){
157 
158  energy = trk.truth.p.E;
159  energy -= pion_mass;
160  }
161  }
162  return energy;
163  });
164 
165 
166  const Var kTruePionProngEnergy([](const caf::SRProxy* sr){
167 
168  if(sr->vtx.elastic.IsValid == false) return -5.0;
169 
170  int nPions = 0;
171  int nPngs = sr->vtx.elastic.fuzzyk.png.size();
172  double energy = -5.0;
173 
174  if(nPngs <= 0) return -5.0;
175 
176  for(int png_idx = 0; png_idx < nPngs; png_idx++){
177  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
178  if(abs(png.truth.pdg) == 211){
179  // TODO: Do I need to add in motherpdg allowance above? Not sure its valid
180 
181 
182  // Just a sanity check
183  if(nPions != 0){
184  //std::cout << "-----------------WARNING----------------" << std::endl;
185  //std::cout << "Somehow there is more than one pion!! (Prong)" << std::endl;
186  }
187 
188  energy = png.truth.p.E;
189  energy -= pion_mass;
190  nPions++;
191  }
192  }
193 
194  return energy;
195  });
196  */
197 
200 
201  /*
202  const Var kTruePionEnergy = VarFromNuTruthVar(kTruePionEnergy_NT);
203  const Var kTrueProtonEnergy = VarFromNuTruthVar(kTrueProtonEnergy_NT);
204  */
205 
206  const MultiVar kProngEnergyRes(int pdg)
207  // Energy resolution of prongs with backtraced
208  // PDG == pdg
209 
210  // Not sure this does what I think it does tbh
211  {
212  const MultiVar kProngERes([pdg](const caf::SRProxy* sr)
213  {
214  std::vector<double> ERes_vec;
215 
216  double E_true;
217  double E_reco;
218  double E_res;
219 
220  if(sr->vtx.elastic.IsValid == false) return ERes_vec;
221 
222  int nPngs = sr->vtx.elastic.fuzzyk.npng;
223 
224  for(int ipng=0; ipng<nPngs; ipng++){
225 
226  auto &png = sr->vtx.elastic.fuzzyk.png[ipng];
227 
228  if(png.truth.pdg == pdg){
229 
230  E_true = png.truth.p.E;
231  E_reco = png.calE;
232 
233  E_res = (E_reco - E_true)/E_true;
234  ERes_vec.push_back(E_res);
235 
236  }
237 
238  }// end for ipng
239  return ERes_vec;
240  }); // end kProngERes
241 
242  return kProngERes;
243  }
244 
245  /*
246  const Var kScan_BPF([](const caf::SRProxy* sr){
247  // This is just a way to be able to scan TTree variables that I can't
248  // normally due to ROOT limitations on Tree depth
249 
250  if(sr->vtx.elastic.IsValid == false) return -5;
251 
252  int run = sr->hdr.run;
253  int subrun = sr->hdr.subrun;
254  int evt = sr->hdr.evt;
255  int slc = sr->hdr.subevt;
256  int cycle = sr->hdr.cycle;
257 
258  std::cout << std::endl;
259 
260  std::cout << run << " / " << subrun << " / " << evt << " / " << slc
261  << " / " << cycle << std::endl;
262 
263  for(uint png_idx = 0; png_idx < sr->vtx.elastic.fuzzyk.npng; png_idx++){
264 
265  auto &shwlid = sr->vtx.elastic.fuzzyk.png[png_idx].shwlid;
266  const TVector3 shwlid_start = shwlid.start;
267  const TVector3 shwlid_stop = shwlid.stop;
268 
269  auto &bpf = sr->vtx.elastic.fuzzyk.png[png_idx].bpf;
270  int n_bpf = bpf.size();
271  if(n_bpf < 1) return -5;
272 
273  int pdg = bpf[0].truth.pdg;
274  int motherpdg = bpf[0].truth.motherpdg;
275 
276  std::cout << "PDG : " << pdg << std::endl;
277  std::cout << "motherPDG : " << motherpdg << std::endl;
278 
279  std::cout << "shwlid_start : ";
280  printTVector(shwlid_start);
281 
282  std::cout << "shwlid_stop : ";
283  printTVector(shwlid_stop);
284  std::cout << std::endl;
285 
286 
287  for(int bpf_idx = 0; bpf_idx < n_bpf; bpf_idx++){
288  const TVector3 bpf_start = bpf[bpf_idx].start;
289  const TVector3 bpf_stop = bpf[bpf_idx].stop;
290 
291  std::cout << "bpf_pdg : " << bpf[bpf_idx].pdg << std::endl;
292 
293  std::cout << "bpf_start : ";
294  printTVector(bpf_start);
295 
296  std::cout << "bpf_stop : ";
297  printTVector(bpf_stop);
298 
299  std::cout << std::endl;
300 
301 
302  } // end for bpf
303  // std::cout << "--------" << std::endl;
304 
305  } // end for png
306  std::cout << "******************" << std::endl;
307  return 1;
308 
309  });
310  */
311 
312  const Var kTrueMuonProng([](const caf::SRProxy* sr)
313  // Returns idx of true muon prong
314  // TODO what is there is more than one muon prong?
315 
316  {
317  if(sr->vtx.elastic.IsValid == false) return -5;
318 
319  int itrue_muon_png = -5;
320 
321  int nPng = sr->vtx.elastic.fuzzyk.npng;
322 
323  for(int png_idx = 0; png_idx < nPng; png_idx++){
324  auto &bpf = sr->vtx.elastic.fuzzyk.png[png_idx].bpf;
325  //int n_bpf = bpf.size();
326  //if(n_bpf < 1) continue;
327  int pdg;
328  int motherpdg;
329 
330  if(bpf.muon.IsValid == true){
331  pdg = bpf.muon.truth.pdg;
332  motherpdg = bpf.muon.truth.motherpdg;
333  }
334  else if(bpf.pion.IsValid == true){
335  pdg = bpf.pion.truth.pdg;
336  motherpdg = bpf.pion.truth.motherpdg;
337  }
338  else if(bpf.proton.IsValid == true){
339  pdg = bpf.proton.truth.pdg;
340  motherpdg = bpf.proton.truth.motherpdg;
341  }
342  else continue;
343 
344  if(pdg == 13 && motherpdg == 13){
345  if(itrue_muon_png != -5){
346  std::cout << "More than one muon prong! There is a problem here..." << std::endl;
347  return -5;
348  }
349  itrue_muon_png = png_idx;
350  };
351 
352  } // end for png
353  return itrue_muon_png;
354  });
355 
356 
357 
358  const Var kBestMuonPng([](const caf::SRProxy* sr){
359  // Takes longest prong as muon if any prong > 500cm, otherwise takes
360  // prong with highest CVN muon score
361  //
362  // Removing the following as it makes it too confusing{, where muon score
363  // must also be higher than other scores for that prong}
364 
365  if(sr->vtx.elastic.IsValid == false) return -5;
366 
367  int nPng = sr->vtx.elastic.fuzzyk.npng;
368 
369  double maxLen = -5;
370  int maxLen_idx = -5;
371 
372  double maxCVN = -5;
373  int maxCVN_idx = -5;
374 
375  for(int png_idx = 0; png_idx < nPng; ++png_idx){
376  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
377 
378  double len = png.len;
379  if(len > maxLen){
380  maxLen = len;
381  maxLen_idx = png_idx;
382  }
383 
384  double cvn = png.cvnpart.muonid;
385  if(cvn > maxCVN){
386  maxCVN = cvn;
387  maxCVN_idx = png_idx;
388  }
389  } // end for png
390 
391  if(maxLen > 500) return maxLen_idx;
392 
393  return maxCVN_idx;
394 
395  });
396 
397  /*
398  const Var kBestPionPng([](const caf::SRProxy* sr)
399  {
400  // Returns idx of prong with highest cvn pion score excluding muon prong
401  //
402  // Removing the following as it just makes things too confusing{, where
403  // the pion score must also be higher than the other scores for that prong.}
404 
405  if(sr->vtx.elastic.IsValid == false) return -5;
406 
407  int nPng = sr->vtx.elastic.fuzzyk.npng;
408 
409  double maxCVN = -5;
410  int maxCVN_idx = -5;
411 
412  for(int png_idx = 0; png_idx < nPng; ++png_idx){
413 
414  if(png_idx == kBestBPFTrack(sr)) continue;
415 
416  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
417 
418  double cvn = png.cvnpart2FlatFluxBal.pionid;
419  if(cvn > maxCVN ){
420  maxCVN = cvn;
421  maxCVN_idx = png_idx;
422  }
423 
424  } // end for png
425 
426  return maxCVN_idx;
427  });
428  */
429 
430  const Var kHighestMuonCVN([](const caf::SRProxy* sr)
431  {
432  // Returns highest cvn muon score, unless any prong is longer than 500 cm,
433  // in which case returns 1.0
434  // (Only prongs )
435  // NB using 4-view CVN for prod5, as it is all that's available for now
436 
437  if(sr->vtx.elastic.IsValid == false) return -5.0;
438 
439  int nPng = sr->vtx.elastic.fuzzyk.npng;
440 
441  double maxCVN = -5.0;
442 
443  for(int png_idx = 0; png_idx < nPng; ++png_idx){
444 
445  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
446  double len = png.len;
447 
448  if(len > 500.0) return 1.0;
449 
450  double cvn = png.cvnpart.muonid;
451  if(cvn > maxCVN ){
452  maxCVN = cvn;
453  }
454 
455  } // end for png
456 
457 
458  // std::cout << "maxCVN: " << maxCVN << std::endl;
459  return maxCVN;
460  });
461 
462 
463 
464  const Var kHighestMuonCVN_byPDG(int pdg)
465  {
466  // returns highest muon CVN if partID matches pdg
467 
468 
469  const Var khighestmuoncvn([pdg](const caf::SRProxy* sr)
470  {
471  if(sr->vtx.elastic.IsValid == false) return -5.0;
472 
473  int nPng = sr->vtx.elastic.fuzzyk.npng;
474 
475  int iBestPng = kBestMuonPng(sr);
476 
477  if(iBestPng < 0 || iBestPng > nPng) return -5.0;
478 
479  auto &png = sr->vtx.elastic.fuzzyk.png[iBestPng];
480 
481  if(png.truth.pdg != pdg) return -5.0;
482 
483  double score = png.cvnpart.muonid;
484  return score;
485  });
486 
487 
488  return khighestmuoncvn;
489  }
490 
491 
492 
493 
494  const Var kNGoodPionPngs([](const caf::SRProxy* sr)
495  {
496  // Returns number of pion prongs other than muon
497  // with > 6 hits, and pion score > 0.8
498  //
499  // (Only prongs )
500  // NB using 4-view CVN for prod5, as it is all that's available for now
501 
502  if(sr->vtx.elastic.IsValid == false) return -5;
503 
504  int nPng = sr->vtx.elastic.fuzzyk.npng;
505 
506  int nPions = 0;
507 
508  for(int png_idx = 0; png_idx < nPng; ++png_idx){
509 
510  if(png_idx == kBestMuonPng(sr)) continue;
511 
512  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
513 
514  if(png.nhit <= 6) continue;
515 
516 
517  double cvn = png.cvnpart.pionid;
518  if(cvn > 0.8 ){
519  nPions++;
520  }
521 
522  } // end for png
523 
524 
525  //std::cout << "kNGoodPions = " << nPions << std::endl;
526  return nPions;
527  });
528 
529 
530 
531 
532  const Var kNhit_3d(int pdg)
533  {
534  // returns nhits of most energetic 3d prong matching pdg
535 
536  const Var knhit_3d([pdg](const caf::SRProxy* sr)
537  {
538  double ret_value = -5.0;
539  double max_energy = -5.0;
540 
541 
542  if(sr->vtx.elastic.IsValid == false) return ret_value;
543 
544  int nPngs = sr->vtx.elastic.fuzzyk.npng;
545  for(int png_idx=0; png_idx<nPngs; png_idx++){
546 
547  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
548  if(png.truth.pdg == pdg){
549 
550  if(png.truth.p.E > max_energy){
551  max_energy = png.truth.p.E;
552  ret_value = png.nhit;
553  }
554 
555  }
556 
557  }// end for png_idx
558  return ret_value;
559  }); // end knhit_3d
560 
561  return knhit_3d;
562  }
563 
564 
565  const Var kNhit_2d(int pdg)
566  {
567  // returns nhits of most energetic 2d prong matching pdg
568 
569  const Var knhit_2d([pdg](const caf::SRProxy* sr)
570  {
571  double ret_value = -5.0;
572  double max_energy = -5.0;
573 
574 
575  if(sr->vtx.elastic.IsValid == false) return ret_value;
576 
577  int nPngs = sr->vtx.elastic.fuzzyk.npng2d;
578  for(int png_idx=0; png_idx<nPngs; png_idx++){
579 
580  auto &png = sr->vtx.elastic.fuzzyk.png2d[png_idx];
581  if(png.truth.pdg == pdg){
582 
583  if(png.truth.p.E > max_energy){
584  max_energy = png.truth.p.E;
585  ret_value = png.nhit;
586  }
587 
588  }
589 
590  }// end for png_idx
591  return ret_value;
592  }); // end knhit_2d
593 
594  return knhit_2d;
595  }
596 
597 
598 
599  /*
600  const Var kBestPionCvnScore([](const caf::SRProxy* sr)
601  // Returns cvn pion score of kBestPionPng
602  {
603  if(!kGoodPionPngExists(sr)) return -5.0;
604 
605  int idx = kBestPionPng(sr);
606  auto &png = sr->vtx.elastic.fuzzyk.png[idx];
607  return double(png.cvnpart2FlatFluxBal.pionid);
608 
609  });
610 
611 
612 
613  // TODO this doesn't account for motherpdg
614  const MultiVar knhitByPdg(int pdg)
615  // Returns values of nhit but only for prongs with true Pdgcode == pdg
616  // (skips best muon prong)
617  {
618  const MultiVar knhit([pdg](const caf::SRProxy* sr)
619  {
620  std::vector<double> nhit_vec;
621 
622  if(sr->vtx.elastic.IsValid == false) return nhit_vec;
623 
624  int nPngs = sr->vtx.elastic.fuzzyk.npng;
625  for(int png_idx=0; png_idx<nPngs; png_idx++){
626 
627  if(png_idx == kBestBPFTrack(sr)) continue;
628 
629  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
630  if(png.truth.pdg == pdg){
631  nhit_vec.push_back(png.nhit);
632  }
633 
634  }// end for png_idx
635  return nhit_vec;
636  }); // end knhit
637 
638  return knhit;
639  }// end knhitByPdg
640 
641 
642  const MultiVar kcalEByPdg(int pdg)
643  // Returns values of calE but only for prongs with true Pdgcode == pdg
644  // (skips best muon prong)
645  {
646  const MultiVar kcalE([pdg](const caf::SRProxy* sr)
647  {
648  std::vector<double> calE_vec;
649 
650  if(sr->vtx.elastic.IsValid == false) return calE_vec;
651 
652  int nPngs = sr->vtx.elastic.fuzzyk.npng;
653  for(int png_idx=0; png_idx<nPngs; png_idx++){
654 
655  if(png_idx == kBestBPFTrack(sr)) continue;
656 
657  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
658  if(png.truth.pdg == pdg){
659  calE_vec.push_back(png.calE);
660  }
661 
662  }// end for png_idx
663  return calE_vec;
664  }); // end kcalE
665 
666  return kcalE;
667  }// end kcalEByPdg
668 
669 
670  const MultiVar klenByPdg(int pdg)
671  // Returns values of len but only for prongs with true Pdgcode == pdg
672  // (skips best muon prong)
673  {
674  const MultiVar klen([pdg](const caf::SRProxy* sr)
675  {
676  std::vector<double> len_vec;
677 
678  if(sr->vtx.elastic.IsValid == false) return len_vec;
679 
680  int nPngs = sr->vtx.elastic.fuzzyk.npng;
681  for(int png_idx=0; png_idx<nPngs; png_idx++){
682 
683  if(png_idx == kBestBPFTrack(sr)) continue;
684 
685  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
686  if(png.truth.pdg == pdg){
687  len_vec.push_back(png.len);
688  }
689 
690  }// end for png_idx
691  return len_vec;
692  }); // end klen
693 
694  return klen;
695  }// end klenByPdg
696 
697 
698 
699  const MultiVar ksimple_dEdxByPdg(int pdg)
700  // Returns values of simple_dEdx but only for prongs with true Pdgcode == pdg
701  // (skips best muon prong)
702  //
703  // simple_dEdx = calE / len
704  {
705  const MultiVar ksimple_dEdx([pdg](const caf::SRProxy* sr)
706  {
707  std::vector<double> simple_dEdx_vec;
708 
709  if(sr->vtx.elastic.IsValid == false) return simple_dEdx_vec;
710 
711  int nPngs = sr->vtx.elastic.fuzzyk.npng;
712  for(int png_idx=0; png_idx<nPngs; png_idx++){
713 
714  if(png_idx == kBestBPFTrack(sr)) continue;
715 
716  auto &png = sr->vtx.elastic.fuzzyk.png[png_idx];
717  if(png.truth.pdg == pdg){
718 
719  double simple_dEdx;
720  if(png.len == 0.0) simple_dEdx = -5.0;
721  // *100 converts to GeV/m
722  else simple_dEdx = 100*(png.calE / png.len);
723  simple_dEdx_vec.push_back(simple_dEdx);
724  }
725 
726  }// end for png_idx
727  return simple_dEdx_vec;
728  }); // end ksimple_dEdx
729 
730  return ksimple_dEdx;
731  }// end ksimple_dEdxByPdg
732 
733 
734 
735  const Var kVtxX([](const caf::SRProxy* sr){
736 
737  if(sr->vtx.elastic.IsValid == false ) return -5.;
738  double vtx_x = sr->vtx.elastic.vtx.x;
739  return vtx_x;
740  });
741 
742  const Var kVtxY([](const caf::SRProxy* sr){
743 
744  if(sr->vtx.elastic.IsValid == false ) return -5.;
745  double vtx_y = sr->vtx.elastic.vtx.y;
746  return vtx_y;
747  });
748 
749  const Var kVtxZ([](const caf::SRProxy* sr){
750 
751  if(sr->vtx.elastic.IsValid == false ) return -5.;
752  double vtx_z = sr->vtx.elastic.vtx.z;
753  return vtx_z;
754 
755  });
756  */
757 
758 
759  const MultiVar kTestMultiVar_A([](const caf::SRProxy* sr)
760  {
761  std::vector<double> ret_vec{-5};
762 
763  if(sr->vtx.elastic.IsValid == false) return ret_vec;
764  return ret_vec;
765  /*
766  int nPngs = sr->vtx.elastic.fuzzyk.npng;
767 
768  for(int ipng=0; ipng<nPngs; ipng++){
769  ret_vec.push_back(ipng);
770  }// end for ipng
771  return ret_vec;
772  */
773  }); // end kTestMultiVar_A
774 
775 
776 }
caf::Proxy< size_t > npng
Definition: SRProxy.h:2038
caf::Proxy< caf::SRFuzzyK > fuzzyk
Definition: SRProxy.h:2059
Cuts and Vars for the 2020 FD DiF Study.
Definition: vars.h:6
caf::Proxy< std::vector< caf::SRProng > > png2d
Definition: SRProxy.h:2044
Proxy for caf::SRNeutrino.
Definition: SRProxy.h:510
const Var kTrueMuonProng([](const caf::SRProxy *sr) {if(sr->vtx.elastic.IsValid==false) return-5;int itrue_muon_png=-5;int nPng=sr->vtx.elastic.fuzzyk.npng;for(int png_idx=0;png_idx< nPng;png_idx++){auto &bpf=sr->vtx.elastic.fuzzyk.png[png_idx].bpf; int pdg;int motherpdg;if(bpf.muon.IsValid==true){pdg=bpf.muon.truth.pdg;motherpdg=bpf.muon.truth.motherpdg;}else if(bpf.pion.IsValid==true){pdg=bpf.pion.truth.pdg;motherpdg=bpf.pion.truth.motherpdg;}else if(bpf.proton.IsValid==true){pdg=bpf.proton.truth.pdg;motherpdg=bpf.proton.truth.motherpdg;}else continue;if(pdg==13 &&motherpdg==13){if(itrue_muon_png!=-5){std::cout<< "More than one muon prong! There is a problem here..."<< std::endl;return-5;}itrue_muon_png=png_idx;};}return itrue_muon_png;})
const Var kN3dPngs([](const caf::SRProxy *sr){if(sr->vtx.elastic.IsValid==false) return-5;int nPngs=sr->vtx.elastic.fuzzyk.png.size();return nPngs;})
Proxy for caf::StandardRecord.
Definition: SRProxy.h:2126
caf::Proxy< std::vector< caf::SRNeutrino > > nu
Definition: SRProxy.h:618
void abs(TH1 *hist)
caf::Proxy< short int > nnu
Definition: SRProxy.h:617
const MultiVar kTestMultiVar_A([](const caf::SRProxy *sr){std::vector< double > ret_vec{-5};if(sr->vtx.elastic.IsValid==false) return ret_vec;return ret_vec;})
Defines an enumeration for prong classification.
_Var< caf::SRProxy > Var
Representation of a variable to be retrieved from a caf::StandardRecord object.
Definition: Var.h:74
const Var kNPions
caf::Proxy< caf::SRElastic > elastic
Definition: SRProxy.h:2118
caf::Proxy< std::vector< caf::SRFuzzyKProng > > png
Definition: SRProxy.h:2043
const Var kNhit_2d(int pdg)
const Var kBestMuonPng([](const caf::SRProxy *sr){ if(sr->vtx.elastic.IsValid==false) return-5;int nPng=sr->vtx.elastic.fuzzyk.npng;double maxLen=-5;int maxLen_idx=-5;double maxCVN=-5;int maxCVN_idx=-5;for(int png_idx=0;png_idx< nPng;++png_idx){auto &png=sr->vtx.elastic.fuzzyk.png[png_idx];double len=png.len;if(len > maxLen){maxLen=len;maxLen_idx=png_idx;}double cvn=png.cvnpart.muonid;if(cvn > maxCVN){maxCVN=cvn;maxCVN_idx=png_idx;}}if(maxLen > 500) return maxLen_idx;return maxCVN_idx;})
_Var< caf::SRNeutrinoProxy > NuTruthVar
Var designed to be used over the nuTree, ie all neutrinos, not just those that got slices...
Definition: Var.h:82
caf::StandardRecord * sr
const Var kHighestMuonCVN([](const caf::SRProxy *sr){ if(sr->vtx.elastic.IsValid==false) return-5.0;int nPng=sr->vtx.elastic.fuzzyk.npng;double maxCVN=-5.0;for(int png_idx=0;png_idx< nPng;++png_idx){auto &png=sr->vtx.elastic.fuzzyk.png[png_idx];double len=png.len;if(len > 500.0) return 1.0;double cvn=png.cvnpart.muonid;if(cvn > maxCVN){maxCVN=cvn;}} return maxCVN;})
caf::Proxy< caf::SRTruthBranch > mc
Definition: SRProxy.h:2138
const NuTruthVar kNProtons_NT([](const caf::SRNeutrinoProxy *nu){int nPrims=nu->prim.size();int nProtons=0;for(int prim_idx=0;prim_idx< nPrims;prim_idx++){auto &prim=nu->prim[prim_idx];int pdg=prim.pdg;if(abs(pdg)==2212){nProtons++;}}return nProtons;})
const NuTruthVar kNPions_NT([](const caf::SRNeutrinoProxy *nu){int nPrims=nu->prim.size();int nPions=0;for(int prim_idx=0;prim_idx< nPrims;prim_idx++){auto &prim=nu->prim[prim_idx];int pdg=prim.pdg;if(abs(pdg)==211){nPions++;}}return nPions;})
Var VarFromNuTruthVar(const NuTruthVar &stv, double _default)
Definition: Var.cxx:7
caf::Proxy< bool > IsValid
Definition: SRProxy.h:2058
const Var kN2dPngs([](const caf::SRProxy *sr){if(sr->vtx.elastic.IsValid==false) return-5;int nPngs2d=sr->vtx.elastic.fuzzyk.png2d.size();return nPngs2d;})
const Var kNProtons
const Var kTrueE_nu([](const caf::SRProxy *sr){if(sr->mc.nnu< 1) return-5.f;return float(sr->mc.nu[0].E);})
const MultiVar kProngEnergyRes(int pdg)
caf::Proxy< size_t > npng2d
Definition: SRProxy.h:2039
caf::Proxy< caf::SRVertexBranch > vtx
Definition: SRProxy.h:2146
const Var kHighestMuonCVN_byPDG(int pdg)
const Var kNGoodPionPngs([](const caf::SRProxy *sr){ if(sr->vtx.elastic.IsValid==false) return-5;int nPng=sr->vtx.elastic.fuzzyk.npng;int nPions=0;for(int png_idx=0;png_idx< nPng;++png_idx){if(png_idx==kBestMuonPng(sr)) continue;auto &png=sr->vtx.elastic.fuzzyk.png[png_idx];if(png.nhit<=6) continue;double cvn=png.cvnpart.pionid;if(cvn > 0.8){nPions++;}} return nPions;})
const Var kNhit_3d(int pdg)
caf::Proxy< std::vector< caf::SRTrueParticle > > prim
Definition: SRProxy.h:555