da/d3e/helper__pur__slc__cumulative_8h_source.html

 #pragma once


 #include "helper.h"


 using namespace ana;


 // These are examples of useful structs to

 // use when making a bunch of Spectra

 struct PlotDef {

   std::string suffix = "";

   std::string label = "";

   Binning bins = Binning::Simple(3, 0, 3);

   Var var = kCounting;

 };


 const Binning kBDTBinning = Binning::Simple(40, 0, 1.0);

 const Binning kEnergyBinningGeV = Binning::Simple(40, 0, 3);

 const Binning kdEdxBinning = Binning::Simple(40, 0, 10);

 const Binning kGapBinning = Binning::Simple(20, 0, 20);

 const Binning kDensityBinning = Binning::Simple(20, 0., 20);

 const Binning kOpenAngleBinning = Binning::Simple(20, 0., 1);

 const Binning kLengthBinning = Binning::Simple(42, -5.01, 200);

 const Binning kPEBinning = Binning::Simple(70, 0., 1400);

 const Binning kTimeBinning = Binning::Simple(70, -3500, 3500);

 const Binning kFlashBinning = Binning::Simple(40, -6.f, 34.f);

 const Binning kPdgBinning = Binning::Simple(5000, -2500, 2500);


 // // In this example, we are making the following Spectra

 std::vector<PlotDef> plots = {

   { "count", "", Binning::Simple(3, 0, 3), kCounting },

   { "bestenergy", "Best plane energy (GeV)", kEnergyBinningGeV, kRecoShower_BestEnergy },

   { "conversion", "Conversion gap (cm)", kGapBinning, kRecoShower_ConversionGap },

   { "dedx", "dEdx (MeV/cm)", kdEdxBinning, kRecoShower_BestdEdx },

   { "slength", "Shower Length (cm)", kLengthBinning, kRecoShower_Length },

   { "tlength", "Longest Track Length (cm)", kLengthBinning, kLongestTrackLength },

   { "openangle", "Opening angle (rad)", kOpenAngleBinning, kRecoShower_OpenAngle },

   { "density", "Shower density (MeV/cm)", kDensityBinning, kRecoShower_Density },

   { "startx", "Shower start position X (cm)", kPositionXNDBinning, kRecoShower_StartX },

   { "starty", "Shower start position Y (cm)", kPositionYNDBinning, kRecoShower_StartY },

   { "startz", "Shower start position Z (cm)", kPositionZNDBinning, kRecoShower_StartZ },

   { "vtxx", "Slice vertex X (cm)", kPositionXNDBinning, kSlcVtxX },

   { "vtxy", "Slice vertes Y (cm)", kPositionYNDBinning, kSlcVtxY },

   { "vtxz", "Slice vertex Z (cm)", kPositionZNDBinning, kSlcVtxZ },

   { "nuScore", "Slice Nu Score", kBDTBinning, kSlcNuScore },

   { "flashScore", "Slice Flash Score", kFlashBinning, kSlcFlashScore },

   { "vtxdist", "Vertex Distance (cm)", kGapBinning, kTruthVtxDistMag },

   { "trueshwpdg", "True Shower Pdg", kPdgBinning, kRecoShower_TruePdg },

   { "truetrkpdg", "True Track Pdg", kPdgBinning, kLongestTrackTruePdg },

 };


 // Selection Struc

 struct SelDef {

   std::string suffix = "";

   std::string label = "";

   Cut cut = kNoCut;

   int color = kBlack;

 };


 std::vector<SelDef> types = {

   { "nuecc", "NuE CC", kSlcIsRecoNu&& kNuECC, kBlue + 1 },

   { "numucc", "NuMu CC", kSlcIsRecoNu&& kNuMuCC, kRed + 1 },

   { "nunc", "NC", kSlcIsRecoNu&& kNC, kOrange },

   { "othernu", "Other Nu", kSlcIsRecoNu&& kOtherNu, kOrange },

   { "cosmic", "Cosmic", kSlcIsRecoNu&& kCosmicRay, kBlack },

 };


 std::vector<SelDef> sels = {

   { "fvcut", "FV Cut", kFiducialVolumeND&& kVtxDistMagCut, kBlue },

   { "nuscorecut", "Nu Score Cut", kSlcNuScoreCut, kBlue },

   { "fmatchcut", "Flah Match Cut", kSlcFlashMatchCut, kBlue },

   { "recosel", "Reco Selection", kRecoNueSel, kBlue },

   { "trklencut", "Track Length Cut", kNueTrackLenCut, kBlue },

   { "shwdensitycut", "Shower Density Cut", kShowerDensityCut, kBlue },

   { "shwconvgapcut", "Conversion Gap Cut", kShowerConvGapCut, kBlue },

   { "shwdedxcut", "Shower dEdx Cut", kShowerdEdxCut, kBlue },

   { "fullsel", "Full Selection", kFullNueSel, kBlue },

 };


 // std::vector<SelDef> sels = {

 //   { "fvcut", "FV Cut", kFiducialVolumeND&& kVtxDistMagCut, kBlue },

 //   { "presel", "Pre Selection", kPreNueSel, kBlue },

 //   { "recosel", "Reco Selection", kRecoNueSel, kBlue },

 //   { "fullsel", "Full Selection", kFullNueSel, kBlue },

 // };

