TruthCuts.cxx

Go to the documentation of this file.

#include "CAFAna/Cuts/TruthCuts.h"

#include "StandardRecord/Proxy/SRProxy.h"

#include <cassert>

namespace ana
{
  const Cut kIsNC([](const caf::SRProxy* sr)
                  {
                    if(sr->mc.nnu == 0) return false;
                    assert(sr->mc.nnu == 1);
                    return !sr->mc.nu[0].iscc;
                  });

  const Cut kIsNue([](const caf::SRProxy* sr){
                     return (sr->mc.nnu == 1 && abs(sr->mc.nu[0].pdg) ==12);});

  const Cut kIsNumu([](const caf::SRProxy* sr){
                     return (sr->mc.nnu == 1 && abs(sr->mc.nu[0].pdg) ==14);});

  const NuTruthCut kIsTau_NT([](const caf::SRNeutrinoProxy* truth){
                                return (abs(truth->pdg) == 16);});

  const Cut kIsTau = CutFromNuTruthCut(kIsTau_NT);

  const NuTruthCut kIsNC_NT([](const caf::SRNeutrinoProxy* truth)
                               {
                                 return !truth->iscc;
                               });

  bool CCFlavSel::operator()(const caf::SRProxy* sr) const
  {
    if(sr->mc.nnu == 0) return false;
    assert(sr->mc.nnu == 1);
    return (sr->mc.nu[0].iscc &&
            abs(sr->mc.nu[0].pdg) == fPdg &&
            abs(sr->mc.nu[0].pdgorig) == fPdgOrig);
  }

  const NuTruthCut kIsNumuCC_NT([](const caf::SRNeutrinoProxy* truth)
                                {
                                  return (
                                          truth->iscc &&
                                          abs(truth->pdg) == 14 &&
                                          abs(truth->pdgorig) == 14
                                          );
                                });

  const NuTruthCut kIsBeamNue_NT([](const caf::SRNeutrinoProxy* truth)
                                 {
                                   return (
                                           truth->iscc &&
                                           abs(truth->pdg) == 12 &&
                                           abs(truth->pdgorig) == 12
                                           );
                                 });

  const NuTruthCut kIsSig_NT([](const caf::SRNeutrinoProxy* truth)
                             {
                               return (
                                       truth->iscc &&
                                       abs(truth->pdg) == 12 &&
                                       abs(truth->pdgorig) == 14
                                       );
                             });

  const Cut kIsAntiNu([](const caf::SRProxy* sr)
                      {
                        if(sr->mc.nnu == 0) return false;
                        assert(sr->mc.nnu == 1);
                        return sr->mc.nu[0].pdg < 0;
                      });

  const Cut kIsNu([](const caf::SRProxy* sr)
                      {
                        if(sr->mc.nnu == 0) return false;
                        assert(sr->mc.nnu == 1);
                        return sr->mc.nu[0].pdg > 0;
                      });

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

  const NuTruthCut kIsAntiNu_NT([](const caf::SRNeutrinoProxy* truth)
                                   {
                                     return truth->pdg < 0;
                                   });

  const Cut kHasNeutrino(
    [](const caf::SRProxy* sr)
      { return (sr->mc.nnu != 0); }
  );

  const NuTruthCut kIsQE_NT([](const caf::SRNeutrinoProxy* truth)
                            {
                              return (truth->mode == caf::kQE);
                            });

  const Cut kIsQE = CutFromNuTruthCut(kIsQE_NT);

  const NuTruthCut kIsRes_NT([](const caf::SRNeutrinoProxy* truth)
                             {
                               return (truth->mode == caf::kRes);
                             });

  const Cut kIsRes = CutFromNuTruthCut(kIsRes_NT);

  const NuTruthCut kIsDIS_NT([](const caf::SRNeutrinoProxy* truth)
                             {
                               return (truth->mode == caf::kDIS);
                             });

  const Cut kIsDIS = CutFromNuTruthCut(kIsDIS_NT);

