/*!
  \file
  PMT data

  \version $Id: PMT.h 23433 2013-04-16 14:38:29Z schulz-a $
*/

#ifndef _sevt_PMT_h_
#define _sevt_PMT_h_

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

#include <sevt/StationConstants.h>
#include <sevt/PMTConstants.h>
#include <sevt/PMTSimData.h>
#include <sevt/PMTRecData.h>
#include <sevt/PMTCalibData.h>
#include <sevt/PMTQuality.h>


namespace sevt {

  class Station;


  /**
     \class PMT PMT.h sevt/PMT.h
     \brief class to hold data at %PMT level
     \ingroup sevt
  */

  class PMT {

  public:
    typedef PMTConstants::PMTGain PMTGain;
    static const PMTGain eHighGain = PMTConstants::eHighGain;
    static const PMTGain eLowGain = PMTConstants::eLowGain;

    /// Return Id of the PMT
    unsigned int GetId() const { return fId; }

    /// Return Id of the station to which this PMT belongs
    int GetStationId() const { return fStationId; }

    /// Get object containing PMT simulated data
    PMTSimData& GetSimData()
    { return *fPMTSimData; }
    const PMTSimData& GetSimData() const
    { return *fPMTSimData; }

    /// Make PMT simulated data object
    void MakeSimData();

    /// Check for existence of PMT simulated data object
    bool HasSimData() const { return fPMTSimData; }

    /// Get object containing PMT reconstructed data
    PMTRecData& GetRecData()
    { return *fPMTRecData; }
    const PMTRecData& GetRecData() const
    { return *fPMTRecData; }

    /// Make PMT reconstructed data object
    void MakeRecData();

    /// Check for existenc of PMT reconstructed data object
    bool HasRecData() const { return fPMTRecData; }

    /// Get object containing PMT calibration data
    PMTCalibData& GetCalibData()
    { return *fPMTCalibData; }
    const PMTCalibData& GetCalibData() const
    { return *fPMTCalibData; }

    /// Make PMT calibration data object
    void MakeCalibData();

    /// Check for existence of PMT calibration data object
    bool HasCalibData() const { return fPMTCalibData; }

    /// Get object containing PMT Quality bits
    PMTQuality& GetQuality()
    { return *fPMTQuality; }
    const PMTQuality& GetQuality() const
    { return *fPMTQuality; }

    void MakeQuality();

    /// Check for existence of PMT Quality (anode mask and/or raining) data object
    bool HasQuality() const { return fPMTQuality; }

    /// Get FADC traces in ADC counts, optionally specifying the channel and/or source
    /** In the case of simulation, this is the FADC trace after local
  trigger simulation */
    utl::TraceI& GetFADCTrace(const PMTGain gain = eHighGain,
                              const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fFADCTrace[gain]->GetTrace(source); }
    const utl::TraceI& GetFADCTrace(const PMTGain gain = eHighGain,
                                    const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fFADCTrace[gain]->GetTrace(source); }

    /// Make a FADC trace. Trace source may be specified.
    void MakeFADCTrace(const StationConstants::SignalComponent source = StationConstants::eTotal);

    /// Check if a FADC trace exists. Trace source may be specified.
    bool HasFADCTrace(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fFADCTrace[eHighGain]->HasLabel(source); }

    const utl::MultiTraceI& GetMultiFADCTrace(const PMTGain gain = eHighGain)
    { return *fFADCTrace[gain]; }

    /** iterator over available high gain channel FADC sources.
  Returns a LabeledTrace when dereferenced*/
    typedef utl::MultiTraceI::Iterator FADCTraceIterator;
    typedef utl::MultiTraceI::ConstIterator ConstFADCTraceIterator;

    FADCTraceIterator FADCTracesBegin(const PMTGain gain = eHighGain)
    { return fFADCTrace[gain]->Begin(); }
    FADCTraceIterator FADCTracesEnd(const PMTGain gain = eHighGain)
    { return fFADCTrace[gain]->End(); }
    ConstFADCTraceIterator FADCTracesBegin(const PMTGain gain = eHighGain) const
    { return fFADCTrace[gain]->Begin(); }
    ConstFADCTraceIterator FADCTracesEnd(const PMTGain gain = eHighGain) const
    { return fFADCTrace[gain]->End(); }

    // these should be removed in FatBastard
    FADCTraceIterator FADCHGTracesBegin() { return fFADCTrace[eHighGain]->Begin(); }
    FADCTraceIterator FADCHGTracesEnd() { return fFADCTrace[eHighGain]->End(); }
    ConstFADCTraceIterator FADCHGTracesBegin() const { return fFADCTrace[eHighGain]->Begin(); }
    ConstFADCTraceIterator FADCHGTracesEnd() const { return fFADCTrace[eHighGain]->End(); }

    FADCTraceIterator FADCLGTracesBegin() { return fFADCTrace[eLowGain]->Begin(); }
    FADCTraceIterator FADCLGTracesEnd() { return fFADCTrace[eLowGain]->End(); }
    ConstFADCTraceIterator FADCLGTracesBegin() const { return fFADCTrace[eLowGain]->Begin(); }
    ConstFADCTraceIterator FADCLGTracesEnd() const { return fFADCTrace[eLowGain]->End(); }

    // \name Simulated FADC double-valued traces. Get FADC traces in ADC counts, optionally specifying the channel and/or source. In the case of simulation, this is the FADC trace after local trigger simulation.
    //@{
    utl::TraceD& GetFADCTraceD(const PMTGain gain = eHighGain,
                               const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fFADCTraceD[gain]->GetTrace(source); }
    const utl::TraceD& GetFADCTraceD(const PMTGain gain = eHighGain,
                                     const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fFADCTraceD[gain]->GetTrace(source); }

    const utl::MultiTraceD& GetMultiFADCTraceD(const PMTGain gain = eHighGain)
    { return *fFADCTraceD[gain]; }

    /** iterator over available high gain channel FADC sources.
  Returns a LabeledTrace when dereferenced*/
    typedef utl::MultiTraceD::Iterator FADCTraceIteratorD;
    typedef utl::MultiTraceD::ConstIterator ConstFADCTraceIteratorD;

    FADCTraceIteratorD FADCTracesDBegin(const PMTGain gain = eHighGain)
    { return fFADCTraceD[gain]->Begin(); }
    FADCTraceIteratorD FADCTracesDEnd(const PMTGain gain = eHighGain)
    { return fFADCTraceD[gain]->End(); }
    ConstFADCTraceIteratorD FADCTracesDBegin(const PMTGain gain = eHighGain) const
    { return fFADCTraceD[gain]->Begin(); }
    ConstFADCTraceIteratorD FADCTracesDEnd(const PMTGain gain = eHighGain) const
    { return fFADCTraceD[gain]->End(); }

    //@}

  private:
    PMT(const int stationId, const unsigned int id) : fStationId(stationId), fId(id) { }
    ~PMT() { }

    int fStationId;
    unsigned int fId;

    utl::ShadowPtr<PMTSimData> fPMTSimData;    // From simulation
    utl::ShadowPtr<PMTRecData> fPMTRecData;
    utl::ShadowPtr<PMTCalibData> fPMTCalibData;
    utl::ShadowPtr<PMTQuality> fPMTQuality;

    utl::InitializedShadowPtr<utl::MultiTraceI> fFADCTrace[PMTConstants::eNumberOfGains];
    utl::InitializedShadowPtr<utl::MultiTraceD> fFADCTraceD[PMTConstants::eNumberOfGains];

    friend class Station;

  };

}


#endif

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