TCTrack.h

Go to the documentation of this file.

///////////////////////////////////////////////////////////////////////////
/// \brief   A TCHit contains pchits and information related to performing a timing calibration
/// \author  edniner@indiana.edu
/// \date    Feb. 2013
///////////////////////////////////////////////////////////////////////////
#ifndef TCTrack_H
#define TCTrack_H

#include "GeometryObjects/PlaneGeo.h"
#include "NovaDAQConventions/DAQConventions.h"

#include "canvas/Persistency/Common/PtrVector.h"

#include "TVector3.h"

/// Calibration data products
namespace caldp
{
  class PCHit;
  /// "Timing Calibration Track". Collection of PCHits
  ///  useful in performing a timing calibration."
  class TCTrack
  {
  public:
    TCTrack();
    
    virtual ~TCTrack();
    
    /// add a pchit to the track
    virtual void Add(const art::Ptr<caldp::PCHit>& pchit);
    /// add a collection of pchits to the track
    virtual void Add(const std::vector<art::Ptr<caldp::PCHit> >& pchits);

    /// return the number of hits in a view
    unsigned int NPCHit(geo::View_t view) const;
    /// return number of hits in x view
    unsigned int NXPCHit() const {return fXPCHits.size();}
    /// return number of hits in y view
    unsigned int NYPCHit() const {return fYPCHits.size();}
    /// return total number of hits
    unsigned int NPCHit()  const {return fXPCHits.size() + fYPCHits.size();}

    /// get the ith pchit from a specified view
    art::Ptr<caldp::PCHit> PCHit(geo::View_t view, unsigned int viewIdx) const;
    /// get the ith x view pchit
    art::Ptr<caldp::PCHit> XPCHit(unsigned int xIdx) const;
    /// get the ith y view pchit
    art::Ptr<caldp::PCHit> YPCHit(unsigned int yIdx) const;
    /// get the ith pchit from either view
    art::Ptr<caldp::PCHit> PCHit(unsigned int globalIdx) const;
    /// return the collection of all x view pchits
    const std::vector<art::Ptr<caldp::PCHit> >& XPCHits() const {return fXPCHits;}
    /// return the collection of all y view pchits
    const std::vector<art::Ptr<caldp::PCHit> >& YPCHits() const {return fYPCHits;}
    /// return the collection of all pchits
    std::vector<art::Ptr<caldp::PCHit> > AllPCHits() const;
    /// return the collection of pchits dropped by fiber fit
    std::vector<art::Ptr<caldp::PCHit> > AllDropPCHits() const {return fDropPCHits;}

    /// remove a pchit from the current cluster
    void RemovePCHit(const art::Ptr<caldp::PCHit> pch);
    /// remove the ith pchit from the cluster
    void RemovePCHit(unsigned int globalIdx);

    /// return max plane number in the specified view
    int MaxPlane(geo::View_t view) const;
    /// return min plane number in the specified view
    int MinPlane(geo::View_t view) const;
    /// return min cell number in the specified view
    int MinCell(geo::View_t view) const;
    /// return max cell number in the specified view
    int MaxCell(geo::View_t view) const;

    /// return min pchit time for a specified view
    double MinTNS(geo::View_t view=geo::kXorY) const;
    /// return max pchit time for a specified view
    double MaxTNS(geo::View_t view=geo::kXorY) const;
    /// return shortest path from start of track to a hit in a view
    double MinPath(geo::View_t view=geo::kXorY) const;
    /// return longest path from start of track to a hit in a view
    double MaxPath(geo::View_t view=geo::kXorY) const;

    /// return the start coordinate for the track
    TVector3 Start() const {return fStart;}
    /// return the stop coordinate for the track
    TVector3 Stop()  const {return fStop;}

    /// return total path lenght for track
    double TotalLength() const {return fTotalLength;}

    /// set track start point
    virtual void SetStart(TVector3 start) {fStart = start;}
    /// set track stop point
    virtual void SetStop(TVector3 stop) {fStop = stop;}
    /// set track total length
    virtual void SetTotalLength(double length) {fTotalLength = length;}

    /// return the velocity of the optical fiber, measured for this track
    double FiberVelocity() const {return fFiberVelocity;}

    /// Calculate the uncertainty in the time based on pulse height
    double TNSUncertainty(float pe, bool goodTime, novadaq::cnv::DetId detectorID) const;

    /// Correct for timewalk effect as a function of distance to readout
    double ReadoutDistCorrection(float x, novadaq::cnv::DetId detectorID) const;

    /// Calculate fiber speed as a function of distance from readout
    double CalcFiberVelocity(float d, novadaq::cnv::DetId detectorID) const;

     /// Recalculate fiber velocity for current track.
     /// A linear fit is performed plotting TNS - TOV vs ReadoutDist.
     /// Where TNS is the hit time and TOF is the time of flight from
     /// the start of the track to the hit, assuming a speed of c.
     /// The ReadoutDist is the distance from the hit location to the APD,
     /// including the pigtail length.
     /// The maximum residual allowed in the fit is a required parameter
     /// There is the option to remove hits from the track that fall outside
     /// this residual. If hits are removed, muon speed will then be recalculated,
     /// and the currently stored fFiberVelocity overwritten
     double CalculateFiberVelocity(double timeResid, 
                                   std::vector<double> *resids,
                                   double *icept,
                                   double *chisqr,
                                   novadaq::cnv::DetId detectorID,
                                   bool removeHits = false,
                                   bool overwrite = false);

     /// Calculate muon velocity for the current track
     /// A linear fit is performed of TNS - readoutCorrection vs pathlenght.
     /// Where TNS is the time for an individual hit, readoutCorrection is 
     /// the time for photons from that hit to travel to the APD.  If no fiberspeed
     /// is specified then the speed currently stored in the track is used. The 
     /// pathlength is the length from the start of track to the hit.
     /// The resulting fit for 1/v is multiplied by c so the value returned
     /// has the form 1/Beta.
     double CalculateMuonVelocity(std::vector<double> *resids,
                                  double *icept,
                                  double *chisqr,
                                  novadaq::cnv::DetId detectorID,
                                  double fiberVel = 9999.0) const;

     /// Set the fiber speed for the track.
     virtual void SetFiberVelocity(double vel) {fFiberVelocity = vel;}
    
 

  protected:    
    /// contain collections of pchits
    std::vector<art::Ptr<caldp::PCHit> > fXPCHits;
    std::vector<art::Ptr<caldp::PCHit> > fYPCHits;

    /// contains collection of pchits dropped by fiber fit
    std::vector<art::Ptr<caldp::PCHit> > fDropPCHits;

    /// start and endpoint for track
    TVector3  fStart;
    TVector3  fStop;

    /// Total pathlength of track
    double fTotalLength;

    /// optical fiber velocity for track
    double fFiberVelocity;
    
  };
  
} // end namespace

#endif // TCTrack_H