  //// Select neutrinos by their parents type
  const Cut kIsNumuFromKaon([](const caf::SRProxy* sr){
      return (sr->mc.nnu == 1 &&
              sr->mc.nu[0].iscc ==1 &&
              (abs(sr->mc.nu[0].beam.ptype) == 321 || sr->mc.nu[0].beam.ptype == 310 || sr->mc.nu[0].beam.ptype == 311 || sr->mc.nu[0].beam.ptype == 130) &&
              abs(sr->mc.nu[0].pdg) == 14);
    });

  const NuTruthCut kIsCoh_NT([](const caf::SRNeutrinoProxy* truth)
                                {
                                  return (truth->mode == caf::kCoh);
                                });

  const Cut kIsCoh = CutFromNuTruthCut(kIsCoh_NT);

  const Cut kIsKaon([](const caf::SRProxy* sr){
      return (abs(sr->mc.nu[0].beam.ptype) == 321 || sr->mc.nu[0].beam.ptype == 310 || sr->mc.nu[0].beam.ptype == 311 || sr->mc.nu[0].beam.ptype == 130);
    });

  const Cut kIsNumuFromPion([](const caf::SRProxy* sr){
      return (sr->mc.nnu == 1 &&
              sr->mc.nu[0].iscc ==1 &&
              (abs(sr->mc.nu[0].beam.ptype) == 211 || sr->mc.nu[0].beam.ptype == 111) &&
              abs(sr->mc.nu[0].pdg) == 14);
    });

  const Cut kIsPion([](const caf::SRProxy* sr){
      return (abs(sr->mc.nu[0].beam.ptype) == 211 || sr->mc.nu[0].beam.ptype == 111);
    });

  const Cut kIsNumuFromMuon([](const caf::SRProxy* sr){
      return (sr->mc.nnu == 1 &&
              sr->mc.nu[0].iscc ==1 &&
              abs(sr->mc.nu[0].beam.ptype) == 13 &&
              abs(sr->mc.nu[0].pdg) == 14);
    });

  const Cut kIsMuon([](const caf::SRProxy* sr){
      return (abs(sr->mc.nu[0].beam.ptype) == 13);
    });

  const Cut kIsNueFromKaon([](const caf::SRProxy* sr){
      return (sr->mc.nnu == 1 &&
              sr->mc.nu[0].iscc ==1 &&
              (abs(sr->mc.nu[0].beam.ptype) == 321 || sr->mc.nu[0].beam.ptype == 310 || sr->mc.nu[0].beam.ptype == 311 || sr->mc.nu[0].beam.ptype == 130) &&
              abs(sr->mc.nu[0].pdg) == 12);
    });

  const Cut kIsNueFromPion([](const caf::SRProxy* sr){
      return (sr->mc.nnu == 1 &&
              sr->mc.nu[0].iscc ==1 &&
              (abs(sr->mc.nu[0].beam.ptype) == 211 || sr->mc.nu[0].beam.ptype == 111) &&
              abs(sr->mc.nu[0].pdg) == 12);
    });

  const Cut kIsNueFromMuon([](const caf::SRProxy* sr){
      return (sr->mc.nnu == 1 &&
              sr->mc.nu[0].iscc ==1 &&
              abs(sr->mc.nu[0].beam.ptype) == 13 &&
              abs(sr->mc.nu[0].pdg) == 12);
    });

  const NuTruthCut kIsDytmanMEC_NT([](const caf::SRNeutrinoProxy* truth)
                                   {
                                     return (truth->mode == caf::kMEC);
                                   });

  const Cut kIsDytmanMEC = CutFromNuTruthCut(kIsDytmanMEC_NT);

  const Cut kIsVtxCont([](const caf::SRProxy* sr)
                       {
                         return(sr->mc.nnu==1 && sr->mc.nu[0].isvtxcont);
                       });

  const NuTruthCut kIsVtxCont_NT([](const caf::SRNeutrinoProxy* truth)
                          {
                            return(truth->isvtxcont);
                          });
}