kLengthBinning
const Binning kLengthBinning
Definition: helper_nuesel_icarus.h:83

ana::kShowerConvGapCut
const Cut kShowerConvGapCut([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].conversion_gap< 3.25f);})
Definition: NueCuts.h:22

ana::kNoCut
const Cut kNoCut([](const caf::SRSliceProxy *){return true;})
The simplest possible cut: pass everything, used as a default.

ana::kRecoShower_OpenAngle
const Var kRecoShower_OpenAngle([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?180.*shw->open_angle/M_PI:-5.;})
Definition: NueVars.h:16

ana::kShowerDensityCut
const Cut kShowerDensityCut([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].density > 4.5);})
Definition: NueCuts.h:23

helper.h

ana::Binning
Represent the binning of a Spectrum&#39;s x-axis.
Definition: Binning.h:18

kTimeBinning
const Binning kTimeBinning
Definition: helper_nuesel_icarus.h:85

kDensityBinning
const Binning kDensityBinning
Definition: helper_nuesel_icarus.h:81

ana::kBDTBinning
const Binning kBDTBinning
Definition: Binnings.cxx:40

ana::kRecoShower_StartX
const Var kRecoShower_StartX([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?double(shw->start.x):-9999.;})
Definition: NueVars.h:17

ana::kSlcFlashScore
const Var kSlcFlashScore([](const caf::SRSliceProxy *slc) -> double{return((bool) kSlcHasFlash(slc)?(float) slc->fmatch.score:-5.f);})
Definition: Vars.h:35

ana::kPositionYNDBinning
const Binning kPositionYNDBinning
Definition: Binnings.cxx:30

ana::kSlcFlashMatchCut
const Cut kSlcFlashMatchCut([](const caf::SRSliceProxy *slc){return(kSlcHasFlashMatch(slc)&&slc->fmatch.score >0 &&slc->fmatch.score< 6);})
Definition: SBNAna/Cuts/Cuts.h:28

ana::kPositionZNDBinning
const Binning kPositionZNDBinning
Definition: Binnings.cxx:31

ana::kRecoShower_StartY
const Var kRecoShower_StartY([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?double(shw->start.y):-9999.;})
Definition: NueVars.h:18

ana::kTruthVtxDistMag
const Var kTruthVtxDistMag([](const caf::SRSliceProxy *slc) -> double{return(kHasTruthMatch(slc)?(float) std::hypot(kTruthVtxDistX(slc), kTruthVtxDistY(slc), kTruthVtxDistZ(slc)):-5.f);})
Definition: TruthVars.h:20

kOpenAngleBinning
const Binning kOpenAngleBinning
Definition: helper_nuesel_icarus.h:82

ana
process_name opflashCryoW ana
Definition: stage0_icarus_light_only.fcl:60

kdEdxBinning
const Binning kdEdxBinning
Definition: helper_eff_spill.h:81

ana::kSlcVtxX
const Var kSlcVtxX([](const caf::SRSliceProxy *slc) -> double{return slc->vertex.x;})
Definition: Vars.h:30

kEnergyBinningGeV
const Binning kEnergyBinningGeV
Definition: helper_eff_spill.h:80

ana::kSlcVtxY
const Var kSlcVtxY([](const caf::SRSliceProxy *slc) -> double{return slc->vertex.y;})
Definition: Vars.h:31

SelDef
Definition: demo.h:63

ana::kFullNueSel
const Cut kFullNueSel
Definition: NueCuts.h:38

ana::kRecoShower_BestEnergy
const Var kRecoShower_BestEnergy([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?double(shw->bestplane_energy):-5;})
Definition: NueVars.h:10

ana::kFiducialVolumeND
const Cut kFiducialVolumeND([](const caf::SRSliceProxy *slc){return PtInVolAbsX(slc->vertex, fvndAbs);})
Definition: SBNAna/Cuts/Cuts.h:17

ana::kSlcVtxZ
const Var kSlcVtxZ([](const caf::SRSliceProxy *slc) -> double{return slc->vertex.z;})
Definition: Vars.h:32

ana::kSlcIsRecoNu
const Cut kSlcIsRecoNu([](const caf::SRSliceProxy *slc){return!slc->is_clear_cosmic;})
Definition: SBNAna/Cuts/Cuts.h:24

