/**
   \file
   StationRecData reconstructed station data
   \version $Id: StationRecData.h 22125 2012-10-30 00:17:39Z darko $
*/

#ifndef _sevt_StationRecData_h_
#define _sevt_StationRecData_h_

#include <utl/TimeStamp.h>
#include <utl/ShadowPtr_fwd.h>

#include <sevt/StationConstants.h>


static const char CvsId_sevt_StationRecData[] =
  "$Id: StationRecData.h 22125 2012-10-30 00:17:39Z darko $";


namespace sevt {

  class Station;


  /**
    \class StationRecData StationRecData.h "sevt/StationRecData.h"
    \brief Class to access station level reconstructed data

    \version $Id: StationRecData.h 22125 2012-10-30 00:17:39Z darko $
    \ingroup sevt
  */

  class StationRecData {

  public:
    typedef StationConstants::RiseTimeRejectionCode RiseTimeRejectionCode;
    static const RiseTimeRejectionCode eLowSignal = StationConstants::eLowSignal;
    static const RiseTimeRejectionCode eNotCandidate = StationConstants::eNotCandidate;
    static const RiseTimeRejectionCode eLowGainSaturated = StationConstants::eLowGainSaturated;
    static const RiseTimeRejectionCode eNotInRing = StationConstants::eNotInRing;

    /// Total integrated signal in VEM  unit, averaged over pmts
    double GetTotalSignal() const { return fTotalSignal; }
    double GetTotalSignalError() const { return fTotalSignalError; }

    /// Total recovered signal in VEM  unit, averaged over pmts 
    double GetRecoveredSignal() const { return fRecoveredSignal; }
    double GetRecoveredSignalError() const { return fRecoveredSignalError; }

    /// Distance from core in shower plane coordinates
    double GetSPDistance() const { return fSPDistance; }

    /// Error in core distance in shower plane coordinates
    double GetSPDistanceError() const { return fSPDistanceError; }

    /// Azimuth in shower plane coordinates
    double GetAzimuthShowerPlane() const { return fAzimuthShowerPlane; }

    /// Amplitude of signal Peak  in VEM-Peak unit,averaged over pmts
    double GetPeakAmplitude() const { return fPeakAmplitude; }

    /// Area over peak
    double GetAreaOverPeak() const { return fAreaOverPeak; }

    /// Shape parameter averaged over PMTs
    double GetShapeParameter() const { return fShapeParameter; }
 
    /// ShapeParameter spread
    double GetShapeParameterRMS() const { return fShapeParameterRMS; }

    /// Rise time averaged over PMTs
    double GetRiseTime() const { return fRiseTime; }
 
    /// Rise time spread
    double GetRiseTimeRMS() const { return fRiseTimeRMS; }

    /// Fall time averaged over PMTs
    double GetFallTime() const { return fFallTime; }

    /// Fall time spread
    double GetFallTimeRMS() const { return fFallTimeRMS; }

    /// T50
    double GetT50() const { return fT50; }
    double GetT50RMS() const { return fT50RMS; }

    /// Residual of geometry fit
    double GetResidual() const { return fResidual; }

    /// Residual of lateral fit
    double GetLDFResidual() const { return fLDFResidual; }

    /// Start time of the signal in time slots from beginning of trace
    unsigned int GetSignalStartSlot() const { return fSignalStart; }

    /// End time of the signal in time slots from beginning of trace
    unsigned int GetSignalEndSlot() const { return fSignalEnd; }

    /// Muon signal [number of muons]
    double GetMuonComponent() const { return fMuonComponent; }

    /// Start time of the signal in GPS sec, ns
    utl::TimeStamp GetSignalStartTime() const { return fStartTime; }

    double GetCorrectedRiseTime() const { return fCorrectedRiseTime; }

    double GetCorrectedRiseTimeError() const { return fCorrectedRiseTimeError; }

    int GetRiseTimeRejectionCode() const { return fRiseTimeRejectionCode; }

    // time offset in case GPS position correction has been applied
    utl::TimeInterval GetStartTimeGPSCorrection() const { return fStartTimeGPSCorrection; }

