NumuVarsExtra.cxx

Go to the documentation of this file.

#include "3FlavorAna/Vars/NumuVarsExtra.h"
#include "3FlavorAna/Vars/NumuVars.h"
#include "CAFAna/Vars/Vars.h"
#include "CAFAna/Vars/TruthVars.h"
#include "3FlavorAna/Vars/NueVarsExtra.h"

#include "StandardRecord/Proxy/SRProxy.h"

#include "Utilities/func/MathUtil.h"

namespace ana
{

  const Binning kXYBinsND = Binning::Simple(44,-2.20,2.20);
  const Binning kZBinsND = Binning::Simple(40,  0,20.00);
  const Binning kXYBinsFD = Binning::Simple(160, -8.0, 8.0);
  const Binning kZBinsFD = Binning::Simple(120, 0, 60.0);

  const Binning kEnergyBinning = Binning::Simple(200,0,20);
  const Binning kEnergyBinningZoom = Binning::Simple(50, 0, 5);
  const Binning kHadronicEnergyBinning = Binning::Simple(50,0,5);
  const Binning kHadronicEnergyBinningZoom = Binning::Simple(20,0,2);

  const MultiVar kPngCalE([](const caf::SRProxy* sr)
      {
        std::vector<double> E;
        if(!sr->vtx.elastic.IsValid) return E;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          E.emplace_back(sr->vtx.elastic.fuzzyk.png[i].calE);
        }
        return E;
      });


  const MultiVar kPngWtCalE([](const caf::SRProxy* sr)
      {
        std::vector<double> E;
        if(!sr->vtx.elastic.IsValid) return E;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          E.emplace_back(sr->vtx.elastic.fuzzyk.png[i].weightedCalE);
        }
        return E;
      });

  const MultiVar kPngNhit([](const caf::SRProxy* sr)
      {
        std::vector<double> nhit;
        if(!sr->vtx.elastic.IsValid) return nhit;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          nhit.emplace_back(sr->vtx.elastic.fuzzyk.png[i].nhit);
        }
        return nhit;
      });

  const MultiVar kPngNhitX([](const caf::SRProxy* sr)
      {
        std::vector<double> nhit;
        if(!sr->vtx.elastic.IsValid) return nhit;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          nhit.emplace_back(sr->vtx.elastic.fuzzyk.png[i].nhitx);
        }
        return nhit;
      });


  const MultiVar kPngNhitY([](const caf::SRProxy* sr)
      {
        std::vector<double> nhit;
        if(!sr->vtx.elastic.IsValid) return nhit;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          nhit.emplace_back(sr->vtx.elastic.fuzzyk.png[i].nhity);
        }
        return nhit;
      });

  const MultiVar kPngNPlane([](const caf::SRProxy* sr)
      {
        std::vector<double> nplane;
        if(!sr->vtx.elastic.IsValid) return nplane;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          nplane.emplace_back(sr->vtx.elastic.fuzzyk.png[i].nplane);
        }
        return nplane;
      });

  const MultiVar kPngMaxPlaneCont([](const caf::SRProxy* sr)
      {
        std::vector<double> maxplane;
        if(!sr->vtx.elastic.IsValid) return maxplane;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          maxplane.emplace_back(sr->vtx.elastic.fuzzyk.png[i].maxplanecont);
        }
        return maxplane;
      });

  const MultiVar kPngMaxPlaneGap([](const caf::SRProxy* sr)
      {
        std::vector<double> maxplane;
        if(!sr->vtx.elastic.IsValid) return maxplane;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          maxplane.emplace_back(sr->vtx.elastic.fuzzyk.png[i].maxplanegap);
        }
        return maxplane;
      });

  const MultiVar kPngLen([](const caf::SRProxy* sr)
      {
        std::vector<double> len;
        if(!sr->vtx.elastic.IsValid) return len;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          len.emplace_back(sr->vtx.elastic.fuzzyk.png[i].len/100.);
        }
        return len;
      });

  const MultiVar kPngDirX([](const caf::SRProxy* sr)
      {
        std::vector<double> dir;
        if(!sr->vtx.elastic.IsValid) return dir;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          dir.emplace_back(sr->vtx.elastic.fuzzyk.png[i].dir.X());
        }
        return dir;
      });
  const MultiVar kPngDirY([](const caf::SRProxy* sr)
      {
        std::vector<double> dir;
        if(!sr->vtx.elastic.IsValid) return dir;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          dir.emplace_back(sr->vtx.elastic.fuzzyk.png[i].dir.Y());
        }
        return dir;
      });
  const MultiVar kPngDirZ([](const caf::SRProxy* sr)
      {
        std::vector<double> dir;
        if(!sr->vtx.elastic.IsValid) return dir;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          dir.emplace_back(sr->vtx.elastic.fuzzyk.png[i].dir.Z());
        }
        return dir;
      });

  const MultiVar kPngStartX([](const caf::SRProxy* sr)
      {
        std::vector<double> start;
        if(!sr->vtx.elastic.IsValid) return start;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          start.emplace_back(sr->vtx.elastic.fuzzyk.png[i].start.X()/100.);
        }
        return start;
      });
  const MultiVar kPngStartY([](const caf::SRProxy* sr)
      {
        std::vector<double> start;
        if(!sr->vtx.elastic.IsValid) return start;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          start.emplace_back(sr->vtx.elastic.fuzzyk.png[i].start.Y()/100.);
        }
        return start;
      });
  const MultiVar kPngStartZ([](const caf::SRProxy* sr)
      {
        std::vector<double> start;
        if(!sr->vtx.elastic.IsValid) return start;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng; ++i){
          start.emplace_back(sr->vtx.elastic.fuzzyk.png[i].start.Z()/100.);
        }
        return start;
      });






  const MultiVar kPng2dCalE([](const caf::SRProxy* sr)
      {
        std::vector<double> E;
        if(!sr->vtx.elastic.IsValid) return E;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          E.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].calE);
        }
        return E;
      });


  const MultiVar kPng2dWtCalE([](const caf::SRProxy* sr)
      {
        std::vector<double> E;
        if(!sr->vtx.elastic.IsValid) return E;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          E.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].weightedCalE);
        }
        return E;
      });

  const MultiVar kPng2dNhit([](const caf::SRProxy* sr)
      {
        std::vector<double> nhit;
        if(!sr->vtx.elastic.IsValid) return nhit;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          nhit.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].nhit);
        }
        return nhit;
      });

  const MultiVar kPng2dNhitX([](const caf::SRProxy* sr)
      {
        std::vector<double> nhit;
        if(!sr->vtx.elastic.IsValid) return nhit;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          nhit.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].nhitx);
        }
        return nhit;
      });


  const MultiVar kPng2dNhitY([](const caf::SRProxy* sr)
      {
        std::vector<double> nhit;
        if(!sr->vtx.elastic.IsValid) return nhit;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          nhit.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].nhity);
        }
        return nhit;
      });

  const MultiVar kPng2dNPlane([](const caf::SRProxy* sr)
      {
        std::vector<double> nplane;
        if(!sr->vtx.elastic.IsValid) return nplane;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          nplane.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].nplane);
        }
        return nplane;
      });

  const MultiVar kPng2dMaxPlaneCont([](const caf::SRProxy* sr)
      {
        std::vector<double> maxplane;
        if(!sr->vtx.elastic.IsValid) return maxplane;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          maxplane.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].maxplanecont);
        }
        return maxplane;
      });

  const MultiVar kPng2dMaxPlaneGap([](const caf::SRProxy* sr)
      {
        std::vector<double> maxplane;
        if(!sr->vtx.elastic.IsValid) return maxplane;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          maxplane.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].maxplanegap);
        }
        return maxplane;
      });

  const MultiVar kPng2dLen([](const caf::SRProxy* sr)
      {
        std::vector<double> len;
        if(!sr->vtx.elastic.IsValid) return len;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          len.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].len/100.);
        }
        return len;
      });


  const MultiVar kPng2dDirX([](const caf::SRProxy* sr)
      {
        std::vector<double> dir;
        if(!sr->vtx.elastic.IsValid) return dir;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          dir.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].dir.X());
        }
        return dir;
      });
  const MultiVar kPng2dDirY([](const caf::SRProxy* sr)
      {
        std::vector<double> dir;
        if(!sr->vtx.elastic.IsValid) return dir;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          dir.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].dir.Y());
        }
        return dir;
      });
  const MultiVar kPng2dDirZ([](const caf::SRProxy* sr)
      {
        std::vector<double> dir;
        if(!sr->vtx.elastic.IsValid) return dir;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          dir.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].dir.Z());
        }
        return dir;
      });

  const MultiVar kPng2dStartX([](const caf::SRProxy* sr)
      {
        std::vector<double> start;
        if(!sr->vtx.elastic.IsValid) return start;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          start.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].start.X()/100.);
        }
        return start;
      });
  const MultiVar kPng2dStartY([](const caf::SRProxy* sr)
      {
        std::vector<double> start;
        if(!sr->vtx.elastic.IsValid) return start;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          start.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].start.Y()/100.);
        }
        return start;
      });
  const MultiVar kPng2dStartZ([](const caf::SRProxy* sr)
      {
        std::vector<double> start;
        if(!sr->vtx.elastic.IsValid) return start;
        for(unsigned int i = 0; i < sr->vtx.elastic.fuzzyk.npng2d; ++i){
          start.emplace_back(sr->vtx.elastic.fuzzyk.png2d[i].start.Z()/100.);
        }
        return start;
      });


  const Var kNPng3D([](const caf::SRProxy* sr)
      {
        if(!sr->vtx.elastic.IsValid) return -5;
        return (int)sr->vtx.elastic.fuzzyk.npng;
      });

  const Var kNPng2D([](const caf::SRProxy* sr)
      {
        if(!sr->vtx.elastic.IsValid) return -5;
        return (int)sr->vtx.elastic.fuzzyk.npng2d;
      });

  const Var kOrphCalE([](const caf::SRProxy* sr)
      {
        if(!sr->vtx.elastic.IsValid) return -5.f;
        return (float)sr->vtx.elastic.fuzzyk.orphCalE;
      });

  const Var kKalTrkOverlapE([](const caf::SRProxy* sr)
      {
        if(sr->trk.kalman.ntracks < 1) return -5.f;
        return (float)sr->trk.kalman.tracks[0].overlapE;
      });

  const Var kVtxXm([](const caf::SRProxy* sr)
      {
        return float(kVtxX(sr)/100.);
      });

  const Var kVtxYm([](const caf::SRProxy* sr)
      {
        return float(kVtxY(sr)/100.);
      });

  const Var kVtxZm([](const caf::SRProxy* sr)
      {
        return float(kVtxZ(sr)/100.);
      });

  const Var kNNonNoise([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return float(sr->slc.nnonnoise);
      });

  const Var kNNonNoiseWt([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return float(1./kNNonNoise(sr));
      });


  const Var kTrueVisE([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visE;
      });

  const Var kTrueVisEinSlc([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visEinslc;
      });

  const Var kTrueVisENeutron([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visENeutron;
      });

  const Var kTrueVisEinSlcNeutron([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visEinslcNeutron;
      });

  const Var kTrueVisEBirks([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visEBirks;
      });

  const Var kTrueVisEinSlcBirks([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visEinslcBirks;
      });

  const Var kTrueVisENeutronBirks([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visENeutronBirks;
      });

  const Var kTrueVisEinSlcNeutronBirks([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].visEinslcNeutronBirks;
      });

  const Var kTrueSlcEff([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].eff;
      });

  const Var kTrueSlcPur([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].pur;
      });

  const Var kTrueNHitsSlc([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].nhitslc;
      });

  const Var kTrueNHitsTot([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].nhittot;
      });

  const Var kTrueMomX([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].p.X();
      });

  const Var kTrueMomY([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].p.Y();
      });

  const Var kTrueMomZ([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return (float)sr->mc.nu[0].p.Z();
      });


  const Var kTrueVtxX([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5555.f;
        return float(sr->mc.nu[0].vtx.X()/100.);
      });

  const Var kTrueVtxY([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5555.f;
        return float(sr->mc.nu[0].vtx.Y()/100.);
      });

  const Var kTrueVtxZ([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return float(sr->mc.nu[0].vtx.Z()/100.);
      });

  const Var kEres([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return float((kCCE(sr)-kTrueE(sr))/kTrueE(sr));
      });

  const Var kMuEres([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        return float((kMuE(sr)-kTrueMuonE(sr))/kTrueMuonE(sr));
      });

  const Var kHadEres([](const caf::SRProxy* sr)
      {
        if(sr->mc.nnu==0) return -5.f;
        float recoE = kHadE(sr);
        float trueE = kTrueE(sr)-kMuE(sr);
        
        return float((recoE-trueE)/trueE);
      });

  const Var kTrkNPlaneGapFrac([](const caf::SRProxy* sr)
      { 
        if(sr->mc.nnu==0) return -5.f;
        if (sr->trk.kalman.ntracks > 0 && sr->trk.kalman.idxremid != 999)
          return float(float(sr->trk.kalman.tracks[0].nplanegap)/float(sr->trk.kalman.tracks[0].nplane));
        return -5.f;
      });

  // --- NuTree --- 

  const NuTruthVar kTrueVisE_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visE;
      });

  const NuTruthVar kTrueVisEinSlc_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visEinslc;
      });

  const NuTruthVar kTrueVisENeutron_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visENeutron;
      });

  const NuTruthVar kTrueVisEinSlcNeutron_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visEinslcNeutron;
      });

  const NuTruthVar kTrueVisEBirks_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visEBirks;
      });

  const NuTruthVar kTrueVisEinSlcBirks_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visEinslcBirks;
      });

  const NuTruthVar kTrueVisENeutronBirks_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visENeutronBirks;
      });

  const NuTruthVar kTrueVisEinSlcNeutronBirks_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->visEinslcNeutronBirks;
      });

  const NuTruthVar kTrueSlcEff_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->eff;
      });

  const NuTruthVar kTrueSlcPur_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->pur;
      });

  const NuTruthVar kTrueNHitsSlc_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->nhitslc;
      });

  const NuTruthVar kTrueNHitsTot_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->nhittot;
      });

  const NuTruthVar kTrueMomX_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->p.X();
      });

  const NuTruthVar kTrueMomY_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->p.Y();
      });

  const NuTruthVar kTrueMomZ_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return (float)nu->p.Z();
      });

  const NuTruthVar kTrueVtxX_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return float(nu->vtx.X()/100.);
      });

  const NuTruthVar kTrueVtxY_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return float(nu->vtx.Y()/100.);
      });

  const NuTruthVar kTrueVtxZ_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return float(nu->vtx.Z()/100.);
      });

  const NuTruthVar kTrueLepE_NT([](const caf::SRNeutrinoProxy* nu)
      {
        // lepton is the first entry in the primaries list
        return float(nu->prim[0].p.E);
      });

  const NuTruthVar kTrueMode_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return int(nu->mode);
      });

  const NuTruthVar kTrueq0q3_NT([](const caf::SRNeutrinoProxy* nu)
      {
        return float(kTrueQ0_NT(nu)/kTrueQ3_NT(nu));
      });

  const Var kAngleKal = SIMPLEVAR(sel.cosrej.anglekal);
  const Var kNueCosRejPngPTP = SIMPLEVAR(sel.nuecosrej.pngptp);
}