types
std::vector< SelDef > types
Definition: helper_eff_spill.h:160

ana::kPositionXNDBinning
const Binning kPositionXNDBinning
Definition: Binnings.cxx:29

kPEBinning
const Binning kPEBinning
Definition: helper_nuesel_icarus.h:84

ana::kRecoShower_Length
const Var kRecoShower_Length([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?double(shw->len):-5.;})
Definition: NueVars.h:15

plots
std::vector< PlotDef > plots
Definition: demo.h:54

kCosmicRay
const Cut kCosmicRay
Definition: PAC2020/SBND/helper.h:54

ana::kSlcNuScoreCut
const Cut kSlcNuScoreCut([](const caf::SRSliceProxy *slc){return(kSlcIsRecoNu(slc)&&slc->nu_score >0.4);})
Definition: SBNAna/Cuts/Cuts.h:25

ana::kNueTrackLenCut
const Cut kNueTrackLenCut([](const caf::SRSliceProxy *slc){return kLongestTrackLength(slc)< 110.f;})
Definition: NueCuts.h:13

ana::kRecoShower_StartZ
const Var kRecoShower_StartZ([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?double(shw->start.z):-9999.;})
Definition: NueVars.h:19

sels
std::vector< SelDef > sels
Definition: demo.h:77

kNuMuCC
const Cut kNuMuCC
Definition: PAC2020/SBND/helper.h:58

ana::kRecoNueSel
const Cut kRecoNueSel
Definition: NueCuts.h:37

ana::kShowerdEdxCut
const Cut kShowerdEdxCut([](const caf::SRSliceProxy *slc){const int largestShwIdx(kLargestRecoShowerIdx(slc));return false;return(slc->reco.shw[largestShwIdx].bestplane_dEdx< 3.625f);})
Definition: NueCuts.h:21

PlotDef
Definition: demo.h:45

ana::kRecoShower_Density
const Var kRecoShower_Density([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?double(shw->density):-5.;})
Definition: NueVars.h:13

ana::kLongestTrackTruePdg
const Var kLongestTrackTruePdg([](const caf::SRSliceProxy *slc) -> int{const caf::SRTrackProxy *trk=LongestRecoTrack(slc);return trk?int(trk->truth.p.pdg):-5;})
Definition: NueVars.h:30

kNuECC
const Cut kNuECC
Definition: PAC2020/SBND/helper.h:57

kGapBinning
const Binning kGapBinning
Definition: helper_nuesel_icarus.h:80

ana::kCounting
const Var kCounting
Definition: Vars.cxx:19

kFlashBinning
const Binning kFlashBinning
Definition: helper_nuesel_icarus.h:86

ana::Current::kNC
Neutral-current interactions.
Definition: IPrediction.h:39

ana::kRecoShower_ConversionGap
const Var kRecoShower_ConversionGap([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?double(shw->conversion_gap):-5.;})
Definition: NueVars.h:12

kOtherNu
const Cut kOtherNu
Definition: PAC2020/SBND/helper.h:60

ana::_Cut< caf::SRSliceProxy >

ana::_Var< caf::SRSliceProxy >

ana::kRecoShower_BestdEdx
const Var kRecoShower_BestdEdx([](const caf::SRSliceProxy *slc) -> double{const caf::SRShowerProxy *shw=LargestRecoShower(slc);if(!shw||shw->bestplane_dEdx< 0) return-5.;return shw->bestplane_dEdx;})
Definition: NueVars.h:11

ana::kSlcNuScore
const Var kSlcNuScore([](const caf::SRSliceProxy *slc) -> double{return slc->nu_score;})
Definition: Vars.h:33

ana::Binning::Simple
static Binning Simple(int n, double lo, double hi, const std::vector< std::string > &labels={})
Definition: Binning.cxx:38

ana::kVtxDistMagCut
const Cut kVtxDistMagCut([](const caf::SRSliceProxy *slc){if(slc->truth.index< 0) return true;return(kTruthVtxDistMag(slc)< 1);})
Definition: SBNAna/Cuts/TruthCuts.h:27

kPdgBinning
const Binning kPdgBinning
Definition: helper_pur_slc_cumulative.h:26

ana::kRecoShower_TruePdg
const Var kRecoShower_TruePdg([](const caf::SRSliceProxy *slc) -> int{const caf::SRShowerProxy *shw=LargestRecoShower(slc);return shw?int(shw->truth.p.pdg):-5;})
Definition: NueVars.h:29

ana::kLongestTrackLength
const Var kLongestTrackLength([](const caf::SRSliceProxy *slc) -> double{const caf::SRTrackProxy *trk=LongestRecoTrack(slc);return trk?double(trk->len):-5.;})
Definition: NueVars.h:34