DetectorClocksData.h

Go to the documentation of this file.

#ifndef LARDATAALG_DETECTORINFO_DETECTORCLOCKSDATA_H
#define LARDATAALG_DETECTORINFO_DETECTORCLOCKSDATA_H

#include "lardataalg/DetectorInfo/ElecClock.h"

namespace detinfo {

  class DetectorClocksData {
  public:
    DetectorClocksData(double const g4_ref_time,
                       double const trigger_offset_tpc,
                       double const trig_time,
                       double const beam_time,
                       ElecClock const& tpc_clock,
                       ElecClock const& optical_clock,
                       ElecClock const& trigger_clock,
                       ElecClock const& external_clock)
      : fTriggerTime{trig_time}
      , fTriggerOffsetTPC{trigger_offset_tpc}
      , fBeamGateTime{beam_time}
      , fG4RefTime{g4_ref_time}
      , fTPCClock{tpc_clock}
      , fOpticalClock{optical_clock}
      , fTriggerClock{trigger_clock}
      , fExternalClock{external_clock}
    {}

    double TriggerOffsetTPC() const
    {
      if (fTriggerOffsetTPC < 0)
        return fTriggerOffsetTPC;
      else
        return -fTriggerOffsetTPC / fTPCClock.Frequency(); // convert ticks to
                                                           // us
    }

    double TPCTime() const { return doTPCTime(); }

    double G4ToElecTime(double const g4_time) const { return g4_time * 1.e-3 - fG4RefTime; }

    double TriggerTime() const { return fTriggerTime; }

    double BeamGateTime() const { return fBeamGateTime; }

    //
    // Getters of TPC ElecClock
    //
    ElecClock const& TPCClock() const noexcept { return fTPCClock; }

    //
    // Getters of Optical ElecClock
    //
    ElecClock const& OpticalClock() const noexcept { return fOpticalClock; }

    //
    // Getters of Trigger ElecClock
    //
    ElecClock const& TriggerClock() const noexcept { return fTriggerClock; }

    //
    // Getters of External ElecClock
    //
    ElecClock const& ExternalClock() const noexcept { return fExternalClock; }

    //
    // Getters for time [us] w.r.t. trigger given information from waveform
    //

    double TPCTick2TrigTime(double const tick) const
    {
      return fTPCClock.TickPeriod() * tick + TriggerOffsetTPC();
    }
    double TPCTick2BeamTime(double const tick) const
    {
      return TPCTick2TrigTime(tick) + TriggerTime() - BeamGateTime();
    }
    double OpticalTick2TrigTime(double const tick, size_t const sample, size_t const frame) const
    {
      return fOpticalClock.TickPeriod() * tick + fOpticalClock.Time(sample, frame) - TriggerTime();
    }
    double OpticalTick2BeamTime(double const tick, size_t const sample, size_t const frame) const
    {
      return fOpticalClock.TickPeriod() * tick + fOpticalClock.Time(sample, frame) - BeamGateTime();
    }
    double ExternalTick2TrigTime(double const tick, size_t const sample, size_t const frame) const
    {
      return fExternalClock.TickPeriod() * tick + fExternalClock.Time(sample, frame) -
             TriggerTime();
    }
    double ExternalTick2BeamTime(double const tick, size_t const sample, size_t const frame) const
    {
      return fExternalClock.TickPeriod() * tick + fExternalClock.Time(sample, frame) -
             BeamGateTime();
    }

    double Time2Tick(double const time) const { return doTime2Tick(time); }

    //
    // Getters for time [tdc] (electronics clock counting ... in double
    // precision)
    //

    double TPCTick2TDC(double const tick) const
    {
      return (doTPCTime() / fTPCClock.TickPeriod() + tick);
    }
    double TPCG4Time2TDC(double const g4time) const
    {
      return G4ToElecTime(g4time) / fTPCClock.TickPeriod();
    }
    double OpticalTick2TDC(double const tick, size_t const sample, size_t const frame) const
    {
      return fOpticalClock.Ticks(sample, frame) + tick;
    }
    double OpticalG4Time2TDC(double const g4time) const
    {
      return G4ToElecTime(g4time) / fOpticalClock.TickPeriod();
    }
    double ExternalTick2TDC(double const tick, size_t const sample, size_t const frame) const
    {
      return fExternalClock.Ticks(sample, frame) + tick;
    }
    double ExternalG4Time2TDC(double const g4time) const
    {
      return G4ToElecTime(g4time) / fExternalClock.TickPeriod();
    }

    //
    // Getters for time [us] (electronics clock counting ... in double
    // precision)
    //
    double TPCTick2Time(double const tick) const
    {
      return doTPCTime() + tick * fTPCClock.TickPeriod();
    }
    double OpticalTick2Time(double const tick, size_t const sample, size_t const frame) const
    {
      return fOpticalClock.Time(sample, frame) + tick * fOpticalClock.TickPeriod();
    }
    double ExternalTick2Time(double const tick, size_t const sample, size_t const frame) const
    {
      return fExternalClock.Time(sample, frame) + tick * fExternalClock.TickPeriod();
    }

    //
    // Getters for time [ticks] (waveform index number)
    //

    double TPCTDC2Tick(double const tdc) const
    {
      return (tdc - doTPCTime() / fTPCClock.TickPeriod());
    }
    double TPCG4Time2Tick(double const g4time) const
    {
      return (G4ToElecTime(g4time) - doTPCTime()) / fTPCClock.TickPeriod();
    }

    template <typename Stream>
    void debugReport(Stream& out) const
    {
      out << "Trigger  time @ " << fTriggerTime << "\nBeamGate time @ " << fBeamGateTime
          << "\nTrigOffsetTPC @ " << TriggerOffsetTPC() << "\nG4RefTime     @ " << fG4RefTime
          << "\nTPC     Freq. @ " << fTPCClock.Frequency() << "\nOptical Freq. @ "
          << fOpticalClock.Frequency() << "\nTrigger Freq. @ " << fTriggerClock.Frequency()
          << "\nExternal Freq. @ " << fExternalClock.Frequency()
          << "\nTPC start tick [tdc]             : " << TPCTick2TDC(0)
          << "\nTPC start tick from trigger [us] : " << TPCTick2TrigTime(0)
          << "\nTPC start tick from beam    [us] : " << TPCTick2BeamTime(0)
          << "\nTPC tdc=0 in tick     : " << TPCTDC2Tick(0)
          << "\nTPC G4 time 0 in tick : " << TPCG4Time2Tick(0)
          << "\nTrigger in TPC tick   : " << Time2Tick(TriggerTime()) << "\n";
    }

  private:
    double fTriggerTime;

    double fTriggerOffsetTPC;

    double fBeamGateTime;

    double fG4RefTime;

    ElecClock fTPCClock;
    ElecClock fOpticalClock;
    ElecClock fTriggerClock;
    ElecClock fExternalClock;

    double doTPCTime() const { return fTriggerTime + fTriggerOffsetTPC; }

    double doTime2Tick(double const time) const
    {
      return (time - doTPCTime()) / fTPCClock.TickPeriod();
    }

  }; // class DetectorClocksData

  inline int trigger_offset(DetectorClocksData const& data)
  {
    return data.TPCClock().Ticks(data.TriggerOffsetTPC() * -1.);
  }

  inline double sampling_rate(DetectorClocksData const& data)
  {
    return data.TPCClock().TickPeriod() * 1.e3;
  }

} // namespace detinfo

#endif // LARDATAALG_DETECTORINFO_DETECTORCLOCKSDATA_H