PixelRecData.h

Go to the documentation of this file.

#ifndef _fevt_PixelRecData_h_
#define _fevt_PixelRecData_h_

#include <fevt/FdConstants.h>

#include <utl/MultiTrace.h>
#include <utl/TimeInterval.h>
#include <utl/ShadowPtr.h>


namespace utl {
  class Photon;
}


namespace fevt {

  class PixelRecData {

  public:
    utl::TraceD& GetPhotonTrace(const FdConstants::LightSource source = FdConstants::eTotal)
    { return fPhotonTrace->GetTrace(source); }
    const utl::TraceD& GetPhotonTrace(const FdConstants::LightSource source = FdConstants::eTotal) const
    { return fPhotonTrace->GetTrace(source); }

    void MakePhotonTrace(unsigned int size, double binning, 
                         const FdConstants::LightSource source = FdConstants::eTotal);
    void MakePhotonTrace(const utl::TraceD& t,
                         const FdConstants::LightSource source = FdConstants::eTotal);

    bool HasPhotonTrace(const FdConstants::LightSource source = FdConstants::eTotal) const
    { return fPhotonTrace->HasLabel(source); }

    typedef utl::MultiTraceD::Iterator PhotonTraceIterator;
    typedef utl::MultiTraceD::ConstIterator ConstPhotonTraceIterator;

    PhotonTraceIterator PhotonTracesBegin() { return fPhotonTrace->Begin(); }
    ConstPhotonTraceIterator PhotonTracesBegin() const { return fPhotonTrace->Begin(); }

    PhotonTraceIterator PhotonTracesEnd() { return fPhotonTrace->End(); }
    ConstPhotonTraceIterator PhotonTracesEnd() const { return fPhotonTrace->End(); }

    int GetFirstTriggeredTimeBin() const { return fFirstTriggeredTimeBin; }

    double GetTotalCharge() const { return fCharge; }
    int GetPulseStart() const { return fPulseStart; }
    int GetPulseStop() const { return fPulseStop; }
    double GetBaseline() const { return fBaseline; }
    double GetRMS() const { return fRMS; }

    double GetCentroid() const { return fCentroid; }
    double GetCentroidError() const { return fCentroidError; }
 
    void SetCentroid(const double centroid, const double err)
    { fCentroid = centroid; fCentroidError = err; }
    bool PulseIsFound() const { return fPulseIsFound; }

    enum Flag {
      eValid = 0,
      eTimeRejected = 1,
      eSpaceRejected = 2,
      eTimeFitRejected = 3,
      eSpaceFitRejected = 4
    };

    Flag GetFlag() const { return fFlagValidPixels; }
    
    void SetFlag(const Flag flagvalidpixels)
    { fFlagValidPixels = flagvalidpixels; }

    void SetFirstTriggeredTimeBin(const int bin) { fFirstTriggeredTimeBin = bin; }

    void SetTotalCharge(const double charge) { fCharge = charge; }
    void SetPulseStart(const int start) { fPulseStart = start; }
    void SetPulseStop(const int stop) { fPulseStop = stop; }

    void SetBaseline(const double bl) { fBaseline = bl; }
    void SetRMS(const double rms) { fRMS = rms; }
    void SetPulseFound(bool flag=true) { fPulseIsFound = flag; }

    enum eCode {
      eUndefined = 999999
    };

    void SetChi_i(const double chi_i) { fChi_i=chi_i; }
    double GetChi_i() const { return fChi_i; }

    void SetT_i(const double t_i, const double error)
    { fT_i = t_i; fT_iError = error; }

    utl::TimeInterval GetT_i() const { return fT_i; }
    utl::TimeInterval GetT_iError() const { return fT_iError; }

  private:
    PixelRecData();
    ~PixelRecData() { }

    //void Clear();

    double fCharge;
    int fPulseStart;
    int fPulseStop;
    double fBaseline;
    double fRMS;
    double fCentroid;
    double fCentroidError;
    double fChi_i;
    utl::TimeInterval fT_i;
    utl::TimeInterval fT_iError;
    bool fPulseIsFound;

    utl::InitializedShadowPtr<utl::MultiTraceD> fPhotonTrace;
    int fFirstTriggeredTimeBin;

    Flag fFlagValidPixels;

    friend class Pixel;
    friend class utl::ShadowPtr<PixelRecData>;

  };

}


#endif
 
// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. FEvent/PixelRecData.o -k"
// End: