PMTSimData.h

Go to the documentation of this file.

#ifndef _sevt_PMTSimData_h_
#define _sevt_PMTSimData_h_

#include <utl/ShadowPtr.h>
#include <utl/TimeStamp.h>
#include <utl/MultiTrace.h>
#include <sevt/StationConstants.h>
#include <utl/MultiTimeDistribution.h>
#include <utl/IteratorRange.h>
#include <sdet/PMTConstants.h>
#include <utl/ClassHelpers.h>

#include <boost/range/adaptor/map.hpp>

#include <vector>


#warning DV remove EventIO friendship
namespace io {
  class PMTSimData_ROOT;
}

namespace sevt {

  class PMT;


  class PMTSimData {

  private:
    typedef std::map<utl::TimeStamp, utl::MultiTraceI> TimeTraceMap;

  public:
    double GetTriggerVEMPeak(const bool isUUB) const { return isUUB ? fCompatibilityTriggerVEMPeak : fTriggerVEMPeak; }
    void SetTriggerVEMPeak(const double peak) { fTriggerVEMPeak = peak; }
    void SetCompatibilityTriggerVEMPeak(const double peak) { fCompatibilityTriggerVEMPeak = peak; }



    utl::TimeDistributionI& GetPETimeDistribution(const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fPETimeDistribution.GetTimeDistribution(source); }

    const utl::TimeDistributionI& GetPETimeDistribution(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fPETimeDistribution.GetTimeDistribution(source); }

    void MakePETimeDistribution(const StationConstants::SignalComponent source = StationConstants::eTotal);

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

    typedef utl::MultiTimeDistributionI::Iterator PETimeDistributionsIterator;

    typedef utl::MultiTimeDistributionI::ConstIterator ConstPETimeDistributionsIterator;

