Clock.h

//-----------------------------------------------------------------------------
// $Id$
//-----------------------------------------------------------------------------
// Filename : TRGClock.h
// Section  : TRG
// Owner    : Yoshihito Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A class to represent a clock.
//-----------------------------------------------------------------------------
// $Log$
//-----------------------------------------------------------------------------
 
#ifndef TRGClock_FLAG_
#define TRGClock_FLAG_
 
#include <string>
#include "trg/trg/SignalVector.h"
 
namespace Belle2 {
  class TRGClock;
  class TRGTime;
}
 
namespace Belle2_GDL {
 
  //...This should be moved to GDL module...
  extern const Belle2::TRGClock GDLSystemClock;
}
 
namespace Belle2 {
  class TRGClock {
 
  public:
 
    TRGClock(const std::string& name,
             double offset,
             double frequency);
 
    TRGClock(const std::string& name,
             const TRGClock&,
             unsigned multiplicationFactor,
             unsigned divisionFactor = 1);
 
    virtual ~TRGClock();
 
  public:// Selectors
 
    const std::string& name(void) const;
 
    int position(double timing) const;
 
    int positionInSourceClock(double timing) const;
 
    double absoluteTime(int clockPosition) const;
 
    double overShoot(double timing) const;
 
    int unit(double period) const;
 
    double offset(void) const;
 
    double frequency(void) const;
 
    double phase(double timing) const;
 
    const TRGSignalVector& clockCounter(void) const;
 
    void dump(const std::string& message = "",
              const std::string& pre = "") const;
 
  public://
 
    int min(void) const;
 
    int max(void) const;
 
    double minTiming(void) const;
 
    double maxTiming(void) const;
 
    TRGTime minTRGTime(bool edge) const;
 
    TRGTime maxTRGTime(bool edge) const;
 
  private:
 
    const std::string _name;
 
    const TRGClock* _source;
 
    const unsigned _multi;
 
    const unsigned _div;
 
    const double _offset;
 
    const double _frequency;
 
    const double _cycle;
 
    int _min;
 
    int _max;
 
    mutable TRGSignalVector* _clockCounter;
  };
 
//-----------------------------------------------------------------------------
 
  inline
  double
  TRGClock::offset(void) const
  {
    return _offset;
  }
 
  inline
  const std::string&
  TRGClock::name(void) const
  {
    return _name;
  }
 
  inline
  double
  TRGClock::minTiming(void) const
  {
//    return _min * _cycle + _offset;
    return _min * _cycle;
  }
 
  inline
  double
  TRGClock::maxTiming(void) const
  {
//    return _max * _cycle + _offset;
    return _max * _cycle;
  }
 
  inline
  int
  TRGClock::unit(double a) const
  {
    return int(a / _cycle) + 1;
  }
 
  inline
  double
  TRGClock::frequency(void) const
  {
    return _frequency;
  }
 
  inline
  int
  TRGClock::min(void) const
  {
    return _min;
  }
 
  inline
  int
  TRGClock::max(void) const
  {
    return _max;
  }
 
  inline
  int
  TRGClock::positionInSourceClock(double a) const
  {
    return _source->position(a);
  }
 
} // namespace Belle2
 
#endif /* TRGClock_FLAG_ */