NueCuts2018.cxx

Go to the documentation of this file.

#include "3FlavorAna/Cuts/NueCuts2018.h"

#include "StandardRecord/Proxy/SRProxy.h"

#include <cassert>

namespace ana
{
  const Cut kNue2018CVNCut([](const caf::SRProxy* sr) {
      if(kIsRHC(sr)) return kNue2018RHCCVNCut(sr);
      else return kNue2018FHCCVNCut(sr);
  });

  const Cut kNearestSliceCosRej2018([](const caf::SRProxy* sr) {
      const double hibin = kIsRHC(sr) ? kNue2018CVNRHCHighEdge : kNue2018CVNFHCHighEdge;

      const double topcut = (kCVNSSe(sr) >= hibin) ? 50 : 400;

      return (fabs(sr->slc.closestslicetime) >= 100 ||
              sr->slc.closestsliceminfromtop >= topcut ||
              sr->slc.closestslicemindist >= 500);
    });

  bool kNue2018PeripheralPreselFunc(const caf::SRProxy* sr)
  {
    return (kNue2017BasicPart(sr) &&
            !kNue2018CorePart(sr) &&
            kNueEnergy2018(sr) < 4.5 &&
            kNueEnergy2018(sr) >= 0 &&
            kIsFarDet(sr));
  }

  bool kNue2018CVNVsCosPIDFunc(const caf::SRProxy* sr)
  {
    if(kIsRHC(sr)) return kNue2018CVNVsCosPIDRHC(sr);

    else return kNue2018CVNVsCosPIDFHC(sr);
  }

  bool kNue2018FDPeripheralFunc(const caf::SRProxy* sr)
  {
    return kNue2018PeripheralPresel(sr) && kNue2018CVNVsCosPID(sr) && kNearestSliceCosRej2018(sr);
  }

  const Cut kNue2018CVNCutLP([](const caf::SRProxy* sr) {
      if(kIsRHC(sr)) return kNue2018RHCCVNCutLP(sr);
      else return kNue2018FHCCVNCutLP(sr);
  });

  const Cut kNue2018CVNVsCosPIDLP([](const caf::SRProxy* sr){

        if(kNue2018CVNVsCosPID(sr)) return false;

        if(kIsRHC(sr)) return kNue2018CVNVsCosPIDRHCLP(sr);

        else return kNue2018CVNVsCosPIDFHCLP(sr);

  });

  const Var kNue2018SelectionBin([](const caf::SRProxy *sr){
      bool isPeri = kNue2018FDPeripheral(sr);

      if (isPeri)
        return float(2.5);

      std::cout << "ERROR::kNue2018SelectionBin. Looking for cvnProd3Train. Branch no longer exists." << std::endl;
      abort();
      /*
      const double lowedge = kIsRHC(sr) ? kNue2018CVNRHCLowEdge : kNue2018CVNFHCLowEdge;
      const double highedge = kIsRHC(sr) ? kNue2018CVNRHCHighEdge : kNue2018CVNFHCHighEdge;
      if (sr->sel.cvnProd3Train.nueid >= lowedge && sr->sel.cvnProd3Train.nueid < highedge)
        return float(0.5);
      else if (sr->sel.cvnProd3Train.nueid >= highedge)
        return float(1.5);
      else return float(-5.0);
      */
      return float(-5.0);
    });

  const Var kNue2018AnaBin([](const caf::SRProxy *sr){
      int selBin = kNue2018SelectionBin(sr);
      float nuE  = kNueEnergy2018(sr);
      int nuEBin = nuE/0.5;

      assert(nuEBin <= 8 && "An event with nuE > 4.5 should never happen");

      int anaBin = 9*selBin + nuEBin;

      return anaBin;
    });

  const Binning kNue2018Binning = Binning::Simple(27,0,27);

  const Var kNue2018AnaBinMergedPeripheral([](const caf::SRProxy *sr){
        int anaBin = kNue2018AnaBin(sr);
        anaBin = anaBin > 18 ? 20 : anaBin;
        return anaBin;
      });

  const Binning kNue2018BinningMergedPeripheral = Binning::Simple(23,0,23);

  const HistAxis kNue2018AxisMergedPeripheral("NuE Energy / Analysis Bin",
                                              kNue2018BinningMergedPeripheral,
                                              kNue2018AnaBinMergedPeripheral);

  const Var kNue2018AnaResBin([](const caf::SRProxy *sr){
    int selBin = kNue2018SelectionBin(sr);
    float nuERes  = (kNueEnergy2018(sr) - kTrueE(sr))/kTrueE(sr);
    int nuEBin = (nuERes + 1)*9 ;//double binning for resolution
    int anaBin = 18*selBin + nuEBin;
    return anaBin;
  });

  const HistAxis kNue2018ResAxis("NuE Energy Resolution / Analysis Bin",
                                 Binning::Simple(54, 0, 54), kNue2018AnaResBin);


  const Var kNue2018AnaSuperBin([](const caf::SRProxy *sr){
      int isPeri = 0;
      if(kNue2018FDPeripheral(sr)) isPeri = 1 ;

      std::cout << "ERROR::kNue2018SelectionBin. Looking for cvnProd3Train. Branch no longer exists." << std::endl;
      abort();
      //double cvn = sr->sel.cvnProd3Train.nueid;
      double cvn=-1;

      const double cvnlow = kIsRHC(sr) ? kNue2018CVNRHCLowEdge : kNue2018CVNFHCLowEdge;
      const double cvnhigh = kIsRHC(sr) ? kNue2018CVNRHCHighEdge : kNue2018CVNFHCHighEdge;

      assert(cvn >= cvnlow && cvn<=1 && "Wrong cvn value");

      float nuE  = kNueEnergy2018(sr);
      int nuEBin = nuE/0.5;

//      assert(nuEBin <= 8 && "An event with nuE > 4.5 should never happen");

      int cvnbin =(int)(cvn/cvnhigh);// cvn binning always do [) same for energy bin

      cvnbin += isPeri;//peripheral shifted from highest to the last bin

      int anaBin = 9*cvnbin + nuEBin;
      return anaBin;
    });

  const Binning kNue2018SuperBinning = Binning::Simple(27,0,27);

  const HistAxis kNue2018SuperAxis("NuE Energy / Analysis Bin",
                                   kNue2018SuperBinning,kNue2018AnaSuperBin);

  const Var kNue2018AnaSuperBinMergedPeripheral([](const caf::SRProxy *sr){
      int anaBin = kNue2018AnaSuperBin(sr);
      anaBin = anaBin > 18 ? 20: anaBin;
      return anaBin;
    });

  const Binning kNue2018SuperBinningMergedPeripheral = Binning::Simple(23,0,23);

  const HistAxis kNue2018SuperAxisMergedPeripheral("NuE Energy / Analysis Bin",
                                                   kNue2018SuperBinningMergedPeripheral,
                                                   kNue2018AnaSuperBinMergedPeripheral);
}