    /// Total integrated signal in VEM  unit, averaged over pmts
    void SetTotalSignal(const double signal, const double sErr = 0)
    { fTotalSignal = signal; fTotalSignalError = sErr; }

    /// Total recovered signal in VEM  unit, averaged over pmts
    void SetRecoveredSignal(const double recSignal, const double recSignalErr)
    { fRecoveredSignal = recSignal; fRecoveredSignalError = recSignalErr; }

    /// Distance from core in shower plane coordinates
    void SetSPDistance(const double distance, const double error)
    { fSPDistance = distance; fSPDistanceError = error; }

    /// Azimuth in shower plane coordinates
    void SetAzimuthShowerPlane(const double azimuth)
    { fAzimuthShowerPlane = azimuth; }

    /// Amplitude of signal Peak  in VEM-Peak unit,averaged over pmts
    void SetPeakAmplitude(const double peak) { fPeakAmplitude = peak; }

    /// Area over peak
    void SetAreaOverPeak(const double areaOverPeak) { fAreaOverPeak = areaOverPeak; }

    /// Shape parameter and RMS averaged over PMTs
    void SetShapeParameter(const double shapeParameter, const double rms)
    { fShapeParameter = shapeParameter; fShapeParameterRMS = rms; }

    /// Rise time and rise time RMS averaged over PMTs
    void SetRiseTime(const double riseTime, const double rms)
    { fRiseTime = riseTime; fRiseTimeRMS = rms; }

    /// Fall time and fall time RMS averaged over PMTs
    void SetFallTime(const double fallTime, const double rms)
    { fFallTime = fallTime; fFallTimeRMS = rms; }

    /// T50
    void SetT50(const double t50, const double rms) { fT50 = t50; fT50RMS = rms; }

    /// Residual of geometry fit
    void SetResidual(const double residual) { fResidual = residual; }

    /// Residual of lateral fit
    void SetLDFResidual(const double LDFresidual) { fLDFResidual = LDFresidual; }

    /// Start time of the signal in time slots from beginning of trace
    void SetSignalStartSlot(const unsigned int slot) { fSignalStart = slot; }

    /// End time of the signal in time slots from beginning of trace
    void SetSignalEndSlot(const unsigned int slot) { fSignalEnd = slot; }

    /// Muon signal [number of muons]
    void SetMuonComponent(const double component) { fMuonComponent = component; }

    /// Start time of the signal in GPS sec, ns
    void SetSignalStartTime(const utl::TimeStamp time) { fStartTime = time; }

    void SetStartTimeGPSCorrection(const utl::TimeInterval offset)
    { fStartTimeGPSCorrection = offset; }

    void SetCorrectedRiseTime(const double crt, const double crte)
    { fCorrectedRiseTime = crt; fCorrectedRiseTimeError = crte; }

    void SetRiseTimeRejectionCode(const int code)
    { fRiseTimeRejectionCode = code; }

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

    double fTotalSignal;
    double fTotalSignalError;
    double fSPDistance;
    double fSPDistanceError;
    double fAzimuthShowerPlane;
    double fPeakAmplitude;
    double fAreaOverPeak;
    double fShapeParameter;
    double fShapeParameterRMS;
    double fRiseTime;
    double fRiseTimeRMS;
    double fFallTime;
    double fFallTimeRMS;
    double fT50;
    double fT50RMS;
    double fResidual;
    double fLDFResidual;
    unsigned int fSignalStart;
    unsigned int fSignalEnd;
    double fMuonComponent;
    utl::TimeStamp fStartTime;
    utl::TimeInterval fStartTimeGPSCorrection;

    // signal recovery
    double fRecoveredSignal;
    double fRecoveredSignalError;

    // rise time at 1000m
    double fCorrectedRiseTime;
    double fCorrectedRiseTimeError;
    int fRiseTimeRejectionCode;

    friend class sevt::Station;
    friend class utl::ShadowPtr<StationRecData>;

  }; 

}


#endif

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