CosRejObj.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file    CosRejObj.h
// \brief   Object collecting Cosmic Rejection variables
// \version
// \author  Kirk Bays - bays@caltech.edu
////////////////////////////////////////////////////////////////////////
#ifndef CosRejObj_h
#define CosRejObj_h

namespace cosrej
{
  class CosRejObj {
  public:

    CosRejObj();
    ~CosRejObj();

    void               SetAngleKal(float angleb);         ///< cos of angle of best Kalman track wrt beam
    void               SetAngleCos(float anglel);         ///< cos of angle of Cosmic track wrt beam

    void               SetConCosPID       (float concospid);        ///< PID for contained cosmic rejection (The one to use - P5 train)
    void               SetOldCosPID       (float oldcospid);        ///< PID for contained cosmic rejection (Old Alg, Prod 3 training)
    void               SetUnconTunedCosPID(float uncontunedcospid); ///< Tuned PID for uncontained cosmic rejection (TMVA) - Jose's

    void               SetNTracks3D(int ntracks3d);       ///< number of 3D Kalman tracks
                                                          ///< added stuff for Cosmic Rejection
    void               SetKFitSpeed(float kfitspeed);     ///< inverse speed (ns/cm) of track fit by TimingFit module (negative indicates backwards track) for best ReMId Kalman Track
    void               SetCFitSpeed(float cfitspeed);     ///< inverse speed (ns/cm) of track fit by TimingFit module (negative indicates backwards track) for Cosmic Track
    void               SetKDirScore(float kdirscore);     ///< chisq diff between assuming forwards going and backwards going for best ReMId Kalman track
    void               SetCDirScore(float cdirscore);     ///< chisq diff between assuming forwards going and backwards going for Cosmic Track
    void               SetKScoreDiff(float kscorediff);   ///< chisq diff between best directed fit and free fit (may indicate if things are wonky) for best ReMId Kalman Track
    void               SetCScoreDiff(float cscorediff);   ///< chisq diff between best directed fit and free fit (may indicate if things are wonky) for Cosmic Track
    void               SetKalSlope(float kalslope);       ///< slope of timing fit; a positive slope indicates track is properly directed
    void               SetKalChisq(float kalchisq);       ///< chisq result associated with slope fit.  Mostly not useful
    void               SetKalChiDiff(float kalchidiff);   ///< chisq difference of assuming + or - c as slope.  A positive chisqdiff means the track is backwards.  If negative, ignore.
    void               SetCosSlope(float cosslope);       ///< same for Cosmic track
    void               SetCosChisq(float coschisq);       ///< same for Cosmic track
    void               SetCosChiDiff(float coschidiff);   ///< same for Cosmic track
    void               SetCosFwdDist(float cosfwddist);   ///< distance (dist,cm) of track from end to det wall projected forwards (Fwd), based on Cosmic Tracker (Cos)
    void               SetCosFwdAir (float cosfwdair);    ///< distance (dist,cm) through air traveled, when projected forwards to detector edge.  For ND only, muon catcher air gap. NYI
    void               SetCosFwdSteel(float cosfwdsteel); ///< distance (dist,cm) through muon catcher traveled, when projected forwards to detector edge.  For ND only.  TODO: make this steel only instead of muon catcher distance
    void               SetCosBakDist(float cosbakdist);   ///< cosmic track distance projected backwards from track start
    void               SetCosFwdCell(int   cosfwdcell);   ///< # cells in that line segment instead of distance of line segment
    void               SetCosFwdCellND(int  cosfwdcellnd);///< # cells in that line segment instead of distance of line segment, including MC, ND only
    void               SetCosBakCell(int   cosbakcell);   ///< note that fwd<->bak values are interchanged if track direction is backwards
    void               SetCosBakCellND(int  cosbakcellnd);///< note that fwd<->bak values are interchanged if track direction is backwards, including MC, ND only
    void               SetCosBakAir (float cosbakair);    ///< distance (dist,cm) through air traveled, when projected backwards to detector edge.  For ND only, muon catcher air gap. NYI - just use ytrans
    void               SetCosBakSteel(float cosbaksteel); ///< distance (dist,cm) through muon catcher traveled, when projected backwards to detector edge.  For ND only.  TODO: make this steel only instead of muon catcher distance
    void               SetKalFwdDist(float kalfwddist);   ///< distance (dist,cm) of best track from end to det wall projected forwards (Fwd), based on Kalman Tracker (Kal)
    void               SetKalBakDist(float kalbakdist);   ///< cosmic track distance projected backwards from track start
    void               SetKalFwdCell(int   kalfwdcell);   ///< # cells in that line segment instead of distance of line segment
    void               SetKalFwdCellND(int  kalfwdcellnd);///< # cells in that line segment instead of distance of line segment, including MC, ND only
    void               SetKalBakCell(int   kalbakcell);   ///< note that fwd<->bak values are interchanged if track direction is backwards
    void               SetKalBakCellND(int kalbakcellnd); ///< note that fwd<->bak values are interchanged if track direction is backwards, including MC, ND only
    void               SetKalFwdAir (float kalfwdair);    ///< distance (dist,cm) through air traveled, when projected forwards to detector edge.  For ND only, muon catcher air gap. NYI
    void               SetKalFwdSteel(float kalfwdsteel); ///< distance (dist,cm) through muon catcher traveled, when projected forwards to detector edge.  For ND only.  TODO: make this steel only instead of muon catcher distance
    void               SetKalBakAir (float kalbakair);    ///< distance (dist,cm) through air traveled, when projected forwards to detector edge.  For ND only, muon catcher air gap. NYI
    void               SetKalBakSteel(float kalbaksteel); ///< distance (dist,cm) through muon catcher traveled, when projected forwards to detector edge.  For ND only.  TODO: make this steel only instead of muon catcher distance
    void               SetCosYPosAtTrans(float cosyposattrans); ///< Y position at transition to muon catcher, for determining if track went through air gap (ND only)
    void               SetKalYPosAtTrans(float kalyposattrans); ///< Y position at transition to muon catcher, for determining if track went through air gap (ND only)
    void               SetMinDist   (float mindist);      ///< minimum projected distance, forwards or backwards, of ANY Kalman track with more than 15 hits
    void               SetMinCell   (int mincell);        ///< minimum projected number of cell, forwards or backwards, of ANY Kalman track with more than 15 hits
    void               SetNHadTracks(int   nhadtracks);   ///< number of 3D Kalman tracks with ReMId value of < 0.4 (not mu-like, or hadronic-like)
    void               SetERatio(float eratio);           ///< ratio of visible E in best track/ visible E in whole slice
    void               SetScatt(float scatt);             ///< basic scattering variable; sum of all angular deviations between best kal track trajectory points / track length
    void               SetStartAct(float startact);       ///< measure of activity near best Kalman track start position; start pos is a good measure of vertex
    void               SetCosThetaTrue(float cosqtrue);   ///< cosine of angle between true particle (bt most contributing) and reco track dir; use to tell if track is backwards; for best kalman track
    void               SetKalThetaTrue(float kalqtrue);   ///< cosine of angle between true particle (bt most contributing) and reco track dir; use to tell if track is backwards; for cosmic track
    void               SetPDGBest(int pdgbest);           ///< pdg code of true most contributing particle to reco track hits.  Calculate for best Kalman track, assume same for cosmic track
    void               SetVtxDist(float vtxdist);         ///< minimum distance of start position of best Kalman track to detector wall.   Negative indicates outside of detector
    void               SetEndDist(float enddist);         ///< minimum distance of end position of best Kalman track to detector wall.   Negative indicates outside of detector
    void               SetFScattMax(float fscattmax);     ///< maximum scattering angle (Fernanda's)
    void               SetFScattSum(float fscattsum);     ///< sum of scattering angles (Fernanda's)
    void               SetFScattExt(float fscattext);     ///< scattering variable (Fernanda's)
    void               SetFScattSig(float fscattsig);     ///< sigma of scattering angles (Fernanda's);
    void               SetCosHitRatio(float coshitratio); ///< ratio of hits in cosmic track to hits in slice
    
