NueCuts2020.cxx

Go to the documentation of this file.

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

#include "StandardRecord/Proxy/SRProxy.h"

#include <cassert>

namespace ana
{
  //ECM this is copy paste with a better name 
  const Cut kNue2020RecoQuality([](const caf::SRProxy* sr) { 
      // Cut out FEB flashers
      if(sr->sel.nuecosrej.hitsperplane >= 8)
        return false;
      // Basic Reco Quality Cuts
      if(!sr->vtx.elastic.IsValid)
        return false;
      if(sr->vtx.elastic.fuzzyk.npng == 0)
        return false;
      return true;
    });
  
  /*const Cut kNue2020FDVeto([](const caf::SRProxy* sr) {  
      if(!kIsFarDet(sr)) return false;
      if(!sr->spill.cosmiccvn[0].passSel) return false;
      if(!kNue2017Veto(sr)) return false;
      return true;
    });
  */
  const Cut kNue2020FDNearestSlice([](const caf::SRProxy* sr) {
      const double hibin = kIsRHC(sr) ? kNue2020CVNRHCHighEdge : kNue2020CVNFHCHighEdge;
      const double topcut = (kCVNe_looseptp(sr) >= hibin) ? 50 : 400;

      return (fabs(sr->slc.closestslicetime) >= 100 ||
              sr->slc.closestsliceminfromtop >= topcut ||
              sr->slc.closestslicemindist >= 500);
    }); 
  //************************************************************
  
  const Cut kNue2020PID([](const caf::SRProxy* sr) {
      if(kIsRHC(sr)) return kNue2020PIDRHC(sr);
      else return kNue2020PIDFHC(sr);
  });
  
  const Cut kNue2020CosRej([](const caf::SRProxy* sr) {
      if(kIsRHC(sr)) return kNue2020CosRejRHC(sr);
      else return kNue2020CosRejFHC(sr);
  });

  bool kNue2020CVN_VsCosPIDFunc(const caf::SRProxy* sr)
  {
    if(kIsRHC(sr)) return kNue2020CVN_VsCosPIDRHC(sr);

    else return kNue2020CVN_VsCosPIDFHC(sr);
  }
  //************************************************************

  bool kNue2020FDPeripheralFunc(const caf::SRProxy* sr)
  {
    return kNue2020PeripheralBasicEventCut(sr) && !kNue2020FD(sr) && kNue2020CVN_VsCosPID(sr) && kNue2020FDNearestSlice(sr);
  }
  
  const Cut kNue2020CVNCutLP([](const caf::SRProxy* sr) {
      if(kIsRHC(sr)) return kNue2020RHCCVNCutLP(sr);
      else return kNue2020FHCCVNCutLP(sr);
  });
  
  const Cut kNue2020CVNVsCosPIDLP([](const caf::SRProxy* sr){

        if(kNue2020CVN_VsCosPID(sr)) return false;

        if(kIsRHC(sr)) return kNue2020CVNVsCosPIDRHCLP(sr);

        else return kNue2020CVNVsCosPIDFHCLP(sr);

  });

  // MRBrem case:
  bool kNue2020FDPeripheralFunc_MRBrem(const caf::SRProxy* sr)
  {
    return kNue2020PeripheralBasicEventCut_MRBrem(sr) && !kNue2020FD_MRBrem(sr) && kNue2020CVN_VsCosPID(sr) && kNue2020FDNearestSlice(sr);
  }
  
  //************************************************************
  // copy pasted
  // --------------------------------------------------------------------------
  const Cut kNue2020NDFiducial([](const caf::SRProxy* sr){
      assert(sr->vtx.elastic.IsValid && "Must apply DQ cuts");
      if (sr->vtx.elastic.vtx.X() < -100.0) return false;
      if (sr->vtx.elastic.vtx.X() >  160.0) return false;
      if (sr->vtx.elastic.vtx.Y() < -160.0) return false;
      if (sr->vtx.elastic.vtx.Y() >  100.0) return false;
      if (sr->vtx.elastic.vtx.Z() <  150.0) return false;
      if (sr->vtx.elastic.vtx.Z() >  900.0) return false;
      return true;
    });

  //************************************************************
  const Cut kNue2020NDContain([](const caf::SRProxy* sr){
      for (unsigned int ix =0; ix<sr->vtx.elastic.fuzzyk.nshwlid; ++ix){
        const caf::SRVector3DProxy& start = sr->vtx.elastic.fuzzyk.png[ix].shwlid.start;
        const caf::SRVector3DProxy& stop  = sr->vtx.elastic.fuzzyk.png[ix].shwlid.stop;
        if (std::min(start.X(),stop.X()) < -150.0)  return false;
        if (std::max(start.X(),stop.X()) >  170.0)  return false;
        if (std::min(start.Y(),stop.Y()) < -170.0)  return false;
        if (std::max(start.Y(),stop.Y()) >  150.0)  return false;
        if (std::min(start.Z(),stop.Z()) <  100.0)  return false;
        if (std::max(start.Z(),stop.Z()) >  1225.0) return false;
      }

      // This was a separate cut in 2017...
      if (sr->sel.contain.nplanestofront < 10) return false;

      return true;
    });

  //************************************************************
  const Var kNue2020SelectionBin([](const caf::SRProxy *sr){
      bool isPeri = kNue2020FDPeripheral(sr);
      if (isPeri)
        return float(2.5);

      const double lowedge = kIsRHC(sr) ? kNue2020CVNRHCLowEdge : kNue2020CVNFHCLowEdge;
      const double highedge = kIsRHC(sr) ? kNue2020CVNRHCHighEdge : kNue2020CVNFHCHighEdge;
      if (sr->sel.cvnloosepreselptp.nueid >= lowedge && sr->sel.cvnloosepreselptp.nueid < highedge)
        return float(0.5);
      else if (sr->sel.cvnloosepreselptp.nueid >= highedge)
        return float(1.5);
      else return float(-5.0);

      return float(-5.0);
    });
  

  const Var kNue2020AnaBin([](const caf::SRProxy *sr){
      int selBin = kNue2020SelectionBin(sr);
      float nuE  = kNueEnergy2020(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 kNue2020Binning = Binning::Simple(27,0,27);
  /// Use this Axis for Ana2020, official Axis
  const HistAxis kNue2020Axis("NuE Energy / Analysis Bin",
                               kNue2020Binning,kNue2020AnaBin);

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

  const Binning kNue2020BinningMergedPeripheral = Binning::Simple(23,0,23);
  const HistAxis kNue2020AxisMergedPeripheral("NuE Energy / Analysis Bin",
                                              kNue2020BinningMergedPeripheral,
                                              kNue2020AnaBinMergedPeripheral);
}