CellHit.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file    CellHit.h
// \brief   A CellHit has all the calibrated information about a hit that
//          doesn't require any event context (e.g., reconstruction location).
// \version $Id: CellHit.h,v 1.10 2012-10-26 21:31:55 bckhouse Exp $
// \author  $Author: bckhouse $
////////////////////////////////////////////////////////////////////////
#ifndef RBCELLHIT_H
#define RBCELLHIT_H

#include <iosfwd>
#include <vector>
#include <utility>

#include "GeometryObjects/OfflineChan.h"
#include "GeometryObjects/PlaneGeo.h"
#include "RawData/RawDigit.h"

#ifndef __GCCXML__
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#endif

namespace rb 
{  
  /// \brief A \ref rawdata::RawDigit with channel information decoded
  class CellHit : public rawdata::RawDigit
  {
  public:
    CellHit(); // Default constructor
    ~CellHit();

#ifndef __GCCXML__
    CellHit(const rawdata::RawDigit& rd, int id=0);
    
    void Print() const; //print out the important bits of this cellhit
    
    // Getters
    unsigned short                            Plane ()        const { return fPlane;         }        
    unsigned short                            Cell  ()        const { return fCell;          }
    geo::View_t                               View  ()        const { return fView;          }
    float                                     PE    ()        const { return fPE;            }
    /// Returns the time of the hit in nanoseconds. This is the
    /// multipoint fit (a.k.a. fine timing) if available, and the time
    /// of the last baseline sample (a.k.a. coarse timing) if not.
    float                                     TNS   ()        const { return fTNS;           }
    const int                                 ID    ()        const { return fID;            }
    bool                                      GoodTiming()    const { return !fCoarseTiming; }
    geo::OfflineChan OfflineChan() const { return geo::OfflineChan(fPlane, fCell); }
 
    // Setters
    void SetCell       (unsigned short cell   ) { fCell    = cell;   }
    void SetPlane      (unsigned short plane  ) { fPlane   = plane;  }
    void SetView       (geo::View_t    view   ) { fView    = view;   }
    void SetPE         (float          pe     ) { fPE      = pe;     }
    void SetTNS        (float          tns,
                        bool           good   ) { fTNS     = tns; fCoarseTiming = !good;}
    void SetID         (int            id     ) { fID      = id;     }
    
    ///< Compares hits by plane, then cell, then time
    bool operator< (const CellHit& other) const;
    bool operator== (const CellHit& other) const;  ///< Returns true if the two cellhits have the same plane, cell, PE and TDC values.
    
    friend std::ostream& operator << (std::ostream& o, const CellHit& c);
#endif // __GCCXML__
  protected:
    unsigned short fPlane;  ///< plane number
    unsigned short fCell;   ///< cell number
    geo::View_t    fView;   ///< view (geo::kX or geo::kY)
    
    float          fPE;     ///< after ADC-->PE gain applied
    float          fTNS;    ///< time of hit in ns with channel differences removed
    int            fID;     ///< ID for CellHit

    bool           fCoarseTiming; ///< Was the timing fit bad?
  };

#ifndef __GCCXML__
  /// Helper for \ref SortByPlane. Is \a a on a lower number plane than \a b?
  bool CompareByPlane(const art::Ptr<rb::CellHit>& a,
                      const art::Ptr<rb::CellHit>& b);
  
  /// Helper for \ref SortByTime. Is \a a earlier than \a b?
  bool CompareByTime(const art::Ptr<rb::CellHit>& a,
                     const art::Ptr<rb::CellHit>& b);
  
  /// Helper for \ref SortByCell. Is \a a on a lower cell number than \a b?
  bool CompareByCell(const art::Ptr<rb::CellHit>& a,
                     const art::Ptr<rb::CellHit>& b);

  /// Helper for \ref SortByPlaneAndCell. Is \a a on a lower (plane,cell) 
  /// number than \a b?
  bool CompareByPlaneAndCell(const art::Ptr<rb::CellHit>& a,
                             const art::Ptr<rb::CellHit>& b);
  
  /// Sort \a c in plane order (low to high).
  void SortByPlane(std::vector<art::Ptr<rb::CellHit> >& c);
  /// Sort \a c in plane order (low to high).
  void SortByPlane(art::PtrVector<rb::CellHit>& c);
  /// Sort \a c in plane order (low to high).
  /// Within a plane, order them by cell
  void SortByPlaneAndCell(art::PtrVector<rb::CellHit>& c);
  /// Sort \a c in plane order (low to high).
  /// Within a plane, order them by cell
  void SortByPlaneAndCell(std::vector<rb::CellHit>& c);
  
  /// Sort \a c in time order (earliest to latest).
  void SortByTime(std::vector<art::Ptr<rb::CellHit> >& c); 
  /// Sort \a c in time order (earliest to latest).
  void SortByTime(art::PtrVector<rb::CellHit>& c); 
  
  /// Sort \a c in cell order (low to high)
  void SortByCell(std::vector<art::Ptr<rb::CellHit> >& c);
  /// Sort \a c in cell order (low to high)
  void SortByCell(art::PtrVector<rb::CellHit>& c);
#endif // __GCCXML__
} // end namespace

#endif // RBCELLHIT_H
////////////////////////////////////////////////////////////////////////