NusCuts20.h

Go to the documentation of this file.

#pragma once

// Location for NuS 2020 analysis cuts
// The cut values in this file are outlined in the Nus20 Selection 
// technote, docdb 44374

#include "CAFAna/Core/Cut.h"
#include "CAFAna/Core/RunPeriods.h"
#include "CAFAna/Cuts/AnalysisMasks.h"
#include "CAFAna/Cuts/Cuts.h"
#include "CAFAna/Vars/Vars.h"
#include "3FlavorAna/Vars/NueVars.h"
#include "3FlavorAna/Vars/NueVarsExtra.h"
#include "3FlavorAna/Vars/NumuVarsExtra.h"
#include "NuXAna/Vars/NusVars.h"
#include "NuXAna/Vars/NusVarsTemp.h"
#include "3FlavorAna/Cuts/NueCuts2020.h"
#include "3FlavorAna/Cuts/NumuCuts2020.h"
#include "3FlavorAna/Cuts/MissingLeptonCuts.h"
#include "NuXAna/Cuts/NusCuts.h"

#include "CAFAna/Cuts/SpillCuts.h"

namespace ana
{

  // -------------------------------- //
  // GENERIC                          //
  // -------------------------------- //

  // Decaf cuts: CVN NC id > .1 for decaf files (both FD and ND)
  // Cut for prof5 CVN (using cvnlooseptp here)
  // define both FHC and RHC cuts in case we want a different cut for RHC in '21
  extern const Cut kNus20FHCDecafCut;
  extern const Cut kNus20RHCDecafCut;

  // quality cuts
  const Cut kNus20ElasticProngCut = (kIsElastic > 0);
  const Cut kNus20NFuzzyProngCut  = (kNFuzzyProng > 0);
  const Cut kNus20NContPlanesCut  = (kNContPlanes > 2);
  const Cut kNus20QualityCuts     = kNus20ElasticProngCut &&
                                    kNus20NFuzzyProngCut  &&
                                    kNus20NContPlanesCut;

  const Cut kNus20EnergyCut       = (kNus20Energy > 0.5 && kNus20Energy < 20);

  // -------------------------------- //
  // NEAR DETECTOR                    //
  // -------------------------------- //

  // define fiducial volume here so it's picked up for both reco and true vertices
  float xLowND  = -100;
  float xHighND =  100;
  float yLowND  = -100;
  float yHighND =  100;
  float zLowND  =  150;
  float zHighND =  1000;

  // pre selection cut
  // including kNShwLid > 0 otherwise vectors go out of range
  const Cut kNus20NDPreSelection = kNusNDFidLoose    &&
                                   kNus20FHCDecafCut &&
                                   !kNumu2020ND      &&
                                   !kNue2020ND       &&
                                   (kNShwLid > 0);

  // near detector containment cuts
  const Cut kNus20NDVtxXCut         = (kVtxX > xLowND  && kVtxX < xHighND);
  const Cut kNus20NDVtxYCut         = (kVtxY > yLowND  && kVtxY < yHighND );
  const Cut kNus20NDVtxZCut         = (kVtxZ > zLowND  && kVtxZ < zHighND);
  const Cut kNus20NDVtxPosCut       = kNus20NDVtxXCut && 
                                      kNus20NDVtxYCut &&
                                      kNus20NDVtxZCut;

  const Cut kNus20NDDistAllTopCut    = (kDistAllTop    > 20);
  const Cut kNus20NDDistAllBottomCut = (kDistAllBottom > 20);
  const Cut kNus20NDDistAllEastCut   = (kDistAllEast   > 20);
  const Cut kNus20NDDistAllWestCut   = (kDistAllWest   > 20);
  const Cut kNus20NDDistAllFrontCut  = (kDistAllFront  > 150);
  const Cut kNus20NDDistAllBackCut   = (kDistAllBack   > 50);
  const Cut kNus20NDMinSliceDistCut  = kNus20NDDistAllTopCut    &&
                                       kNus20NDDistAllBottomCut &&
                                       kNus20NDDistAllEastCut   &&
                                       kNus20NDDistAllWestCut   &&
                                       kNus20NDDistAllFrontCut  &&
                                       kNus20NDDistAllBackCut;

  const Cut kNus20NDFiducialCuts      = kNus20NDVtxPosCut &&
                                        kNus20NDMinSliceDistCut;

  // places quality and fiducial volume cuts
  const Cut kNus20NDQualityAndFiducialCut = kNus20QualityCuts &&
                                            kNus20NDFiducialCuts;

  // near detector selection cuts
  // only places cut on CVN value
  const Cut kNus20NDCVNCut    = (kCVNnc_looseptp > 0.98);
  
  const Cut kNus20NDSelectionCuts = kNus20NDCVNCut;
 
  // full near detector selection
  const Cut kNus20NDCuts      = kNus20NDPreSelection  &&
                                kNus20QualityCuts     &&
                                kNus20NDFiducialCuts  &&
                                kNus20NDSelectionCuts &&
                                kNus20EnergyCut;

