NueCosRej.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file    NueCosRej.h
// \brief   Object collecting Cosmic Rejection variables for Nue analysis
// \version
// \author  Kanika Sachdev ksachdev@physics.umn.edu
////////////////////////////////////////////////////////////////////////
#ifndef NueCosRej_h
#define NueCosRej_h

namespace cosrej
{
  class NueCosRej {
  public:

    NueCosRej();
    ~NueCosRej();

    /// \brief Number of hits in slice per number of planes in leading prong.
    /// This is a handle on rejecting FEB flashes. We don't use number
    /// of planes in slice because there might be too many if a far off
    /// noise hit is sliced with physics
    double HitsPerPlane     () const { return fHitsPerPlane;}

    /// \brief Transverse component of the energy-weighted average
    /// of prong directions
    double ProngTransMom         () const { return fProngTransMom;}


    /// \brief Transverse component of the event momentum. Particle masses
    /// in the momentum calculation are inferred from log-likelihoods
    /// \ref ShowerLID
    double ParticleShowerTransMom() const { return fParticleShowerTransMom;}

    /// \brief Transverse component of the event momentum. Particle masses
    /// in the momentum calculation are assumed to be 0
    double PhotonShowerTransMom  () const { return fPhotonShowerTransMom;}

    /// \brief The cosine between the reconstructed momentum and the x-axis.
    /// Particle masses in the momentum calculation are assumed to be 0
    double PhotonShowerMomX      () const { return fPhotonShowerMomX;}

    /// \brief The cosine between the reconstructed momentum and the y-axis.
    /// Particle masses in the momentum calculation are assumed to be 0
    double PhotonShowerMomY      () const { return fPhotonShowerMomY;}

    /// \brief Perpendicular distance of start point of the leading
    /// prong to the top edge of the detector
    double StartDistToTop        () const { return fStartDistToTop;}

    /// \brief Perpendicular distance of start point of the leading
    /// prong to the bottom edge of the detector
    double StartDistToBottom     () const { return fStartDistToBottom;}

    /// \brief Perpendicular distance of start point of the leading
    /// prong to the front edge of the detector
    double StartDistToFront      () const { return fStartDistToFront;}

    /// \brief Perpendicular distance of start point of the leading
    /// prong to the back edge of the detector
    double StartDistToBack       () const { return fStartDistToBack;}

    /// \brief Perpendicular distance of start point of the leading
    /// prong to the west edge of the detector (west is positive x)
    double StartDistToWest       () const { return fStartDistToWest;}

    /// \brief Perpendicular distance of start point of the leading
    /// prong to the east edge of the detector (east is negative x)
    double StartDistToEast       () const { return fStartDistToEast;}

    /// \brief Perpendicular distance of stop point of the leading
    /// prong to the top edge of the detector
    double StopDistToTop         () const { return fStopDistToTop;}

    /// \brief Perpendicular distance of stop point of the leading
    /// prong to the bottom edge of the detector
    double StopDistToBottom      () const { return fStopDistToBottom;}

    /// \brief Perpendicular distance of stop point of the leading
    /// prong to the front edge of the detector
    double StopDistToFront       () const { return fStopDistToFront;}

    /// \brief Perpendicular distance of stop point of the leading
    /// prong to the back edge of the detector
    double StopDistToBack        () const { return fStopDistToBack;}

    /// \brief Perpendicular distance of stop point of the leading
    /// prong to the west edge of the detector (west is positive x)
    double StopDistToWest        () const { return fStopDistToWest;}

    /// \brief Perpendicular distance of stop point of the leading
    /// prong to the east edge of the detector (east is negative x)
    double StopDistToEast        () const { return fStopDistToEast;}

        /// \brief Minimum perpendicular distance of all prongs start points
    /// to the top edge of the detector
    double StartMinDistToTop        () const { return fStartMinDistToTop;}

    /// \brief Minimum perpendicular distance of all prongs start points
    /// to the bottom edge of the detector
    double StartMinDistToBottom     () const { return fStartMinDistToBottom;}

    /// \brief Minimum perpendicular distance of all prongs start points
    /// to the front edge of the detector
    double StartMinDistToFront      () const { return fStartMinDistToFront;}

    /// \brief Minimum perpendicular distance of all prongs start points
    /// to the back edge of the detector
    double StartMinDistToBack       () const { return fStartMinDistToBack;}

