OverlayCuts.cxx

Go to the documentation of this file.

#include "3FlavorAna/Cuts/OverlayCuts.h"
#include "StandardRecord/Proxy/SRProxy.h"

namespace ana
{
  Cut OverlayCutFromNuTruthCut(const NuTruthCut stc)
  {
    return Cut([stc](const caf::SRProxy* sr)
               {
                 if(sr->mc.nallnus == 0) return false;
                 for(int j=0; j<sr->mc.nallnus; j++)
                   if(  ( sr->mc.allnus[j].mode > 9999   // overlaid mc or 
                          || !sr->spill.ismc ))           // overlaid data
                     return stc(&sr->mc.allnus[j]);
                 return false;
               });
  }

  const NuTruthCut kNoCut_NT([](const caf::SRNeutrinoProxy* nu)
                                  {
                                    return true;
                                  });

  const NuTruthCut kOverlaidMC_Nu([](const caf::SRNeutrinoProxy* nu)
                                  {
                                    return (nu->mode > 9999);
                                  });
  const NuTruthCut kOverlaidData_Nu([](const caf::SRNeutrinoProxy* nu)
                                    {
                                      return true;
                                    });

  const TVector3 ovtxmin(-180, -180, 25);
  const TVector3 ovtxmax( 180,  180, 1150);
  const NuTruthCut kTrueOFiducial_Nu([](const caf::SRNeutrinoProxy* nu)
                                    {
                                      return (nu->vtx.X() <  ovtxmax.X() &&
                                              nu->vtx.X() >  ovtxmin.X() &&
                                              nu->vtx.Y() >  ovtxmin.Y() &&
                                              nu->vtx.Y() <  ovtxmax.Y() &&
                                              nu->vtx.Z() >  ovtxmin.Z() &&
                                              nu->vtx.Z() <  ovtxmax.Z() );
                                    });
  const Cut kTrueOFiducial = OverlayCutFromNuTruthCut(kTrueOFiducial_Nu);

  const TVector3 ovtxminLoose(-220, -220, 0);
  const TVector3 ovtxmaxLoose( 220,  220, 1150);
  const NuTruthCut kTrueOFiducialLoose_Nu([](const caf::SRNeutrinoProxy* nu)
                                    {
                                      return (nu->vtx.X() <  ovtxmaxLoose.X() &&
                                              nu->vtx.X() >  ovtxminLoose.X() &&
                                              nu->vtx.Y() >  ovtxminLoose.Y() &&
                                              nu->vtx.Y() <  ovtxmaxLoose.Y() &&
                                              nu->vtx.Z() >  ovtxminLoose.Z() &&
                                              nu->vtx.Z() <  ovtxmaxLoose.Z() );
                                    });
  const Cut kTrueOFiducialLoose = OverlayCutFromNuTruthCut(kTrueOFiducial_Nu);

  const NuTruthCut kTrueE250MeV_Nu([](const caf::SRNeutrinoProxy* nu)
                          {
                            return nu->E > 0.25;
                          });
  const Cut kTrueE250MeV = OverlayCutFromNuTruthCut(kTrueE250MeV_Nu);

  const Cut kTrueNumuCC = OverlayCutFromNuTruthCut(kTrueNumuCC_Nu);
  const NuTruthCut kTrueNumuCC_Nu([](const caf::SRNeutrinoProxy* truth)
      {
      return (
          truth->iscc &&
          abs(truth->pdg) == 14
          );
      });

  const Cut kTrueNueCC = OverlayCutFromNuTruthCut(kTrueNueCC_Nu);
  const NuTruthCut kTrueNueCC_Nu([](const caf::SRNeutrinoProxy* truth)
      {
      return (
          truth->iscc &&
          abs(truth->pdg) == 12
          );
      });

  const NuTruthCut kAnaTrueECut_Nu_Numu([](const caf::SRNeutrinoProxy* nu)
                          {
                            //return (nu->E >= 0. && nu->E < 5.);
                            return (nu->E >= 0. && nu->E < 7.);
                          });
  const Cut kAnaTrueECut_Numu = OverlayCutFromNuTruthCut(kAnaTrueECut_Nu_Numu);

  const NuTruthCut kAnaTrueECut_Nu_Nue([](const caf::SRNeutrinoProxy* nu)
                          {
                            //return (nu->E >= 0. && nu->E < 4.5);
                            return (nu->E >= 0. && nu->E < 6.0);
                          });
  const Cut kAnaTrueECut_Nue = OverlayCutFromNuTruthCut(kAnaTrueECut_Nu_Nue);

  const Cut kOverlaidEff51([](const caf::SRProxy* sr)
      {
      if(sr->mc.nallnus == 0) return false;
      for(int j=0; j<sr->mc.nallnus; j++)
      if(  ( sr->mc.allnus[j].mode > 9999   // overlaid mc or 
            || !sr->spill.ismc )           // overlaid data
          && sr->mc.allnus[j].eff > 0.51 )  // and slice eff cut
      return true;
      return false;
      });

  const Cut kOverlaidNoEffCut([](const caf::SRProxy* sr)
      {
      if(sr->mc.nallnus == 0) return false;
      for(int j=0; j<sr->mc.nallnus; j++)
      if(  ( sr->mc.allnus[j].mode > 9999
            || !sr->spill.ismc )) 
      return true;
      return false;
      });

  const Cut kNotOverlaidData([](const caf::SRProxy* sr)
      {
      if(sr->mc.nallnus == 0) return true;
      return false;
      });


  const SpillCut kNoCut_Sp([](const caf::SRSpillProxy* sp)
                                  {
                                    return true;
                                  });
}