Belle II Software  release-05-01-25
Clock.cc
1 //-----------------------------------------------------------------------------
2 // $Id$
3 //-----------------------------------------------------------------------------
4 // Filename : TRGClock.h
5 // Section : TRG
6 // Owner : Yoshihito Iwasaki
7 // Email : yoshihito.iwasaki@kek.jp
8 //-----------------------------------------------------------------------------
9 // Description : A class to represent a clock.
10 //-----------------------------------------------------------------------------
11 // $Log$
12 //-----------------------------------------------------------------------------
13 
14 #include <limits>
15 #include <iostream>
16 #include <cmath>
17 #include "trg/trg/Clock.h"
18 #include "trg/trg/Time.h"
19 #include "trg/trg/Signal.h"
20 #include "trg/trg/Utilities.h"
21 
22 using namespace std;
23 
24 namespace Belle2_GDL {
25 
26  //...This should be moved to GDL module...
27  const Belle2::TRGClock GDLSystemClock("GDL system clock", 0, 125.000);
28 }
29 
30 namespace Belle2 {
36  TRGClock::TRGClock(const string& name,
37  double offset,
38  double frequency)
39  : _name(name),
40  _source(0),
41  _multi(1),
42  _div(1),
43  _offset(offset),
44  _frequency(frequency),
45  _cycle(1000 / frequency),
46 // _min(int(TRGTime::min() / frequency)),
47 // _max(int(TRGTime::max() / frequency)),
48 // _min(numeric_limits<int>::min() + 100),
49 // _max(numeric_limits<int>::max() - 100),
50  _min(numeric_limits<int>::min() / 16),
51  _max(numeric_limits<int>::max() / 16),
52  _clockCounter(0)
53  {
54 
55  if (this != & Belle2_GDL::GDLSystemClock) {
56  if (Belle2_GDL::GDLSystemClock.minTiming() > minTiming())
57  _min = int((Belle2_GDL::GDLSystemClock.minTiming() - _offset)
58  / _cycle);
59  if (Belle2_GDL::GDLSystemClock.maxTiming() < maxTiming())
60  _max = int((Belle2_GDL::GDLSystemClock.maxTiming() - _offset)
61  / _cycle);
62  }
63  }
64 
65  TRGClock::TRGClock(const string& name,
66  const TRGClock& source,
67  unsigned multiplicationFactor,
68  unsigned divisionFactor)
69  : _name(name),
70  _source(& source),
71  _multi(multiplicationFactor),
72  _div(divisionFactor),
73  _offset(source._offset),
74  _frequency(source._frequency *
75  double(multiplicationFactor) /
76  double(divisionFactor)),
77  _cycle(source._cycle /
78  double(multiplicationFactor) *
79  double(divisionFactor)),
80  _min(source._min * int(multiplicationFactor) / int(divisionFactor)),
81  _max(source._max * int(multiplicationFactor) / int(divisionFactor)),
82  _clockCounter(0)
83  {
84  }
85 
87  {
88  if (_clockCounter)
89  delete _clockCounter;
90  }
91 
92  void
93  TRGClock::dump(const string&,
94  const string& pre) const
95  {
96  cout << pre << _name;
97  if (_source) {
98  cout << ":sync'd to " << _source->name() << endl;
99  cout << pre << " multiplication factor=" << _multi << endl;
100  cout << pre << " division factor =" << _div << endl;
101  } else {
102  cout << endl;
103  }
104 
105  cout << pre << " offset :" << _offset << endl
106  << pre << " freq(MHz):" << _frequency << endl
107  << pre << " cycle(ns):" << _cycle << endl
108  << pre << " min pos :" << _min << endl
109  << pre << " max pos :" << _max << endl
110  << pre << " min(ns) :" << minTiming() << endl
111  << pre << " max(ns) :" << maxTiming() << endl;
112 
113  cout << pre << " numeric limit of int (min,max="
114  << numeric_limits<int>::min() << ","
115  << numeric_limits<int>::max() << ")" << endl;
116  }
117 
118  int
119  TRGClock::position(double t) const
120  {
121 #ifdef TRG_DEBUG
122  if ((t < minTiming()) || (t > maxTiming()))
123  cout << "TRGClock::unit(" << _name
124  << ") !!! out of time window : min=" << minTiming()
125  << ",max=" << maxTiming() << ",given value=" << t << endl;
126 // cout << "t,offset,unit=" << t << "," << _offset << "," << int((t
127 // - _offset) / _cycle) << endl;
128 #endif
129  return floor((t - _offset) / _cycle);
130  }
131 
132  double
134  {
135  return double(t) * _cycle + _offset;
136  }
137 
138  double
139  TRGClock::overShoot(double t) const
140  {
141  return (t - _offset) - _cycle * double(position(t));
142  }
143 
144  TRGTime
145  TRGClock::minTRGTime(bool edge) const
146  {
147  TRGTime a(minTiming(), edge, * this, _name + "_min");
148  return a;
149  }
150 
151  TRGTime
152  TRGClock::maxTRGTime(bool edge) const
153  {
154  TRGTime a(maxTiming(), edge, * this, _name + "_max");
155  return a;
156  }
157 
158  double
159  TRGClock::phase(double a) const
160  {
161 // return overShoot(a) / _cycle * 360;
162  const double pos = (a - _offset) / _cycle;
163  const double pos0 = double(int(pos));
164  const double dif = pos - pos0;
165  // std::cout << "a,offset,pos,pos0,dif=" << a << "," << _offset << ","
166  // << pos << "," << pos0 << "," << dif << std::endl;
167  return dif * 360;
168  }
169 
170  const TRGSignalVector&
172  {
173 
174  if (_clockCounter)
175  return * _clockCounter;
176 
177  _clockCounter = new TRGSignalVector(name() + " counter", * this);
178 
179  //...5 bit clock counter...
180  unsigned cicle = 2;
181  for (int i = 0; i < 5; i++) {
182  TRGSignal s("tmp", * this);
183 
184  //...From 0 to 1280*5...
185 // const int maxN = 1280 * 5;
186  const int maxN = 400;
187  for (int j = 0; j < maxN; j++) {
188  if (((j - cicle / 2) % cicle) == 0)
189  s.set(j, j + cicle / 2);
190  }
191 
192  //...Append this bit...
193  s.name("ClockCounterBit" + TRGUtilities::itostring(i));
194  (* _clockCounter) += s;
195 
196  //...Double cicle...
197  cicle *= 2;
198  }
199 
200  return * _clockCounter;
201  }
202 
204 } // namespace Belle2
Belle2::TRGSignal
A class to represent a digitized signal. Unit is nano second.
Definition: Signal.h:28
Belle2::TRGClock::_source
const TRGClock * _source
Clock source.
Definition: Clock.h:124
Belle2::TRGClock::_min
int _min
Clock min. count.
Definition: Clock.h:142
Belle2::TRGClock::clockCounter
const TRGSignalVector & clockCounter(void) const
returns the clock counter.
Definition: Clock.cc:171
Belle2::TRGClock::name
const std::string & name(void) const
returns name.
Definition: Clock.h:162
Belle2::TRGClock::_cycle
const double _cycle
Clock cycle in nano second.
Definition: Clock.h:139
Belle2::TRGClock::dump
void dump(const std::string &message="", const std::string &pre="") const
dumps contents.
Definition: Clock.cc:93
Belle2::TRGClock::minTRGTime
TRGTime minTRGTime(bool edge) const
returns min. TRGtime with clock.
Definition: Clock.cc:145
Belle2::TRGClock::_div
const unsigned _div
Division factor.
Definition: Clock.h:130
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TRGClock::minTiming
double minTiming(void) const
returns min. timing.
Definition: Clock.h:169
Belle2::TRGClock::overShoot
double overShoot(double timing) const
returns over shoot.
Definition: Clock.cc:139
Belle2::TRGClock::_frequency
const double _frequency
Frequency in MHz.
Definition: Clock.h:136
Belle2::TRGClock::maxTRGTime
TRGTime maxTRGTime(bool edge) const
returns max. TRGtime with clock.
Definition: Clock.cc:152
Belle2::TRGClock::_max
int _max
Clock max. count.
Definition: Clock.h:145
Belle2::TRGClock::maxTiming
double maxTiming(void) const
returns max. timing.
Definition: Clock.h:177
Belle2::TRGClock::position
int position(double timing) const
returns clock position.
Definition: Clock.cc:119
Belle2::TRGClock::~TRGClock
virtual ~TRGClock()
Destructor.
Definition: Clock.cc:86
Belle2::TRGClock::TRGClock
TRGClock(const std::string &name, double offset, double frequency)
Constructor. "offset" is in unit of ns. "frequency" is in unit of MHz.
Definition: Clock.cc:36
Belle2::TRGClock::_name
const std::string _name
Name.
Definition: Clock.h:121
Belle2::TRGUtilities::itostring
static std::string itostring(int i)
converts int to string. (Use boost::lexical_cast)
Belle2::TRGClock::_clockCounter
TRGSignalVector * _clockCounter
Clock counter.
Definition: Clock.h:148
Belle2::TRGClock::absoluteTime
double absoluteTime(int clockPosition) const
returns absolute time of clock position
Definition: Clock.cc:133
Belle2::TRGClock::_multi
const unsigned _multi
Multiplication factor.
Definition: Clock.h:127
Belle2::TRGClock::phase
double phase(double timing) const
returns phase of given timing in degree (0 to 360).
Definition: Clock.cc:159
Belle2::TRGTime
A class to represent a signal timing in the trigger system.
Definition: Time.h:30
Belle2::TRGClock::_offset
const double _offset
Clock offset in nano second.
Definition: Clock.h:133
Belle2::TRGClock
A class to represent a digitized signal. Unit is nano second.
Definition: Clock.h:43
Belle2::TRGSignalVector
A class to represent a bundle of digitized signals.
Definition: SignalVector.h:31