    PETimeDistributionsIterator PETimeDistributionsBegin() { return fPETimeDistribution.Begin(); }
    ConstPETimeDistributionsIterator PETimeDistributionsBegin() const { return fPETimeDistribution.Begin(); }
    PETimeDistributionsIterator PETimeDistributionsEnd() { return fPETimeDistribution.End(); }
    ConstPETimeDistributionsIterator PETimeDistributionsEnd() const { return fPETimeDistribution.End(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(PETimeDistributionsIterator, ConstPETimeDistributionsIterator, PETimeDistributions)




    utl::TimeDistributionD& GetBaseSignal(const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fBaseSignal.GetTimeDistribution(source); }

    const utl::TimeDistributionD& GetBaseSignal(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fBaseSignal.GetTimeDistribution(source); }

    void MakeBaseSignal(const StationConstants::SignalComponent source = StationConstants::eTotal);

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

    void ClearBaseSignals();

    typedef utl::MultiTimeDistributionD::Iterator BaseSignalsIterator;

    typedef utl::MultiTimeDistributionD::ConstIterator ConstBaseSignalsIterator;

    BaseSignalsIterator BaseSignalsBegin() { return fBaseSignal.Begin(); }
    ConstBaseSignalsIterator BaseSignalsBegin() const { return fBaseSignal.Begin(); }
    BaseSignalsIterator BaseSignalsEnd() { return fBaseSignal.End(); }
    ConstBaseSignalsIterator BaseSignalsEnd() const { return fBaseSignal.End(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(BaseSignalsIterator, ConstBaseSignalsIterator, BaseSignals)




    utl::TimeDistributionD& GetFilterSignal(const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fFilterSignal.GetTimeDistribution(source); }

    const utl::TimeDistributionD& GetFilterSignal(const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fFilterSignal.GetTimeDistribution(source); }

    void MakeFilterSignal(const StationConstants::SignalComponent source = StationConstants::eTotal);

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

    typedef utl::MultiTimeDistributionD::Iterator FilterSignalsIterator;

    typedef utl::MultiTimeDistributionD::ConstIterator ConstFilterSignalsIterator;

    FilterSignalsIterator FilterSignalsBegin() { return fFilterSignal.Begin(); }
    ConstFilterSignalsIterator FilterSignalsBegin() const { return fFilterSignal.Begin(); }
    FilterSignalsIterator FilterSignalsEnd() { return fFilterSignal.End(); }
    ConstFilterSignalsIterator FilterSignalsEnd() const { return fFilterSignal.End(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(FilterSignalsIterator, ConstFilterSignalsIterator, FilterSignals)




    utl::TimeDistributionI& GetFADCTrace(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                                         const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fFADCTrace[gain].GetTimeDistribution(source); }

    const utl::TimeDistributionI& GetFADCTrace(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                                               const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fFADCTrace[gain].GetTimeDistribution(source); }

    void MakeFADCTrace(StationConstants::SignalComponent source = StationConstants::eTotal);

    bool HasFADCTrace(StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fFADCTrace[sdet::PMTConstants::eHighGain].HasLabel(source); }


    typedef utl::MultiTimeDistributionI::Iterator FADCTraceIterator;

    typedef utl::MultiTimeDistributionI::ConstIterator ConstFADCTraceIterator;

    FADCTraceIterator FADCTracesBegin(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain)
    { return fFADCTrace[gain].Begin(); }
    ConstFADCTraceIterator FADCTracesBegin(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain) const
    { return fFADCTrace[gain].Begin(); }
    FADCTraceIterator FADCTracesEnd(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain)
    { return fFADCTrace[gain].End(); }
    ConstFADCTraceIterator FADCTracesEnd(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain) const
    { return fFADCTrace[gain].End(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG(FADCTraceIterator, ConstFADCTraceIterator, FADCTraces, const sdet::PMTConstants::PMTGain arg = sdet::PMTConstants::eHighGain)


    utl::TimeDistributionD& GetFADCTraceD(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                                          const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return fFADCTraceD[gain].GetTimeDistribution(source); }

    const utl::TimeDistributionD& GetFADCTraceD(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                                                const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return fFADCTraceD[gain].GetTimeDistribution(source); }


    typedef utl::MultiTimeDistributionD::Iterator FADCTraceDIterator;

    typedef utl::MultiTimeDistributionD::ConstIterator ConstFADCTraceDIterator;

    FADCTraceDIterator FADCTracesDBegin(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain)
    { return fFADCTraceD[gain].Begin(); }
    ConstFADCTraceDIterator FADCTracesDBegin(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain) const
    { return fFADCTraceD[gain].Begin(); }
    FADCTraceDIterator FADCTracesDEnd(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain)
    { return fFADCTraceD[gain].End(); }
    ConstFADCTraceDIterator FADCTracesDEnd(const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain) const
    { return fFADCTraceD[gain].End(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG(FADCTraceDIterator, ConstFADCTraceDIterator, FADCTracesD, const sdet::PMTConstants::PMTGain arg = sdet::PMTConstants::eHighGain)


    typedef decltype(std::begin(boost::adaptors::keys(TimeTraceMap()))) TriggerTimeIterator;

    TriggerTimeIterator TriggerTimesBegin() const { return std::begin(boost::adaptors::keys(fFADCTraces[sdet::PMTConstants::eHighGain])); }
    TriggerTimeIterator TriggerTimesEnd() const { return std::end(boost::adaptors::keys(fFADCTraces[sdet::PMTConstants::eHighGain])); }
    OFFLINE_MAKE_CONST_ITERATOR_RANGE(TriggerTimeIterator, TriggerTimes)

    utl::TraceI& GetFADCTrace(const utl::TimeStamp& stamp,
                              const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                              const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return GetMultiTrace(stamp, gain).GetTrace(source); }

    const utl::TraceI& GetFADCTrace(const utl::TimeStamp& stamp,
                                    const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                                    const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return GetMultiTrace(stamp, gain).GetTrace(source); }

    void MakeFADCTrace(const utl::TimeStamp& stamp,
                       StationConstants::SignalComponent source = StationConstants::eTotal);

    bool HasFADCTrace(const utl::TimeStamp& stamp,
                      StationConstants::SignalComponent source = StationConstants::eTotal) const;

    typedef utl::MultiTraceI::Iterator FADCTriggeredTraceIterator;
    typedef utl::MultiTraceI::ConstIterator ConstFADCTriggeredTraceIterator;

    FADCTriggeredTraceIterator FADCTriggeredTracesBegin(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain)
    { return GetMultiTrace(stamp, gain).Begin(); }
    FADCTriggeredTraceIterator FADCTriggeredTracesEnd(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain)
    { return GetMultiTrace(stamp, gain).End(); }
    ConstFADCTriggeredTraceIterator FADCTriggeredTracesBegin(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain) const
    { return GetMultiTrace(stamp, gain).Begin(); }
    ConstFADCTriggeredTraceIterator FADCTriggeredTracesEnd(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain) const
    { return GetMultiTrace(stamp, gain).End(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG2(FADCTriggeredTraceIterator, ConstFADCTriggeredTraceIterator, FADCTriggeredTraces, const utl::TimeStamp& arg1, const sdet::PMTConstants::PMTGain arg2)



    utl::TraceD& GetFADCTraceD(const utl::TimeStamp& stamp,
                               const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                               const StationConstants::SignalComponent source = StationConstants::eTotal)
    { return GetMultiTraceD(stamp, gain).GetTrace(source); }
    const utl::TraceD& GetFADCTraceD(const utl::TimeStamp& stamp,
                                     const sdet::PMTConstants::PMTGain gain = sdet::PMTConstants::eHighGain,
                                     const StationConstants::SignalComponent source = StationConstants::eTotal) const
    { return GetMultiTraceD(stamp, gain).GetTrace(source); }

    typedef utl::MultiTraceD::Iterator FADCTriggeredTraceDIterator;
    typedef utl::MultiTraceD::ConstIterator ConstFADCTriggeredTraceDIterator;

    FADCTriggeredTraceDIterator FADCTriggeredTracesDBegin(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain)
    { return GetMultiTraceD(stamp, gain).Begin(); }
    FADCTriggeredTraceDIterator FADCTriggeredTracesDEnd(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain)
    { return GetMultiTraceD(stamp, gain).End(); }
    ConstFADCTriggeredTraceDIterator FADCTriggeredTracesDBegin(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain) const
    { return GetMultiTraceD(stamp, gain).Begin(); }
    ConstFADCTriggeredTraceDIterator FADCTriggeredTracesDEnd(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain) const
    { return GetMultiTraceD(stamp, gain).End(); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG2(FADCTriggeredTraceDIterator, ConstFADCTriggeredTraceDIterator, FADCTriggeredTracesD, const utl::TimeStamp& arg1, const sdet::PMTConstants::PMTGain arg2)

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

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

    utl::MultiTraceI& GetMultiTrace(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain)
    { return OFFLINE_CAST_CONST_METHOD(GetMultiTrace(stamp, gain)); }
    const utl::MultiTraceI& GetMultiTrace(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain) const;

    utl::MultiTraceD& GetMultiTraceD(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain)
    { return OFFLINE_CAST_CONST_METHOD(GetMultiTraceD(stamp, gain)); }
    const utl::MultiTraceD& GetMultiTraceD(const utl::TimeStamp& stamp, const sdet::PMTConstants::PMTGain gain) const;

    double fTriggerVEMPeak = 0;
    double fCompatibilityTriggerVEMPeak = 0;

    utl::MultiTimeDistributionI fPETimeDistribution;
    utl::MultiTimeDistributionD fBaseSignal;
    utl::MultiTimeDistributionD fFilterSignal;

    unsigned int fFADCTraceLength = 0;
    double fFADCBinSize = 0;

    utl::MultiTimeDistributionI fFADCTrace[sdet::PMTConstants::eNumberOfGains];
    utl::MultiTimeDistributionD fFADCTraceD[sdet::PMTConstants::eNumberOfGains];

    typedef std::map<utl::TimeStamp, utl::MultiTraceI> TimeTraceIMap;
    typedef std::map<utl::TimeStamp, utl::MultiTraceD> TimeTraceDMap;
    TimeTraceIMap fFADCTraces[sdet::PMTConstants::eNumberOfGains];
    TimeTraceDMap fFADCTracesD[sdet::PMTConstants::eNumberOfGains];

    friend class sevt::PMT;
    friend class utl::ShadowPtr<sevt::PMTSimData>;
    friend class io::PMTSimData_ROOT;

  };

}


#endif