ElecClock.h

Go to the documentation of this file.

#ifndef ElecClock_H
#define ElecClock_H

#include "ClockConstants.h"
#include "DetectorClocksException.h"

namespace detinfo {
  class ElecClock {
  public:
    ElecClock(double const time, double const frame_period, double const frequency)
      : ElecClock{time, frame_period, frequency, std::nothrow}
    {
      if (fFrequency <= 0)
        throw detinfo::DetectorClocksException("Only positive frequency allowed.");
    }

    constexpr ElecClock WithTime(double const time) const noexcept
    {
      return {time, fFramePeriod, fFrequency, std::nothrow};
    }

    constexpr ElecClock WithTick(int const tick, int const frame = 0) const noexcept
    {
      return {Time(tick, frame), fFramePeriod, fFrequency, std::nothrow};
    }

    constexpr ElecClock AdvanceTimeBy(double const time) const noexcept
    {
      return {fTime + time, fFramePeriod, fFrequency, std::nothrow};
    }

    constexpr ElecClock AdvanceTicksBy(int const ticks) const noexcept
    {
      return {fTime + Time(ticks), fFramePeriod, fFrequency, std::nothrow};
    }

    constexpr double Time() const noexcept { return fTime; }

    constexpr double Time(int const sample, int const frame) const noexcept
    {
      return (sample / fFrequency + frame * fFramePeriod);
    }

    constexpr double Time(double const time) const noexcept
    {
      return Time(Sample(time), Frame(time));
    }

    constexpr double Time(int const ticks) const noexcept { return ticks / fFrequency; }

    constexpr double Frequency() const { return fFrequency; }

    constexpr double FramePeriod() const noexcept { return fFramePeriod; }

    constexpr int Ticks() const noexcept { return Ticks(fTime); }

    constexpr int Ticks(double const time) const noexcept
    {
      return static_cast<int>(time * fFrequency);
    }

    constexpr int Ticks(int const sample, int const frame) const noexcept
    {
      return sample + frame * FrameTicks();
    }

    constexpr int Sample() const noexcept { return Sample(fTime); }

    constexpr int Sample(double const time) const noexcept
    {
      return static_cast<int>((time - Frame(time) * fFramePeriod) * fFrequency);
    }

    constexpr int Sample(int const tick) const noexcept
    {
      return (tick % static_cast<int>(FrameTicks()));
    }

    constexpr int Frame() const noexcept { return Frame(fTime); }

    constexpr int Frame(double const time) const noexcept
    {
      return static_cast<int>(time / fFramePeriod);
    }

    constexpr int Frame(int const tick) const noexcept
    {
      return (tick / static_cast<int>(FrameTicks()));
    }

    constexpr unsigned int FrameTicks() const noexcept
    {
      return static_cast<unsigned int>(fFramePeriod * fFrequency);
    }

    constexpr double TickPeriod() const noexcept { return 1. / fFrequency; }

    //-- comparators --//

    constexpr bool operator<(const ElecClock& rhs) const noexcept { return fTime < rhs.Time(); }
    constexpr bool operator>(const ElecClock& rhs) const noexcept { return fTime > rhs.Time(); }
    constexpr bool operator<=(const ElecClock& rhs) const noexcept { return fTime <= rhs.Time(); }
    constexpr bool operator>=(const ElecClock& rhs) const noexcept { return fTime >= rhs.Time(); }

  private:
    constexpr ElecClock(double const time,
                        double const frame_period,
                        double const frequency,
                        std::nothrow_t) noexcept
      : fTime(time), fFramePeriod(frame_period), fFrequency(frequency)
    {}

    double fTime{};                 
    double fFramePeriod{kTIME_MAX}; 
    double fFrequency{1e9};         

  }; // class ElecClock

}
#endif
 // end of doxygen group