    /// \brief Minimum perpendicular distance of all prongs start points
    /// to the west edge of the detector (west is positive x)
    double StartMinDistToWest       () const { return fStartMinDistToWest;}

    /// \brief Minimum perpendicular distance of all prongs start points
    /// to the east edge of the detector (east is negative x)
    double StartMinDistToEast       () const { return fStartMinDistToEast;}

    /// \brief Minimum perpendicular distance of all prongs stop points
    /// to the top edge of the detector
    double StopMinDistToTop         () const { return fStopMinDistToTop;}

    /// \brief Minimum perpendicular distance of all prongs stop points
    /// to the bottom edge of the detector
    double StopMinDistToBottom      () const { return fStopMinDistToBottom;}

    /// \brief Minimum perpendicular distance of all prongs stop points
    /// to the front edge of the detector
    double StopMinDistToFront       () const { return fStopMinDistToFront;}

    /// \brief Minimum perpendicular distance of all prongs stop points
    /// to the back edge of the detector
    double StopMinDistToBack        () const { return fStopMinDistToBack;}

    /// \brief Minimum perpendicular distance of all prongs stop points
    /// to the west edge of the detector (west is positive x)
    double StopMinDistToWest        () const { return fStopMinDistToWest;}

    /// \brief Minimum perpendicular distance of all prongs stop points
    /// to the east edge of the detector (east is negative x)
    double StopMinDistToEast        () const { return fStopMinDistToEast;}

    /// \brief A BDT trained based on simple containment variables
    /// Used in the peripheral sample of the 2017 analysis
    /// See DocDB 17179 for more
    double CosPIDContain            () const { return fCosPIDContain; }

    /// \brief A BDT trained based on simple containment variables.  Includes
    /// pX/p and pY/p separately instead of pT/p to take advante of cosmic
    /// asymmetry in these vars. (DocDB 21956)
    double CosPIDContainXY         () const { return fCosPIDContainXY; }

    /// \brief A BDT trained based on simple containment variables and the
    /// nue output of CVN.  Includes pX/p and pY/p separately instead of
    /// pT/p to take advantage of cosmic asymmetry in these vars. (DocDB 21956)
    double CosPIDLight              () const { return fCosPIDLight; }

    double PeriBDT              () const { return fPeriBDT; }
    double CoreBDT              () const { return fCoreBDT; }

 

    /// \brief Cosine of Angle between the leading and the next leading
    /// prong
    double CosAngleToNextProng  () const { return fCosAngleToNextProng;}

    /// \brief Perpendicular distance of closes approach between the
    /// leading prong and the event vertex
    double ProngDistToVtx       () const { return fProngDistToVtx;}

    /// \brief The maximum X between the start and stop points of the
    /// leading prong in the slice
    double ProngMaxX            () const { return fProngMaxX;}

    /// \brief The maximum Y between the start and stop points of the
    /// leading prong in the slice
    double ProngMaxY            () const { return fProngMaxY;}

    /// \brief The maximum Z between the start and stop points of the
    /// leading prong in the slice
    double ProngMaxZ            () const { return fProngMaxZ;}
    /// \brief The minimium X between the start and stop points of the
    /// leading prong in the slice
    double ProngMinX            () const { return fProngMinX;}

    /// \brief The minimium Y between the start and stop points of the
    /// leading prong in the slice
    double ProngMinY            () const { return fProngMinY;}

    /// \brief The minimium Z between the start and stop points of the
    /// leading prong in the slice
    double ProngMinZ            () const { return fProngMinZ;}

    /// \brief Asymmetry in the zero-hit planes at the start and end
    /// of the leading shower
    double SparsenessAsymm      () const { return fSparsenessAsymm;}

    /// \brief Asymmetry in the hitsperplane at the start and end of
    /// the leading shower
    double HitsPerPlaneAsymm    () const { return fHitsPerPlaneAsymm;}

   /// \brief Asymmetry in the zero-hit planes at the start and end
   /// of the slice
    double SparsenessAsymmSlice       () const { return fSparsenessAsymmSlice;}

    /// \brief Asymmetry in the hitsperplane at the start and end of
    /// the slice
    double HitsPerPlaneAsymmSlice     () const { return fHitsPerPlaneAsymmSlice;}