    void               SetTrackLenKal(float tracklenkal);        ///< Total length of kalman track
    void               SetTrackLenKal2nd(float tracklenkal2nd);  ///< Total length of 2nd highest ReMId kalman track
    void               SetTrackE2nd(float tracke2nd);            ///< Calorimetric energy of 2nd highest ReMId kalman track
    void               SetAngleKal2nd(float angle2nd);           ///< cos of angle of 2nd best Kalman track wrt beam
    void               SetAngleBtwKalTrks(float anglebtw);       ///< cos of angle of 2nd best Kalman track wrt beam
    void               SetTrkEPerNHit(float trkepernhit);        ///< Track energy per kalman track hit
    
    float              AngleKal() const;
    float              AngleCos() const;

    float              ConCosPID() const;
    float              OldCosPID() const;
    float              UnconTunedCosPID() const;

    int                NTracks3D() const ;
    float              KFitSpeed() const;
    float              CFitSpeed() const;
    float              KDirScore() const;
    float              CDirScore() const;
    float              KScoreDiff() const;
    float              CScoreDiff() const;
    float              KalSlope() const;
    float              KalChisq() const;
    float              CosSlope() const;
    float              CosChisq() const;
    float              CosFwdDist() const;
    float              CosFwdAir() const;
    float              CosFwdSteel() const;
    float              CosBakDist() const;
    int                CosFwdCell() const;
    int                CosFwdCellND() const;
    int                CosBakCell() const;
    int                CosBakCellND() const;
    float              CosBakAir() const;
    float              CosBakSteel() const;
    float              KalFwdDist() const;
    float              KalBakDist() const;
    int                KalFwdCell() const;
    int                KalFwdCellND() const;
    int                KalBakCell() const;
    int                KalBakCellND() const;
    float              KalFwdAir() const;
    float              KalFwdSteel() const;
    float              KalBakAir() const;
    float              KalBakSteel() const;
    float              CosYPosAtTrans() const;
    float              KalYPosAtTrans() const;
    float              MinDist() const;
    int                MinCell() const;
    int                NHadTracks() const;
    float              ERatio() const;
    float              Scatt() const;
    float              StartAct() const;
    float              EndAct() const;
    float              CosThetaTrue() const;
    float              KalThetaTrue() const;
    int                PDGBest() const;
    float              KalChiDiff() const;
    float              CosChiDiff() const;
    float              VtxDist() const;
    float              EndDist() const;
    float              FScattMax() const;
    float              FScattSum() const;
    float              FScattExt() const;
    float              FScattSig() const;
    float              CosHitRatio() const;
    float              TrackLenKal() const;
    float              TrackLenKal2nd() const;
    float              TrackE2nd() const;
    float              AngleKal2nd() const;
    float              AngleBtwKalTrks() const;
    float              TrkEPerNHit() const;
    
