PCHit.h

Go to the documentation of this file.

///////////////////////////////////////////////////////////////////////////
/// \brief   A PCHit contains the basic information from cosmic track data 
///          needed for calibration.
/// \author  rtoner@physics.harvard.edu
/// \date    Jan. 2013
///////////////////////////////////////////////////////////////////////////
#ifndef PCHIT_H
#define PCHIT_H

#include "GeometryObjects/PlaneGeo.h"

/// Calibration data products
namespace caldp
{
  /// "Pre-calibration hit". Common input to calibration procedures
  class PCHit
  {
  public:
    PCHit();
    
    ~PCHit();

    /// Return plane value
    int         Plane    () const {return plane;     }; 
    /// Return cell value
    int         Cell     () const {return cell;      }; 
    /// Return diblock value
    int         Diblock  () const {return diblock;   }; 
    /// Return dcm value
    int         DCM      () const {return dcm;       }; 
    /// Return apd value
    int         APD      () const {return apd;       }; 
    /// Return pixel value
    int         Pixel    () const {return pixel;     }; 
    /// Return view
    geo::View_t View     () const {return view;      }; 
    /// Return PE value
    float       PE       () const {return pe;        }; 
    /// Return Path value
    float       Path     () const {return path;      }; 
    /// Return W value
    float       W        () const {return w;         }; 
    /// Return True energy (MeV) value
    float       TrueMeV  () const {return trueMeV;   }; 
    /// Return True PE value
    float       TruePE   () const {return truePE;    }; 
    /// Return True Pathlength value
    float       TruePath () const {return truePath;  };
    /// Return True W value
    float       TrueW    () const {return trueW;     };
    /// Return uncorrected hit time
    float       TNS      () const {return tns;       }; 
    /// Return quality of timing fit for cell
    bool        GoodTime () const {return goodTime;  }; 
    /// Return path from start of track to current cell
    float       FlightLen() const {return flightLen; }; 
    /// Return distance to readout, with pigtail
    float       ReadDist () const {return readDist;  }; 
    /// Return number of simulated photons at readout before fluctuations
    float       PoissonLambda () const { return poissonLambda; }

    /// Set plane value
    void SetPlane    (int         aPlane   ) { plane    = aPlane;   };
    /// Set cell value
    void SetCell     (int         aCell    ) { cell     = aCell;    };
    /// Set diblock value
    void SetDiblock  (int         aDiblock ) { diblock  = aDiblock; };
    /// Set dcm value
    void SetDCM      (int         aDCM     ) { dcm      = aDCM;     };
    /// Set apd value
    void SetAPD      (int         aAPD     ) { apd      = aAPD;     };
    /// Set pixel value
    void SetPixel    (int         aPixel   ) { pixel    = aPixel;   };
    /// Set view value
    void SetView     (geo::View_t aView    ) { view     = aView;    };
    /// Set PE value
    void SetPE       (float       aPE      ) { pe       = aPE;      };
    /// Set Path value
    void SetPath     (float       aPath    ) { path     = aPath;    };
    /// Set W value
    void SetW        (float       aW       ) { w        = aW;       };
    /// Set True energy (MeV) value
    void SetTrueMeV  (float       aTrueMeV ) { trueMeV  = aTrueMeV; };
    /// Set True PE value
    void SetTruePE   (float       aTruePE  ) { truePE   = aTruePE;  };
    /// Set True path length value
    void SetTruePath (float       aTruePath) { truePath = aTruePath;};
    /// Set True W value
    void SetTrueW    (float       aTrueW   ) { trueW    = aTrueW;   };
    /// Set hit time (ns)
    void SetTNS      (float       aTNS     ) { tns      = aTNS;     };
    /// Set quality of timing fit
    void SetGoodTime (bool        aGoodT   ) { goodTime = aGoodT;   };
    /// Set path length from start of track
    void SetFlightLen(float       aLen     ) { flightLen= aLen;     };
    /// Set distance to cell readout
    void SetReadDist (float       aDist    ) { readDist = aDist;    };
    /// Set number of simulated photons at readout before fluctuations
    void SetPoissonLambda(float   aLambda  ) { poissonLambda = aLambda; }
  protected:    
    int plane;        ///< plane number
    int cell;         ///< cell number
    int diblock;      ///< diblock number
    int dcm;          ///< number of dcm on diblock
    int apd;          ///< number of apd on dcm
    int pixel;        ///< number pixel on apd
    geo::View_t view; ///< hit view
    float pe;         ///< uncalibrated PEs
    float path;       ///< Path length
    float w;          ///< Unmeasured coordinate of hit
    float trueMeV;    ///< True energy of hit (MC Truth)
    float truePE;     ///< True number of photoelectrons (MC Truth)
    float truePath;   ///< True pathlength through the cell
    float trueW;      ///< True position along cell W (W)
    float tns;        ///< Time of pchit (ns)
    bool  goodTime;   ///< True if the time fit for the hit was good
    float flightLen;  ///< path length from the start of track (cm)
    float readDist;   ///< distance from hit to readout(including pigtail) (cm)
    float poissonLambda; ///< Number of simulated photons at readout in the absence of fluctuations
  };
  
} // end namespace

#endif // PCHIT_H