PMTRecData.h

Go to the documentation of this file.

#ifndef _sevt_PMTRecData_h_
#define _sevt_PMTRecData_h_

#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/IteratorRange.h>

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

#include <vector>
#include <utility>


namespace io {
  class PMTRecData_ROOT;
}

namespace sevt {

  class PMTRecData {

  public:

    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(fFADCTraceLength, fFADCBinSize, source); }

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


    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(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(VEMTraceIterator, ConstVEMTraceIterator, VEMTraces)

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

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

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

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

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

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

    typedef std::pair<unsigned int, unsigned int> Piece;
    typedef std::vector<Piece> FlatPieceCollection;

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

    double GetRiseTime() const { return fRiseTime; }
    double GetRiseTimeCleaned() const { return fRiseTimeCleaned; }
    double GetRiseTimeRMS() const { return fRiseTimeRMS; }
    double GetRiseTimeCleanedRMS() const { return fRiseTimeCleanedRMS; }
    double GetFallTime() const { return fFallTime; }
    double GetFallTimeCleaned() const { return fFallTimeCleaned; }
    double GetFallTimeRMS() const { return fFallTimeRMS; }
    double GetFallTimeCleanedRMS() const { return fFallTimeCleanedRMS; }

    double GetT40() const { return fT40; }
    double GetT50() const { return fT50; }

    // VEM_peak as estimated from the Online value
    double GetOnlineVEMPeak() const { return fOnlineVEMPeak; }
    double GetOnlineVEMPeakError() const { return fOnlineVEMPeakError; }
    // VEM_peak as obtained from the histogram fit
    double GetHistogramVEMPeak() const { return fHistogramVEMPeak; }
    double GetHistogramVEMPeakError() const { return fHistogramVEMPeakError; }
    // final VEM_peak
    double GetVEMPeak() const { return fVEMPeak; }
    double GetVEMPeakError() const { return fVEMPeakError; }
    bool IsVEMPeakFromHistogram() const { return fIsVEMPeakFromHistogram; }

    // VEM_charge as estimated from the Online value
    double GetOnlineVEMCharge() const { return fOnlineVEMCharge; }
    double GetOnlineVEMChargeError() const { return fOnlineVEMChargeError; }
    // VEM_charge as obtained from the histogram fit
    double GetHistogramVEMCharge() const { return fHistogramVEMCharge; }
    double GetHistogramVEMChargeError() const { return fHistogramVEMChargeError; }
    // final VEM_charge
    double GetVEMCharge() const { return fVEMCharge; }
    double GetVEMChargeError() const { return fVEMChargeError; }
    bool IsVEMChargeFromHistogram() const { return fIsVEMChargeFromHistogram; }

    double GetAreaOverPeak() const { return fAreaOverPeak; }
    double GetTotalCharge() const { return fTotalCharge; }
    double GetTotalChargeError() const { return fTotalChargeError; }
    double GetPeakAmplitude() const { return fPeakAmplitude; }
    double GetShapeParameter() const { return fShapeParameter; }
    double GetMuonChargeSlope() const { return fMuonChargeSlope; }
    double GetMuonPulseDecayTime() const { return fMuonPulseDecayTime; }
    double GetMuonPulseDecayTimeError() const { return fMuonPulseDecayTimeError; }
    double GetGainRatio() const { return fGainRatio; }

    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 sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain) const
    { return fFADCSaturatedBins[gain]; }

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

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

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

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

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

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

    void SetOnlineVEMPeak(const double peak, const double peakErr)
    { fOnlineVEMPeak = peak; fOnlineVEMPeakError = peakErr; }
    void SetHistogramVEMPeak(const double peak, const double peakErr)
    { fHistogramVEMPeak = peak; fHistogramVEMPeakError = peakErr; }
    void SetVEMPeak(const double peak, const double peakErr)
    { fVEMPeak = peak; fVEMPeakError = peakErr; }
    void SetIsVEMPeakFromHistogram(const bool is) { fIsVEMPeakFromHistogram = is; }