    /// \brief The index of the slice that is most likely to be
    /// the parent muon according to distance of closest approach, in case
    /// this slice is a muon induced brem or a muon decay in flight.
    int    MuSliceIdxByDist           () const { return fMuSliceIdxByDist;}

    /// \brief Minimum time difference between this slice and
    /// the possible muon parent (selected by closest approach)
    double MuTimeDiffByDist           () const { return fMuTimeDiffByDist;}

    /// \brief Minimum angle difference between this slice and
    /// the possible muon parent (selected by closest approach)
    double MuAngleDiffByDist          () const { return fMuAngleDiffByDist;}

    /// \brief Distance of closest approach between this slice and
    /// the possible muon parent (selected by closest approach)
    double MuClosestApproachByDist    () const { return fMuClosestApproachByDist;}

    /// \brief The index of the slice that is most likely to be
    /// the parent muon according to difference in time, in case this
    /// slice is a muon induced brem or a muon decay in flight.
    int    MuSliceIdxByTime           () const { return fMuSliceIdxByTime;}

    /// \brief Minimum time difference between this slice and
    /// the possible muon parent (selected by difference in time)
    double MuTimeDiffByTime           () const { return fMuTimeDiffByTime;}

    /// \brief Minimum angle difference between this slice and
    /// the possible muon parent (selected by difference in time)
    double MuAngleDiffByTime          () const { return fMuAngleDiffByTime;}

    /// \brief Distance of closest approach between this slice and
    /// the possible muon parent (selected by difference in time)
    double MuClosestApproachByTime    () const { return fMuClosestApproachByTime;}

    /// \name Setters
    //@{
    void SetHitsPerPlane          (double input)
    {  fHitsPerPlane           = input;}

    void SetProngTransMom         (double input)
    {  fProngTransMom          = input;}

    void SetParticleShowerTransMom(double input)
    {  fParticleShowerTransMom = input;}

    void SetPhotonShowerTransMom  (double input)
    {  fPhotonShowerTransMom   = input;}

    void SetPhotonShowerMomX      (double input)
    {  fPhotonShowerMomX       = input;}

    void SetPhotonShowerMomY      (double input)
    {  fPhotonShowerMomY       = input;}

    void SetStartDistToTop        (double input)
    {  fStartDistToTop         = input;}

    void SetStartDistToBottom     (double input)
    {  fStartDistToBottom      = input;}

    void SetStartDistToFront      (double input)
    {  fStartDistToFront       = input;}

    void SetStartDistToBack       (double input)
    {  fStartDistToBack        = input;}

    void SetStartDistToWest       (double input)
    {  fStartDistToWest        = input;}

    void SetStartDistToEast       (double input)
    {  fStartDistToEast        = input;}

    void SetStopDistToTop         (double input)
    {  fStopDistToTop          = input;}

    void SetStopDistToBottom      (double input)
    {  fStopDistToBottom       = input;}

    void SetStopDistToFront       (double input)
    {  fStopDistToFront        = input;}

    void SetStopDistToBack        (double input)
    {  fStopDistToBack         = input;}

    void SetStopDistToWest        (double input)
    {  fStopDistToWest         = input;}

    void SetStopDistToEast        (double input)
    {  fStopDistToEast         = input;}


    void SetStartMinDistToTop        (double input)
    {  fStartMinDistToTop         = input;}

    void SetStartMinDistToBottom     (double input)
    {  fStartMinDistToBottom      = input;}

    void SetStartMinDistToFront      (double input)
    {  fStartMinDistToFront       = input;}

    void SetStartMinDistToBack       (double input)
    {  fStartMinDistToBack        = input;}

    void SetStartMinDistToWest       (double input)
    {  fStartMinDistToWest        = input;}

    void SetStartMinDistToEast       (double input)
    {  fStartMinDistToEast        = input;}

    void SetStopMinDistToTop         (double input)
    {  fStopMinDistToTop          = input;}

    void SetStopMinDistToBottom      (double input)
    {  fStopMinDistToBottom       = input;}

    void SetStopMinDistToFront       (double input)
    {  fStopMinDistToFront        = input;}

    void SetStopMinDistToBack        (double input)
    {  fStopMinDistToBack         = input;}

    void SetStopMinDistToWest        (double input)
    {  fStopMinDistToWest         = input;}

    void SetStopMinDistToEast        (double input)
    {  fStopMinDistToEast         = input;}

