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(): ElecClock(0, kTIME_MAX, 1e9) {}

    ElecClock(double time, double frame_period, double frequency)
      : fTime(time),
        fFramePeriod(frame_period),
        fFrequency(frequency)
    { 
      if( fFrequency <= 0 ) throw detinfo::DetectorClocksException("Negative frequency is prohibited!"); 
    }
    
  protected:

    //-- Attribute variables --//

    double fTime;        
    double fFramePeriod; 
    double fFrequency;   
    
  public:

    //-- Setters --//

    void SetTime(double time) { fTime = time; }

    void SetTime(int sample,
                 int frame)
    { fTime = Time(sample, frame); }

    void SetTime(unsigned int sample,
                 unsigned int frame)
    { SetTime(int(sample),int(frame)); }

    void SetTime(int ticks)
    { fTime = Time(ticks,0); }

    void SetTime(unsigned int ticks)
    { SetTime(int(ticks)); }

    //-- Getters --//

    double Time() const { return fTime; }

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

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

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

    double Frequency() const { return fFrequency; }

    double FramePeriod() const { return fFramePeriod; }

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

    int Ticks(double time) const { return (int)(time * fFrequency); }

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

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

    int Sample(double time) const { return (int)((time - Frame(time) * fFramePeriod) * fFrequency); }

    int Sample(int tick) const { return (tick % (int)(FrameTicks())); }

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

    int Frame(double time) const { return (int)(time / fFramePeriod); }

    int Frame(int tick) const { return (tick / (int)(FrameTicks())); }

    unsigned int FrameTicks() const { return (int)(fFramePeriod * fFrequency);}

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

    
    //-- operators --//

    
    ElecClock& operator++()    { fTime += 1./fFrequency; return *this;}
    
    ElecClock  operator++(int) {ElecClock tmp(*this); operator++(); return tmp;}
    
    ElecClock& operator--()    { fTime -= 1./fFrequency; return *this;}
    
    ElecClock  operator--(int) {ElecClock tmp(*this); operator--(); return tmp;}
    
    ElecClock& operator+=(const double &rhs) { fTime += rhs; return *this;}
    ElecClock& operator-=(const double &rhs) { fTime -= rhs; return *this;}
    
    ElecClock& operator+=(const float  &rhs) { fTime += (double)rhs; return *this;}
    ElecClock& operator-=(const float  &rhs) { fTime -= (double)rhs; return *this;}
    
    ElecClock& operator+=(const int &rhs) { fTime += Time(rhs); return *this;}
    ElecClock& operator-=(const int &rhs) { fTime -= Time(rhs); return *this;}
    
    ElecClock& operator+=(const unsigned int &rhs) { fTime += Time((int)rhs); return *this;}
    ElecClock& operator-=(const unsigned int &rhs) { fTime -= Time((int)rhs); return *this;}
    
    ElecClock& operator+=(const ElecClock& rhs) { fTime += rhs.Time(); return *this;}
    
    ElecClock& operator-=(const ElecClock& rhs) { fTime -= rhs.Time(); return *this;}

    inline ElecClock operator+(const ElecClock& rhs)
    { return ElecClock(fTime + rhs.Time(),fFramePeriod,fFrequency); }

    inline ElecClock operator-(const ElecClock& rhs)
    { return ElecClock(fTime - rhs.Time(),fFramePeriod,fFrequency); }
    
    
    inline bool operator<  (const ElecClock& rhs) const { return fTime <  rhs.Time(); }
    inline bool operator>  (const ElecClock& rhs) const { return fTime >  rhs.Time(); }
    inline bool operator<= (const ElecClock& rhs) const { return fTime <= rhs.Time(); }
    inline bool operator>= (const ElecClock& rhs) const { return fTime >= rhs.Time(); }

  }; // class ElecClock

}
#endif
 // end of doxygen group