/**
   \file
   Declaration of PMTRecData

*/

#ifndef _sevt_PMTRecData_h_
#define _sevt_PMTRecData_h_

#include <vector>
#include <utility>

#include <utl/Trace.h>
#include <utl/ShadowPtr.h>
#include <utl/LameShadowPtr_fwd.h>
#include <utl/MultiTrace.h>
#include <utl/QuadraticFitData.h>
#include <utl/TabulatedFunctionErrors.h>
#include <utl/TabulatedFunction.h>

#include <utl/ExponentialFitData.h>
#include <sevt/StationConstants.h>
#include <sevt/PMTConstants.h>
#include <sdet/Station.h>

static const char CVSId_sevt_PMTRecData[] =
  "$Id: PMTRecData.h 22124 2012-10-30 00:15:43Z darko $";


namespace sevt {

  /**
    \class PMTRecData PMTRecData.h sevt/PMTRecData.h
    \brief class to hold reconstructed data at %PMT level
    \author Stefano Argiro
    \author Darko Veberic
    \version $Id: PMTRecData.h 22124 2012-10-30 00:15:43Z darko $
    \date 10 Oct 2003
    \date 10 Oct 2007 DV add baseline
    \ingroup sevt
  */

  class PMTRecData {
  public:
    class Signal {
    public:
      Signal(const int start, const int stop, const int binsTh, const double max, const double charge) :
        fStart(start),
        fStop(stop),
        fBinsOverThresh(binsTh),
        fMaxValue(max),
        fCharge(charge)
      { }

      int fStart;
      int fStop;
      int fBinsOverThresh;
      double fMaxValue;
      double fCharge;
    };

    typedef std::vector<Signal> SignalCollection;

    /// Traces calibrated in VEM Peak
    /** By default, the trace corresponding to the total signal is returned
     *  Use GetVEMTrace(StationConstants::SignalComponent Source) to get other
     *  sources (if any)
     *  /example GetVEMTrace(StationConstants::eMuon */
    utl::TraceD& GetVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fTrace->GetTrace(source); }