  protected:

    float              fAngleKal;
    float              fAngleCos;

    float              fConCosPID;
    float              fOldCosPID;
    float              fUnconTunedCosPID;

    int                fNTracks3D;
    float              fKFitSpeed;
    float              fCFitSpeed;
    float              fKDirScore;
    float              fCDirScore;
    float              fKScoreDiff;
    float              fCScoreDiff;
    float              fKalSlope;
    float              fKalChisq;
    float              fCosSlope;
    float              fCosChisq;
    float              fCosFwdDist;
    float              fCosFwdAir;
    float              fCosFwdSteel;
    float              fCosBakDist;
    int                fCosFwdCell;
    int                fCosFwdCellND;
    int                fCosBakCell;
    int                fCosBakCellND;
    float              fCosBakAir;
    float              fCosBakSteel;
    float              fKalFwdDist;
    float              fKalBakDist;
    int                fKalFwdCell;
    int                fKalFwdCellND;
    int                fKalBakCell;
    int                fKalBakCellND;
    float              fKalFwdAir;
    float              fKalFwdSteel;
    float              fKalBakAir;
    float              fKalBakSteel;
    float              fCosYPosAtTrans;
    float              fKalYPosAtTrans;
    float              fMinDist;
    int                fMinCell;
    int                fNHadTracks;
    float              fERatio;
    float              fScatt;
    float              fStartAct;
    float              fEndAct;
    float              fCosThetaTrue;
    float              fKalThetaTrue;
    int                fPDGBest;
    float              fKalChiDiff;
    float              fCosChiDiff;
    float              fVtxDist;
    float              fEndDist;
    float              fFScattMax;
    float              fFScattSum;
    float              fFScattExt;
    float              fFScattSig;
    float              fCosHitRatio;
    float              fTrackLenKal;
    float              fTrackLenKal2nd;
    float              fTrackE2nd;
    float              fAngleKal2nd;
    float              fAngleBtwKalTrks;
    float              fTrkEPerNHit;
    
  };

}
#endif