  // this cut is to define out of the detector
  const Cut kNus20NDTrueVtxOutOfDetX = (kTrueVtxX < NDL/100. || kTrueVtxX > NDR/100.);
  const Cut kNus20NDTrueVtxOutOfDetY = (kTrueVtxY < NDB/100. || kTrueVtxY > NDT/100.);
  const Cut kNus20NDTrueVtxOutOfDetZ = (kTrueVtxZ < NDF/100. || kTrueVtxZ > NDE/100.);
  const Cut kNus20NDTrueVtxOutOfDet  = kNus20NDTrueVtxOutOfDetX ||
                                       kNus20NDTrueVtxOutOfDetY ||
                                       kNus20NDTrueVtxOutOfDetZ;

  // defines true vertices inside of the fiducial volume
  // for whatever reason, the true variables are stores as meters
  const Cut kNus20NDTrueContainedX = (kTrueVtxX  > xLowND/100 && kTrueVtxX < xHighND/100);
  const Cut kNus20NDTrueContainedY = (kTrueVtxY  > yLowND/100 && kTrueVtxY < yHighND/100);
  const Cut kNus20NDTrueContainedZ = (kTrueVtxZ  > zLowND/100 && kTrueVtxZ < zHighND/100);
  const Cut kNus20NDTrueContained  = kNus20NDTrueContainedX &&
                                     kNus20NDTrueContainedY &&
                                     kNus20NDTrueContainedZ;

  // -------------------------------- //
  // FAR DETECTOR                     //
  // -------------------------------- //

  // define fiducial volume here so it's picked up for both reco and true vertices
  float xLowFD  = -100;
  float xHighFD =  100;
  float yLowFD  = -100;
  float yHighFD =  100;
  float zLowFD  =  150;
  float zHighFD =  1000;

  // pre selection cut
  const Cut kNus20FDPreSelection = kNusFDFidLoose    &&
                                   kNus20FHCDecafCut &&
                                   !kNumu2020FD      &&
                                   !kNue2020FD       &&
                                   (kNShwLid > 0);

  // don't apply vertex cuts straight up, instead look at just signal 
  // containment, and put the vertex positions into the BDT

  const Cut kNus20FDDistAllTopCut    = (kDistAllTop    > 100);
  const Cut kNus20FDDistAllBottomCut = (kDistAllBottom > 100);
  const Cut kNus20FDDistAllEastCut   = (kDistAllEast   > 100);
  const Cut kNus20FDDistAllWestCut   = (kDistAllWest   > 100);
  const Cut kNus20FDDistAllFrontCut  = (kDistAllFront  > 160);
  const Cut kNus20FDDistAllBackCut   = (kDistAllBack   > 160);
  const Cut kNus20FDMinSliceDistCut  = kNus20FDDistAllTopCut    &&
                                       kNus20FDDistAllBottomCut &&
                                       kNus20FDDistAllEastCut   &&
                                       kNus20FDDistAllWestCut   &&
                                       kNus20FDDistAllFrontCut  &&
                                       kNus20FDDistAllBackCut;

        const Cut kNus20FDQualityContainment = kNus20FDPreSelection &&
                                                                                                                                                                 kNus20QualityCuts    &&
                                                                                                                                                                 kNus20FDMinSliceDistCut;

  // far detector selection cuts
  // only places cut on CVN value
  const Cut kNus20FDCVNCut    = (kCVNnc_looseptp > 0.1);
  
  const Cut kNus20FDSelectionCuts = kNus20FDCVNCut;

        // far detector cosmic rejection cuts
        const Cut kNus20FDCosRejCuts = (kNCCosRejBDTG20 > 0.85);

        // full far detector selection
  const Cut kNus20FDCuts      = kNus20FDPreSelection    &&
                                kNus20QualityCuts       &&
                                kNus20FDMinSliceDistCut &&
                                kNus20FDSelectionCuts   &&
                                                                                                                                kNus20FDCosRejCuts      &&
                                kNus20EnergyCut;
  const Cut kNus20FDCuts_ML   = kNus20FDCuts && kIsLeptonMissing;

  // this cut is to define out of the detector
  const Cut kNus20FDTrueVtxOutOfDetX = (kTrueVtxX < FDL/100. || kTrueVtxX > FDR/100.);
  const Cut kNus20FDTrueVtxOutOfDetY = (kTrueVtxY < FDB/100. || kTrueVtxY > FDT/100.);
  const Cut kNus20FDTrueVtxOutOfDetZ = (kTrueVtxZ < FDF/100. || kTrueVtxZ > FDE/100.);
  const Cut kNus20FDTrueVtxOutOfDet  = kNus20FDTrueVtxOutOfDetX ||
                                       kNus20FDTrueVtxOutOfDetY ||
                                       kNus20FDTrueVtxOutOfDetZ;


}