    void SetCosPIDContain            (double input)
    {  fCosPIDContain             = input;}

    void SetCosPIDContainXY          (double input)
    {  fCosPIDContainXY           = input;}

    void SetCosPIDLight              (double input)
    {  fCosPIDLight               = input;}

    void SetPeriBDT            (double input)
    {  fPeriBDT             = input;}
  
   void SetCoreBDT            (double input)
    {  fCoreBDT             = input;}
  

    void SetCosAngleToNextProng  (double input)
    {  fCosAngleToNextProng   = input;}

    void SetProngDistToVtx       (double input)
    {  fProngDistToVtx        = input;}

    void SetProngMaxX            (double input)
    {  fProngMaxX             = input;}

    void SetProngMaxY            (double input)
    {  fProngMaxY             = input;}

    void SetProngMaxZ            (double input)
    {  fProngMaxZ             = input;}

    void SetProngMinX            (double input)
    {  fProngMinX             = input;}

    void SetProngMinY            (double input)
    {  fProngMinY             = input;}

    void SetProngMinZ            (double input)
    {  fProngMinZ             = input;}

    void SetSparsenessAsymm      (double input)
    { fSparsenessAsymm        = input;}

    void SetHitsPerPlaneAsymm    (double input)
    { fHitsPerPlaneAsymm      = input;}

    void SetSparsenessAsymmSlice       (double input)
    { fSparsenessAsymmSlice         =  input;}

    void SetHitsPerPlaneAsymmSlice     (double input)
    { fHitsPerPlaneAsymmSlice       =  input;}

    void SetMuSliceIdxByDist           (int input)
    { fMuSliceIdxByDist             =  input;}

    void SetMuTimeDiffByDist           (double input)
    { fMuTimeDiffByDist             =  input; }

    void SetMuAngleDiffByDist          (double input)
    { fMuAngleDiffByDist            =  input; }

    void SetMuClosestApproachByDist    (double input)
    { fMuClosestApproachByDist      =  input; }

    void SetMuSliceIdxByTime           (int input)
    { fMuSliceIdxByTime             =  input;}

    void SetMuTimeDiffByTime           (double input)
    { fMuTimeDiffByTime             =  input; }

    void SetMuAngleDiffByTime          (double input)
    { fMuAngleDiffByTime            =  input; }

    void SetMuClosestApproachByTime    (double input)
    { fMuClosestApproachByTime      =  input; }


    //@}

  private:
    double fHitsPerPlane;
    double fProngTransMom;
    double fParticleShowerTransMom;
    double fPhotonShowerTransMom;
    double fPhotonShowerMomX;
    double fPhotonShowerMomY;
    double fStartDistToTop;
    double fStartDistToBottom;
    double fStartDistToFront;
    double fStartDistToBack;
    double fStartDistToWest;
    double fStartDistToEast;
    double fStopDistToTop;
    double fStopDistToBottom;
    double fStopDistToFront;
    double fStopDistToBack;
    double fStopDistToWest;
    double fStopDistToEast;
    double fStartMinDistToTop;
    double fStartMinDistToBottom;
    double fStartMinDistToFront;
    double fStartMinDistToBack;
    double fStartMinDistToWest;
    double fStartMinDistToEast;
    double fStopMinDistToTop;
    double fStopMinDistToBottom;
    double fStopMinDistToFront;
    double fStopMinDistToBack;
    double fStopMinDistToWest;
    double fStopMinDistToEast;
    double fCosPIDContain;
    double fCosPIDContainXY;
    double fCosPIDLight;
    double fPeriBDT;
    double fCoreBDT;
    double fProngDistToVtx;
    double fCosAngleToNextProng;
    double fProngMaxX;
    double fProngMaxY;
    double fProngMaxZ;
    double fProngMinX;
    double fProngMinY;
    double fProngMinZ;
    double fSparsenessAsymm;
    double fHitsPerPlaneAsymm;
    double fSparsenessAsymmSlice;
    double fHitsPerPlaneAsymmSlice;

    int    fMuSliceIdxByDist;
    double fMuAngleDiffByDist;
    double fMuTimeDiffByDist;
    double fMuClosestApproachByDist;

    int fMuSliceIdxByTime;
    double fMuAngleDiffByTime;
    double fMuTimeDiffByTime;
    double fMuClosestApproachByTime;

  };

}
#endif