    const utl::TraceD& GetVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fTrace->GetTrace(source); }

    void MakeVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal)
    { fTrace->AddTrace(sdet::Station::GetFADCTraceLength(),
                       sdet::Station::GetFADCBinSize(), source); }

    bool HasVEMTrace(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fTrace->HasLabel(source); }

    /// An iterator over the available VEM trace sources.
    /**	Returns a LabeledTrace when dereferenced */
    typedef utl::MultiTrace<double>::Iterator VEMTraceIterator;
    typedef utl::MultiTrace<double>::ConstIterator ConstVEMTraceIterator;

    VEMTraceIterator VEMTracesBegin() { return fTrace->Begin(); }
    ConstVEMTraceIterator VEMTracesBegin() const { return fTrace->Begin(); }

    VEMTraceIterator VEMTracesEnd() { return fTrace->End(); }
    ConstVEMTraceIterator VEMTracesEnd() const { return fTrace->End(); }

    bool HasFADCBaseline(const PMTConstants::PMTGain gain = PMTConstants::eHighGain) const
    { return fFADCBaseline[gain]; }

    void MakeFADCBaseline(const PMTConstants::PMTGain gain = PMTConstants::eHighGain)
    { fFADCBaseline[gain] =
        new utl::TraceD(sdet::Station::GetFADCTraceLength(), sdet::Station::GetFADCBinSize()); }

    utl::TraceD& GetFADCBaseline(const PMTConstants::PMTGain gain = PMTConstants::eHighGain)
    { return *fFADCBaseline[gain]; }

    const utl::TraceD& GetFADCBaseline(const PMTConstants::PMTGain gain = PMTConstants::eHighGain) const
    { return *fFADCBaseline[gain]; }

    double GetFADCBaselineError(const PMTConstants::PMTGain gain = PMTConstants::eHighGain) const
    { return fFADCBaselineError[gain]; }

    int GetFADCBaselineWindow(const PMTConstants::PMTGain gain = PMTConstants::eHighGain) const
    { return fFADCBaselineWindow[gain]; }

    /// pieces of relative FADC flatnes in format [first, second)
    typedef std::pair<unsigned int, unsigned int> Piece;
    typedef std::vector<Piece> FlatPieceCollection;

    FlatPieceCollection& GetBaselineFlatPieces(const PMTConstants::PMTGain gain = PMTConstants::eHighGain)
    { return fFADCBaselineFlatPieces[gain]; }
    const FlatPieceCollection& GetBaselineFlatPieces(const PMTConstants::PMTGain gain = PMTConstants::eHighGain) const
    { return fFADCBaselineFlatPieces[gain]; }

    /// Average rise time from the PMTs
    double GetRiseTime() const { return fRiseTime; }
    /// RMS of the rise time from the PMTs
    double GetRiseTimeRMS() const { return fRiseTimeRMS; }
    /// Average fall time from the PMTs
    double GetFallTime() const { return fFallTime; }
    /// RMS of the fall time from the PMTs
    double GetFallTimeRMS() const { return fFallTimeRMS; }
    /// T50
    double GetT50() const { return fT50; }
    /// Peak value in VEM
    double GetVEMPeak() const { return fVEMPeak; }
    double GetVEMPeakError() const { return fVEMPeakError; }
    bool IsVEMPeakFromHistogram() const { return fIsVEMPeakFromHistogram; }
    /// Charge value in VEM
    double GetVEMCharge() const { return fVEMCharge; }
    double GetVEMChargeError() const { return fVEMChargeError; }
    bool IsVEMChargeFromHistogram() const { return fIsVEMChargeFromHistogram; }
    /// Area over peak
    double GetAreaOverPeak() const { return fAreaOverPeak; }
    /// Total charge
    double GetTotalCharge() const { return fTotalCharge; }
    double GetTotalChargeError() const { return fTotalChargeError; }
    /// Peak Amplitude
    double GetPeakAmplitude() const { return fPeakAmplitude; }
    double GetShapeParameter() const { return fShapeParameter; }
    /// Slope of the muon charge histogram
    double GetMuonChargeSlope() const { return fMuonChargeSlope; }
    /// Slope of the muon shape histogram
    double GetMuonPulseDecayTime() const { return fMuonPulseDecayTime; }
    double GetMuonPulseDecayTimeError() const { return fMuonPulseDecayTimeError; }
    double GetDynodeAnodeRatio() const { return fDynodeAnodeRatio; }

    utl::QuadraticFitData& GetMuonPeakFitData() { return fMuonPeakFitData; }
    const utl::QuadraticFitData& GetMuonPeakFitData() const { return fMuonPeakFitData; }

    utl::QuadraticFitData& GetMuonChargeFitData() { return fMuonChargeFitData; }
    const utl::QuadraticFitData& GetMuonChargeFitData() const { return fMuonChargeFitData; }

    utl::ExponentialFitData& GetMuonChargeSlopeFitData() { return fMuonChargeSlopeFitData; }
    const utl::ExponentialFitData& GetMuonChargeSlopeFitData() const { return fMuonChargeSlopeFitData; }

    utl::ExponentialFitData& GetMuonShapeFitData() { return fMuonShapeFitData; }
    const utl::ExponentialFitData& GetMuonShapeFitData() const { return fMuonShapeFitData; }

    int GetFADCSaturatedBins(const PMTConstants::PMTGain gain = PMTConstants::eHighGain) const
    { return fFADCSaturatedBins[gain]; }

    PMTConstants::PMTGain GetGainUsed() const { return fGainUsed; }

    SignalCollection& GetRawSignals() { return fRawSignals; }
    const SignalCollection& GetRawSignals() const { return fRawSignals; }

    SignalCollection& GetSignals() { return fSignals; }
    const SignalCollection& GetSignals() const { return fSignals; }

    void SetRiseTime(const double riseTime, const double rms)
    { fRiseTime = riseTime; fRiseTimeRMS = rms; }

    void SetFallTime(const double fallTime, const double rms)
    { fFallTime = fallTime; fFallTimeRMS = rms; }

    void SetT50(const double t50) { fT50 = t50; }

    void SetVEMPeak(const double vemPeak, const double peakErr = 0)
    { fVEMPeak = vemPeak; fVEMPeakError = peakErr; }
    void SetVEMPeakFromHistogram(const bool is) { fIsVEMPeakFromHistogram = is; }
    void SetVEMCharge(const double vemCharge, const double chErr = 0)
    { fVEMCharge = vemCharge; fVEMChargeError = chErr; }
    void SetVEMChargeFromHistogram(const bool is) { fIsVEMChargeFromHistogram = is; }
    void SetAreaOverPeak(const double areaOverPeak) { fAreaOverPeak = areaOverPeak; }
    void SetTotalCharge(const double totalCharge, const double chErr = 0)
    { fTotalCharge = totalCharge; fTotalChargeError = chErr; }
    void SetPeakAmplitude(const double peak) { fPeakAmplitude = peak; }
    void SetShapeParameter(const double shape) { fShapeParameter = shape; }
    /// in unit of 1/VEM
    void SetMuonChargeSlope(const double slope) { fMuonChargeSlope = slope; }
    void SetMuonPulseDecayTime(const double time, const double tErr = 0)
    { fMuonPulseDecayTime = time; fMuonPulseDecayTimeError = tErr; }
    void SetDynodeAnodeRatio(const double da) { fDynodeAnodeRatio = da; }

    void SetFADCBaselineError(const double error, const PMTConstants::PMTGain gain = PMTConstants::eHighGain)
    { fFADCBaselineError[gain] = error; }

    void SetFADCBaselineWindow(const int sigma, const PMTConstants::PMTGain gain = PMTConstants::eHighGain)
    { fFADCBaselineWindow[gain] = sigma; }

    void SetFADCSaturatedBins(const int num, const PMTConstants::PMTGain gain = PMTConstants::eHighGain)
    { fFADCSaturatedBins[gain] = num; }

    void SetGainUsed(const PMTConstants::PMTGain gain) { fGainUsed = gain; }

    bool HasMuonProductionDepth() const { return fMuonProductionDepth; }

    utl::TabulatedFunctionErrors& GetMuonProductionDepth() { return *fMuonProductionDepth; }

    const utl::TabulatedFunctionErrors& GetMuonProductionDepth() const
    { return *fMuonProductionDepth; }

    void
    MakeMuonProductionDepth()
    {
      if (fMuonProductionDepth)
        ERROR("PMTRecData:: Muon production depth already exists - Not replacing");
      else 
        fMuonProductionDepth = new utl::TabulatedFunctionErrors;
    }
    
    void SetUsedInGlobalMPD(const bool is) { fIsUsedInGlobalMPD = is; }

    bool IsUsedInGlobalMPD() const { return fIsUsedInGlobalMPD; }

  private:
    PMTRecData() :
      fRiseTime(0), fRiseTimeRMS(0),
      fFallTime(0), fFallTimeRMS(0),
      fT50(0),
      fVEMPeak(0), fVEMPeakError(0), fIsVEMPeakFromHistogram(false),
      fVEMCharge(0), fVEMChargeError(0), fIsVEMChargeFromHistogram(false),
      fAreaOverPeak(0),
      fTotalCharge(0), fTotalChargeError(0),
      fPeakAmplitude(0),
      fShapeParameter(0),
      fMuonChargeSlope(0),
      fMuonPulseDecayTime(0), fMuonPulseDecayTimeError(0),
      fDynodeAnodeRatio(0),
      fIsUsedInGlobalMPD(false),
      //fMuonPeakFitData
      //fMuonChargeFitData
      //fMuonChargeSlopeFitData
      //fMuonShapeFitData
      //fTrace
      //fFADCBaseline[]
      //fFADCBaselineFlatPieces
      fGainUsed(PMTConstants::eNoGain)
      //fRawSignals
      //fSignals
    {
      for (int i = 0; i < PMTConstants::eNumberOfGains; ++i) {
        fFADCBaselineError[i] = 0;
        fFADCBaselineWindow[i] = 0;
        fFADCSaturatedBins[i] = 0;
      }
    }

    ~PMTRecData() { }

    double fRiseTime;
    double fRiseTimeRMS;
    double fFallTime;
    double fFallTimeRMS;
    double fT50;
    double fVEMPeak;
    double fVEMPeakError;
    bool fIsVEMPeakFromHistogram;
    double fVEMCharge;
    double fVEMChargeError;
    bool fIsVEMChargeFromHistogram;
    double fAreaOverPeak;
    double fTotalCharge;
    double fTotalChargeError;
    double fPeakAmplitude;
    double fShapeParameter;
    double fMuonChargeSlope;
    double fMuonPulseDecayTime;
    double fMuonPulseDecayTimeError;
    double fDynodeAnodeRatio;

    utl::QuadraticFitData fMuonPeakFitData;
    utl::QuadraticFitData fMuonChargeFitData;
    utl::ExponentialFitData fMuonChargeSlopeFitData;
    utl::ExponentialFitData fMuonShapeFitData;
    bool fIsUsedInGlobalMPD;

  protected:
    // From calibrated tank in VEM
    utl::InitializedShadowPtr<utl::MultiTraceD> fTrace;

  private:
    utl::ShadowPtr<utl::TraceD> fFADCBaseline[PMTConstants::eNumberOfGains];
    double fFADCBaselineError[PMTConstants::eNumberOfGains];
    int fFADCBaselineWindow[PMTConstants::eNumberOfGains];
    FlatPieceCollection fFADCBaselineFlatPieces[PMTConstants::eNumberOfGains];
    int fFADCSaturatedBins[PMTConstants::eNumberOfGains];
    PMTConstants::PMTGain fGainUsed;
    SignalCollection fRawSignals;
    SignalCollection fSignals;
    
    utl::ShadowPtr<utl::TabulatedFunctionErrors> fMuonProductionDepth;
    
    friend class PMT;
    friend class utl::ShadowPtr<PMTRecData>;

  };

}


#endif

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