    void SetOnlineVEMCharge(const double charge, const double chargeErr)
    { fOnlineVEMCharge = charge; fOnlineVEMChargeError = chargeErr; }
    void SetHistogramVEMCharge(const double charge, const double chargeErr)
    { fHistogramVEMCharge = charge; fHistogramVEMChargeError = chargeErr; }
    void SetVEMCharge(const double charge, const double chargeErr)
    { fVEMCharge = charge; fVEMChargeError = chargeErr; }
    void SetIsVEMChargeFromHistogram(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; }
    void SetMuonChargeSlope(const double slope) { fMuonChargeSlope = slope; }
    void SetMuonPulseDecayTime(const double time, const double tErr = 0)
    { fMuonPulseDecayTime = time; fMuonPulseDecayTimeError = tErr; }
    void SetGainRatio(const double da) { fGainRatio = da; }

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

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

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

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

    bool HasMuonProductionDepth() const { return bool(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 SetIsUsedInGlobalMPD(const bool is) { fIsUsedInGlobalMPD = is; }

    bool IsUsedInGlobalMPD() const { return fIsUsedInGlobalMPD; }

  private:
    PMTRecData() = default;
    ~PMTRecData() = default;

    void SetFADCTraceLength(const unsigned int traceLength) { fFADCTraceLength = traceLength; }
    void SetFADCBinSize(const double binSize) { fFADCBinSize = binSize; }

    double fRiseTime = 0;
    double fRiseTimeRMS = 0;
    double fRiseTimeCleaned = 0;
    double fRiseTimeCleanedRMS = 0;
    double fFallTime = 0;
    double fFallTimeRMS = 0;
    double fFallTimeCleaned = 0;
    double fFallTimeCleanedRMS = 0;
    double fT40 = 0;
    double fT50 = 0;
    //
    double fOnlineVEMPeak = 0;
    double fOnlineVEMPeakError = 0;
    double fHistogramVEMPeak = 0;
    double fHistogramVEMPeakError = 0;
    double fVEMPeak = 0;
    double fVEMPeakError = 0;
    bool fIsVEMPeakFromHistogram = false;
    //
    double fOnlineVEMCharge = 0;
    double fOnlineVEMChargeError = 0;
    double fHistogramVEMCharge = 0;
    double fHistogramVEMChargeError = 0;
    double fVEMCharge = 0;
    double fVEMChargeError = 0;
    bool fIsVEMChargeFromHistogram = false;
    //
    double fAreaOverPeak = 0;
    double fTotalCharge = 0;
    double fTotalChargeError = 0;
    double fPeakAmplitude = 0;
    double fShapeParameter = 0;
    double fMuonChargeSlope = 0;
    double fMuonPulseDecayTime = 0;
    double fMuonPulseDecayTimeError = 0;
    double fGainRatio = 0;

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

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

  private:
    utl::ShadowPtr<utl::TraceD> fFADCBaseline[sdet::PMTConstants::eNumberOfGains];
    double fFADCBaselineError[sdet::PMTConstants::eNumberOfGains] = { 0 };
    int fFADCBaselineWindow[sdet::PMTConstants::eNumberOfGains] = { 0 };
    FlatPieceCollection fFADCBaselineFlatPieces[sdet::PMTConstants::eNumberOfGains];
    int fFADCSaturatedBins[sdet::PMTConstants::eNumberOfGains] = { 0 };
    sdet::PMTConstants::PMTGain fGainUsed = sdet::PMTConstants::eNoGain;
    SignalSegmentCollection fRawSignals;
    SignalSegmentCollection fSignals;

    unsigned int fFADCTraceLength = 0;
    double fFADCBinSize = 0;

    utl::ShadowPtr<utl::TabulatedFunctionErrors> fMuonProductionDepth;

    friend class PMT;
    friend class utl::ShadowPtr<PMTRecData>;
    friend class io::PMTRecData_ROOT;

  };

}


#endif